src/Core/Editors/EditorGrantGroup.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 "EditorGrantGroup.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 "GrantGroup.h"
  29 #include "GrantGroupManager.h"
  30 #include "Managers.h"
  31
  32 using mud::GrantGroup;
  33
  34 typedef EditorGrantGroup E;
  35 typedef CommandInfoObject<E> O;
  36 typedef CommandBinding<E> B;
  37
  38 //                                              name            function  need: object lock
  39 static O editName(              "Name",         &E::editName,   true, true);
  40 static O editImplication("Description", &E::editImplication, true, true);
  41 static O showGrantGroup("Show",         &E::showGrantGroup, true, false);
  42 static O saveGrantGroup("Save",         &E::saveGrantGroup, true, false);
  43
  44 static const B commands[] = {
  45         B("implication", editImplication),
  46         B("name", editName),
  47         B("save", saveGrantGroup),
  48         B("show", showGrantGroup),
  49 };
  50
  51 EditorGrantGroup::EditorGrantGroup(UBSocket* sock) :
  52 OLCEditor(sock),
  53 m_commands(commands, array_size(commands)),
  54 m_grantgroup()
  55 {
  56         listCommands(Global::Get()->EmptyString);
  57 }
  58
  59 EditorGrantGroup::~EditorGrantGroup(void)
  60 {
  61
  62 }
  63
  64 std::string EditorGrantGroup::lookup(const std::string& action)
  65 {
  66         std::string name = OLCEditor::lookup(action);
  67         if(name.size() != 0)
  68                 return name;
  69
  70         const GrantGroupCommand* act = (GrantGroupCommand*)m_commands.getObject(action);
  71         if(act)
  72                 return act->getName();
  73
  74         return Global::Get()->EmptyString;
  75 }
  76
  77 void EditorGrantGroup::dispatch(const std::string& action, const std::string& argument)
  78 {
  79         const GrantGroupCommand* act = (GrantGroupCommand*)m_commands.getObject(action);
  80
  81         if(!act)
  82         {
  83                 OLCEditor::dispatch(action, argument);
  84                 return;
  85         }
  86
  87         if(!m_grantgroup)
  88         {
  89                 m_sock->Send("You need to be editing a grantgroup first.\n");
  90                 m_sock->Send("(Use the 'edit' command.)\n");
  91                 return;
  92         }
  93
  94         if(act->needLock())
  95         {
  96                 try {
  97                         m_grantgroup->Lock();
  98                 } catch(SavableLocked& e) {
  99                         m_sock->Send("The grantgroup you are currently editing is locked (being edited by someone else), so you cannot edit it right now.\n");
 100                         m_sock->Send("Please try again later.\n");
 101                         return;
 102                 }
 103         }
 104
 105         act->Run(this, argument);
 106         return;
 107 }
 108
 109 SavablePtr EditorGrantGroup::getEditing()
 110 {
 111         return m_grantgroup;
 112 }
 113
 114 TableImplPtr EditorGrantGroup::getTable()
 115 {
 116         return db::TableImpls::Get()->GRANTGROUPS;
 117 }
 118
 119 KeysPtr EditorGrantGroup::addNew()
 120 {
 121         return mud::Managers::Get()->GrantGroup->Add();
 122 }
 123
 124 std::vector<std::string> EditorGrantGroup::getList()
 125 {
 126         return mud::Managers::Get()->GrantGroup->List();
 127 }
 128
 129 void EditorGrantGroup::setEditing(KeysPtr keys)
 130 {
 131         if(!keys->size())
 132         {
 133                 m_grantgroup.reset();
 134                 return;
 135         }
 136
 137         m_grantgroup = mud::Managers::Get()->GrantGroup->GetByKey(keys->first()->getIntegerValue());
 138         return;
 139 }
 140
 141 std::vector<std::string> EditorGrantGroup::getCommands()
 142 {
 143         return m_commands.getCommandsVector();
 144 }
 145
 146 void EditorGrantGroup::editName(const std::string& argument)
 147 {
 148         if(argument.size() == 0)
 149         {
 150                 m_sock->Send("GrantGroup name can't be zero length!\n");
 151                 return;
 152         }
 153
 154         m_sock->Sendf("GrantGroup name changed from '%s' to '%s'.\n", m_grantgroup->getName().c_str(), argument.c_str());
 155         m_grantgroup->setName(argument);
 156         return;
 157 }
 158
 159 void EditorGrantGroup::editImplication(const std::string& argument)
 160 {
 161         if(argument.size() == 0)
 162         {
 163                 m_sock->Send("Please specify the implicated grantgroup!\n");
 164                 return;
 165         }
 166
 167         int implication = atoi(argument.c_str());
 168         if(implication <= 0)
 169         {
 170                 m_sock->Sendf("Please specify an implication > 0!\n");
 171                 return;
 172         }
 173
 174         m_sock->Sendf("GrantGroup implication changed from '%d' to '%d'.\n", m_grantgroup->getImplication(), implication);
 175         m_grantgroup->setImplication(implication);
 176 }
 177
 178 void EditorGrantGroup::showGrantGroup(const std::string& argument)
 179 {
 180         m_sock->Send(m_grantgroup->toString());
 181         return;
 182 }
 183
 184 void EditorGrantGroup::saveGrantGroup(const std::string& argument)
 185 {
 186         m_sock->Sendf("Saving grantgroup '%s'.\n", m_grantgroup->getName().c_str());
 187         m_grantgroup->Save();
 188         m_sock->Send("Saved.\n");
 189         return;
 190 }