src/Core/Editors/OLCEditor.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "Account.h"
  22 #include "Array.h"
  23 #include "Assert.h"
  24 #include "Command.h"
  25 #include "DatabaseMgr.h"
  26 #include "EditorOLC.h"
  27 #include "OLCEditor.h"
  28 #include "Permission.h"
  29 #include "Savable.h"
  30 #include "StringUtilities.h"
  31 #include "UBSocket.h"
  32
  33 typedef OLCEditor E;
  34 typedef CommandObject<E> O;
  35 typedef CommandBinding<E> B;
  36
  37 static O listCommands("Commands", &E::listCommands);
  38 static O newSavable("New", &E::newSavable);
  39 static O deleteSavable("Delete", &E::deleteSavable);
  40 static O editSavable("Edit", &E::editSavable);
  41 static O quitEditor("Quit", &E::quitEditor);
  42 static O doneEditing("Done", &E::doneEditing);
  43 static O discardChanges("Discard", &E::discardChanges);
  44 static O listSavable("List", &E::listSavable);
  45
  46 static const B commands[] = {
  47         B("?", listCommands),
  48         B("discard", discardChanges),
  49         B("done", doneEditing),
  50         B("edit", editSavable),
  51         B("erase", deleteSavable),
  52         B("list", listSavable),
  53         B("new", newSavable),
  54         B("quit", quitEditor),
  55 };
  56
  57 OLCEditor::OLCEditor(UBSocket* sock) :
  58 Editor(sock),
  59 m_olccommands(commands, array_size(commands))
  60 {
  61
  62 }
  63
  64 OLCEditor::~OLCEditor()
  65 {
  66
  67 }
  68
  69 std::string OLCEditor::lookup(const std::string& action)
  70 {
  71         const SavableCommand* act = m_olccommands.getObject(action);
  72         if(act)
  73                 return act->getName();
  74
  75         return Global::Get()->EmptyString;
  76 }
  77
  78 void OLCEditor::dispatch(const std::string& action, const std::string& argument)
  79 {
  80         const SavableCommand* act = m_olccommands.getObject(action);
  81
  82         Assert(act);
  83         act->Run(this, argument);
  84 }
  85
  86 void OLCEditor::newSavable(const std::string& argument)
  87 {
  88         KeysPtr keys = addNew();
  89         if(!keys->size())
  90         {
  91                 Sendf("Could not create a new %s!\n", name().c_str());
  92                 return;
  93         }
  94
  95         Sendf("%s created!\n", name().c_str());
  96         setEditing(keys);
  97         return;
  98 }
  99
 100 void OLCEditor::editSavable(const std::string& argument)
 101 {
 102         TableImplPtr table = getTable();
 103
 104         if(argument.size() == 0)
 105         {
 106                 Send("Please specify an id to edit.\n");
 107                 Send("Type 'list' to see a list of available id's.\n");
 108                 Sendf("Type 'new' to create a new %s!\n", name().c_str());
 109                 return;
 110         }
 111
 112         KeysPtr keys;
 113
 114         try {
 115                 keys = KeysPtr(new Keys(table, argument));
 116         } catch(std::invalid_argument& e)
 117         {
 118                 Send("Please specify an id to edit.\n");
 119                 Sendf("'%s' is not a valid id.\n", argument.c_str());
 120                 return;
 121         }
 122
 123         int count = SavableManager::count(keys);
 124
 125         if(count < 1)
 126         {
 127                 Send("Please specify an id to edit.\n");
 128                 Sendf("'%s' does not exist!\n", argument.c_str());
 129                 return;
 130         }
 131
 132         Assert(count == 1);
 133
 134         setEditing(keys);
 135         m_sock->Sendf("You are now editing id %s> ", argument.c_str());
 136         m_sock->Send(getEditing()->toString());
 137         m_sock->Send("\n");
 138         return;
 139 }
 140
 141 void OLCEditor::deleteSavable(const std::string& argument)
 142 {
 143         if(argument.size() == 0)
 144         {
 145                 Send("Please specify an id to delete.\n");
 146                 Send("Type 'list' to see a list of available id's.\n");
 147                 return;
 148         }
 149
 150         KeysPtr keys;
 151
 152         try
 153         {
 154                 keys = KeysPtr(new Keys(getTable(), argument));
 155         }
 156         catch(std::invalid_argument& e)
 157         {
 158                 Send("Please specify an id to edit.\n");
 159                 Sendf("'%s' is not a valid id.\n", argument.c_str());
 160         }
 161
 162         int count = SavableManager::count(keys);
 163
 164         if(count < 1)
 165         {
 166                 Send("Please specify an id to delete.\n");
 167                 Sendf("'%s' does not exist!\n", argument.c_str());
 168                 return;
 169         }
 170
 171         Assert(count == 1);
 172
 173         SavableManagerPtr manager = SavableManager::bykeys(keys);
 174         bool locked = manager->lock();
 175
 176         if(!locked)
 177         {
 178                 m_sock->Sendf("Could not lock '%s', it is being edited by someone else!\n", argument.c_str());
 179                 return;
 180         }
 181
 182         manager->erase();
 183         manager->unlock();
 184
 185         m_sock->Sendf("Deleted id %s.\n", keys->toString().c_str());
 186         m_sock->Send("\n");
 187         return;
 188 }
 189
 190 void OLCEditor::listSavable(const std::string& argument)
 191 {
 192         std::string name = this->name();
 193         name.append("s");
 194         Strings list = getList();
 195         if(list.size())
 196                 m_sock->Send(String::Get()->box(list,name));
 197         else
 198                 m_sock->Sendf("No %ss.\n", this->name().c_str());
 199         return;
 200 }
 201
 202 void OLCEditor::listCommands(const std::string& argument)
 203 {
 204         m_sock->Send(String::Get()->box(m_olccommands.getCommandsVector(), name()));
 205         m_sock->Send("\n");
 206         std::string name = this->name();
 207         name.append("Editing");
 208         m_sock->Send(String::Get()->box(getCommands(), name));
 209         m_sock->Send("\n");
 210         return;
 211 }
 212
 213 void OLCEditor::quitEditor(const std::string& argument)
 214 {
 215         m_sock->Send("Ok.\n");
 216         SavablePtr editing = getEditing();
 217
 218         if(editing)
 219         {
 220                 try {
 221                         editing->Save();
 222                 } catch(SavableLocked& e) {
 223                         // if they don't have a lock, they didn't edit anything anyway
 224                         // so no need to save or notify them
 225                 }
 226         }
 227
 228         m_sock->PopEditor();
 229         return;
 230 }
 231
 232 void OLCEditor::doneEditing(const std::string& argument)
 233 {
 234         SavablePtr editing = getEditing();
 235
 236         if(editing)
 237         {
 238                 m_sock->Send("Ok.\n");
 239
 240                 try {
 241                         editing->Save();
 242                 } catch(SavableLocked& e) {
 243                         // if they don't have a lock, they didn't edit anything anyway
 244                         // so no need to save or notify them
 245                 }
 246         } else {
 247                 m_sock->Send("You are not editing anything, so no need to type 'done'.\n");
 248         }
 249
 250         TableImplPtr table = getTable();
 251         Assert(table);
 252
 253         KeysPtr keys(new Keys(table));
 254         setEditing(keys);
 255         return;
 256 }
 257
 258 void OLCEditor::discardChanges(const std::string& argument)
 259 {
 260         if(argument.compare("confirm"))
 261         {
 262                 m_sock->Send("Please type 'discard confirm' to discard your changes.\n");
 263                 return;
 264         }
 265
 266         m_sock->Send("Ok.\n");
 267         SavablePtr editing = getEditing();
 268
 269         if(editing)
 270         {
 271                 try {
 272                         editing->Lock();
 273                         editing->Discard();
 274                 } catch(SavableLocked& e) {
 275                         m_sock->Send("You cannot discard all changes as you are not the one editing!\n");
 276                 }
 277         } else {
 278                 m_sock->Send("You're not editing anything!\n");
 279         }
 280
 281         return;
 282 }