src/Core/Editors/EditorCommand.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 "EditorCommand.h"
  22 #include "EditorOLC.h"
  23 #include "UBSocket.h"
  24 #include "StringUtilities.h"
  25 #include "TableImpls.h"
  26 #include "Array.h"
  27 #include "Account.h"
  28 #include "Command.h"
  29 #include "CommandManager.h"
  30 #include "GrantGroup.h"
  31 #include "GrantGroupManager.h"
  32 #include "Managers.h"
  33
  34 using mud::Command;
  35
  36 typedef EditorCommand E;
  37 typedef CommandInfoObject<E> O;
  38 typedef CommandBinding<E> B;
  39
  40 //                                              name            function          need: object lock
  41 static O editName(              "Name",         &E::editName,           true, true);
  42 static O editGrantGroups("GrantGroup",&E::editGrantGroups,true, true);
  43 static O editHighForce( "HighForce", &E::editHighForce, true, true);
  44 static O editForce(             "Force",        &E::editForce,          true, true);
  45 static O editLowForce(  "LowForce", &E::editLowForce,   true, true);
  46 static O showCommand(   "Show",         &E::showCommand,        true, false);
  47 static O saveCommand(   "Save",         &E::saveCommand,        true, true);
  48
  49 static const B commands[] = {
  50         B("force", editForce),
  51         B("grantgroup", editGrantGroups),
  52         B("highforce", editHighForce),
  53         B("lowforce", editLowForce),
  54         B("name", editName),
  55         B("save", saveCommand),
  56         B("show", showCommand),
  57 };
  58
  59 EditorCommand::EditorCommand(UBSocket* sock) :
  60 OLCEditor(sock),
  61 m_commands(commands, array_size(commands)),
  62 m_command()
  63 {
  64         listCommands(Global::Get()->EmptyString);
  65 }
  66
  67 EditorCommand::~EditorCommand(void)
  68 {
  69
  70 }
  71
  72 std::string EditorCommand::lookup(const std::string& action)
  73 {
  74         std::string name = OLCEditor::lookup(action);
  75         if(name.size() != 0)
  76                 return name;
  77
  78         const CommandCommand* act = (CommandCommand*)m_commands.getObject(action);
  79         if(act)
  80                 return act->getName();
  81
  82         return Global::Get()->EmptyString;
  83 }
  84
  85 void EditorCommand::dispatch(const std::string& action, const std::string& argument)
  86 {
  87         const CommandCommand* act = (CommandCommand*)m_commands.getObject(action);
  88
  89         if(!act)
  90         {
  91                 OLCEditor::dispatch(action, argument);
  92                 return;
  93         }
  94
  95         if(!m_command)
  96         {
  97                 m_sock->Send("You need to be editing a command first.\n");
  98                 m_sock->Send("(Use the 'edit' command.)\n");
  99                 return;
 100         }
 101
 102         if(act->needLock())
 103         {
 104                 try {
 105                         m_command->Lock();
 106                 } catch(SavableLocked& e) {
 107                         m_sock->Send("The command you are currently editing is locked (being edited by someone else), so you cannot edit it right now.\n");
 108                         m_sock->Send("Please try again later.\n");
 109                         return;
 110                 }
 111         }
 112
 113         act->Run(this, argument);
 114         return;
 115 }
 116
 117 SavablePtr EditorCommand::getEditing()
 118 {
 119         return m_command;
 120 }
 121
 122 TableImplPtr EditorCommand::getTable()
 123 {
 124         return db::TableImpls::Get()->COMMANDS;
 125 }
 126
 127 KeysPtr EditorCommand::addNew()
 128 {
 129         return mud::Managers::Get()->Command->Add();
 130 }
 131
 132 std::vector<std::string> EditorCommand::getList()
 133 {
 134         return mud::Managers::Get()->Command->List();
 135 }
 136
 137 void EditorCommand::setEditing(KeysPtr keys)
 138 {
 139         if(!keys->size())
 140         {
 141                 m_command.reset();
 142                 return;
 143         }
 144
 145         m_command = mud::Managers::Get()->Command->GetByKey(keys->first()->getIntegerValue());
 146         return;
 147 }
 148
 149 std::vector<std::string> EditorCommand::getCommands()
 150 {
 151         return m_commands.getCommandsVector();
 152 }
 153
 154 void EditorCommand::editName(const std::string& argument)
 155 {
 156         if(argument.size() == 0)
 157         {
 158                 m_sock->Send("Command name can't be zero length!\n");
 159                 return;
 160         }
 161
 162         m_sock->Sendf("Command name changed from '%s' to '%s'.\n", m_command->getName().c_str(), argument.c_str());
 163         m_command->setName(argument);
 164         return;
 165 }
 166
 167 void EditorCommand::editGrantGroups(const std::string& argument)
 168 {
 169         if(!m_command->Exists())
 170         {
 171                 m_sock->Send("For some reason the command you are editing does not exist.\n");
 172                 return;
 173         }
 174
 175         try
 176         {
 177                 long id = mud::Managers::Get()->GrantGroup->lookupByName(argument);
 178                 m_sock->Sendf("Grantgroup changed from '%d' to '%d'.\n", m_command->getGrantGroup(), id);
 179                 m_command->setGrantGroup(id);
 180         }
 181         catch(RowNotFoundException& e)
 182         {
 183                 m_sock->Sendf("'%s' is not a valid grantgroup!\n", argument.c_str());
 184                 m_sock->Send(String::Get()->box(mud::Managers::Get()->GrantGroup->List(), "GrantGroups"));
 185         }
 186 }
 187
 188 void EditorCommand::editHighForce(const std::string& argument)
 189 {
 190         if(!argument.compare("Enable"))
 191         {
 192                 m_command->setHighForce(true);
 193                 return;
 194         }
 195
 196         if(!argument.compare("Disable"))
 197         {
 198                 m_command->setHighForce(false);
 199                 return;
 200         }
 201
 202         m_sock->Send("Please specify a force level!\n");
 203         m_sock->Send("Choose between 'Enable' and 'Disable'.\n");
 204         return;
 205 }
 206
 207 void EditorCommand::editForce(const std::string& argument)
 208 {
 209         if(!argument.compare("Enable"))
 210         {
 211                 m_command->setForce(true);
 212                 return;
 213         }
 214
 215         if(!argument.compare("Disable"))
 216         {
 217                 m_command->setForce(false);
 218                 return;
 219         }
 220
 221         m_sock->Send("Please specify a force level!\n");
 222         m_sock->Send("Choose between 'Enable' and 'Disable'.\n");
 223         return;
 224 }
 225
 226 void EditorCommand::editLowForce(const std::string& argument)
 227 {
 228         if(!argument.compare("Enable"))
 229         {
 230                 m_command->setLowForce(true);
 231                 return;
 232         }
 233
 234         if(!argument.compare("Disable"))
 235         {
 236                 m_command->setLowForce(false);
 237                 return;
 238         }
 239
 240         m_sock->Send("Please specify a force level!\n");
 241         m_sock->Send("Choose between 'Enable' and 'Disable'.\n");
 242         return;
 243 }
 244
 245 void EditorCommand::showCommand(const std::string& argument)
 246 {
 247         m_sock->Send(m_command->toString());
 248         return;
 249 }
 250
 251 void EditorCommand::saveCommand(const std::string& argument)
 252 {
 253         m_sock->Sendf("Saving command '%s'.\n", m_command->getName().c_str());
 254         m_command->Save();
 255         m_sock->Send("Saved.\n");
 256         return;
 257 }
 258