src/Core/Editors/EditorDetail.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 "SavableHeaders.h"
  22 #include "EditorDetail.h"
  23 #include "EditorString.h"
  24 #include "EditorBool.h"
  25 #include "Array.h"
  26 #include "Assert.h"
  27 #include "StringUtilities.h"
  28 #include "TableImpls.h"
  29 #include "UBSocket.h"
  30 #include "Account.h"
  31 #include "Detail.h"
  32 #include "DetailManager.h"
  33 #include "Area.h"
  34 #include "AreaManager.h"
  35 #include "Room.h"
  36 #include "RoomManager.h"
  37 #include "Chunk.h"
  38 #include "ChunkManager.h"
  39 #include "Managers.h"
  40
  41 #include <boost/spirit/core.hpp>
  42
  43 typedef EditorDetail E;
  44 typedef CommandInfoObject<E> O;
  45 typedef CommandBinding<E> B;
  46
  47 using namespace boost::spirit;
  48
  49 //                                       name           function  need: object lock
  50 static O editKey(       "Key",          &E::editKey,    true, true);
  51 static O editDescription("Description", &E::editDescription, true, true);
  52 static O showDetail("Show",     &E::showDetail, true, false);
  53 static O saveDetail("Save",     &E::saveDetail, true, true);
  54 static O clearParents("ClearParents", &E::clearParents);
  55 static O setParent(     "SetParent",&E::setParent);
  56
  57 static const B commands[] = {
  58         B("all", clearParents),
  59         B("description", editDescription),
  60         B("filter", setParent),
  61         B("name", editKey),
  62         B("save", saveDetail),
  63         B("show", showDetail),
  64 };
  65
  66 EditorDetail::EditorDetail(UBSocket* sock) :
  67 OLCEditor(sock),
  68 m_commands(commands, array_size(commands)),
  69 m_detail(),
  70 m_target(M_NONE)
  71 {
  72         listCommands(Global::Get()->EmptyString);
  73 }
  74
  75 EditorDetail::EditorDetail(UBSocket* sock, mud::DetailPtr detail) :
  76 OLCEditor(sock),
  77 m_commands(commands, array_size(commands)),
  78 m_detail(detail),
  79 m_target(M_NONE)
  80 {
  81
  82 }
  83
  84 EditorDetail::EditorDetail(UBSocket* sock, mud::AreaPtr parentArea) :
  85 OLCEditor(sock),
  86 m_commands(commands, array_size(commands)),
  87 m_detail(),
  88 m_parentArea(parentArea),
  89 m_target(M_NONE)
  90 {
  91         listCommands(Global::Get()->EmptyString);
  92         m_sock->Sendf("Only Details that belong to area '%d' are shown, to clear this restriction type 'all'.\n", parentArea->getID());
  93 }
  94
  95 EditorDetail::EditorDetail(UBSocket* sock, mud::RoomPtr parentRoom) :
  96 OLCEditor(sock),
  97 m_commands(commands, array_size(commands)),
  98 m_detail(),
  99 m_parentRoom(parentRoom),
 100 m_target(M_NONE)
 101 {
 102         listCommands(Global::Get()->EmptyString);
 103         m_sock->Sendf("Only Details that belong to room '%d' are shown, to clear this restriction type 'all'.\n", parentRoom->getID());
 104 }
 105
 106 EditorDetail::EditorDetail(UBSocket* sock, mud::ChunkPtr parentChunk) :
 107 OLCEditor(sock),
 108 m_commands(commands, array_size(commands)),
 109 m_detail(),
 110 m_parentChunk(parentChunk),
 111 m_target(M_NONE)
 112 {
 113         listCommands(Global::Get()->EmptyString);
 114         m_sock->Sendf("Only Details that belong to chunk '%d' are shown, to clear this restriction type 'all'.\n", parentChunk->getID());
 115 }
 116
 117 EditorDetail::~EditorDetail(void)
 118 {
 119
 120 }
 121
 122 void EditorDetail::OnFocus()
 123 {
 124         switch(m_target)
 125         {
 126                 case M_NONE:
 127                         return;
 128
 129                 case M_DESCRIPTION:
 130                         m_detail->setDescription(m_value);
 131                         break;
 132         }
 133
 134         m_target = M_NONE;
 135 }
 136
 137 std::string EditorDetail::lookup(const std::string& action)
 138 {
 139         std::string name = OLCEditor::lookup(action);
 140         if(name.size() != 0)
 141                 return name;
 142
 143         const DetailCommand* act = (DetailCommand*)m_commands.getObject(action);
 144         if(act)
 145                 return act->getName();
 146
 147         return Global::Get()->EmptyString;
 148 }
 149
 150 void EditorDetail::dispatch(const std::string& action, const std::string& argument)
 151 {
 152         const DetailCommand* act = (DetailCommand*)m_commands.getObject(action);
 153
 154         if(!act)
 155         {
 156                 OLCEditor::dispatch(action, argument);
 157                 return;
 158         }
 159
 160         if(!m_detail && act->needObject())
 161         {
 162                 m_sock->Send("You need to be editing a detail first.\n");
 163                 m_sock->Send("(Use the 'edit' command.)\n");
 164                 return;
 165         }
 166
 167         if(act->needLock())
 168         {
 169                 try {
 170                         m_detail->Lock();
 171                 } catch(SavableLocked& e) {
 172                         m_sock->Send("The detail you are currently editing is locked (being edited by someone else), so you cannot edit it right now.\n");
 173                         m_sock->Send("Please try again later.\n");
 174                         return;
 175                 }
 176         }
 177
 178         act->Run(this, argument);
 179         return;
 180 }
 181
 182 SavablePtr EditorDetail::getEditing()
 183 {
 184         return m_detail;
 185 }
 186
 187 TableImplPtr EditorDetail::getTable()
 188 {
 189         return db::TableImpls::Get()->DETAILS;
 190 }
 191
 192 KeysPtr EditorDetail::addNew()
 193 {
 194         return mud::Managers::Get()->Detail->Add();
 195 }
 196
 197 std::vector<std::string> EditorDetail::getList()
 198 {
 199         if(m_parentArea)
 200                 return mud::Managers::Get()->Detail->List(m_parentArea);
 201
 202         if(m_parentRoom)
 203                 return mud::Managers::Get()->Detail->List(m_parentRoom);
 204
 205         if(m_parentChunk)
 206                 return mud::Managers::Get()->Detail->List(m_parentChunk);
 207
 208         return mud::Managers::Get()->Detail->List();
 209 }
 210
 211 void EditorDetail::setEditing(KeysPtr keys)
 212 {
 213         if(!keys->size())
 214         {
 215                 m_detail.reset();
 216                 return;
 217         }
 218
 219         m_detail = mud::Managers::Get()->Detail->GetByKey(keys->first()->getIntegerValue());
 220         return;
 221 }
 222
 223 std::vector<std::string> EditorDetail::getCommands()
 224 {
 225         return m_commands.getCommandsVector();
 226 }
 227
 228 void EditorDetail::editKey(const std::string& argument)
 229 {
 230         if(argument.size() == 0)
 231         {
 232                 m_sock->Send("Detail key can't be zero length!\n");
 233                 return;
 234         }
 235
 236         m_sock->Sendf("Detail key changed from '%s' to '%s'.\n", m_detail->getKey().c_str(), argument.c_str());
 237         m_detail->setKey(argument);
 238         return;
 239 }
 240
 241 void EditorDetail::editDescription(const std::string& argument)
 242 {
 243         if(argument.size() == 0)
 244         {
 245                 m_sock->Send("No argument, dropping you into the string editor!\n");
 246                 m_sock->SetEditor(new EditorString(m_sock, m_value));
 247                 m_target = M_DESCRIPTION;
 248                 return;
 249         }
 250
 251         m_sock->Sendf("Detail description changed from '%s' to '%s'.\n", m_detail->getDescription().c_str(), argument.c_str());
 252         m_detail->setDescription(argument);
 253         return;
 254 }
 255
 256 void EditorDetail::showDetail(const std::string& argument)
 257 {
 258         std::vector<std::string> result;
 259         std::string key = "Key: '";
 260         key.append(m_detail->getKey());
 261         key.append("'.");
 262         result.push_back(key);
 263
 264         std::string description = "Description: '";
 265         description.append(m_detail->getDescription());
 266         description.append("'.");
 267         result.push_back(description);
 268
 269         m_sock->Send(String::Get()->box(result, "Detail"));
 270 }
 271
 272 void EditorDetail::saveDetail(const std::string& argument)
 273 {
 274         m_sock->Sendf("Saving detail '%s'.\n", m_detail->getKey().c_str());
 275         if(argument.size())
 276                 m_detail->Save(m_sock->GetAccount()->getID(), argument);
 277         else
 278                 m_detail->Save(m_sock->GetAccount()->getID(), Global::Get()->EmptyString);
 279         m_sock->Send("Saved.\n");
 280         return;
 281 }
 282
 283 void EditorDetail::clearParents(const std::string& argument)
 284 {
 285         m_sock->Send("Ok.\n");
 286         m_parentArea.reset();
 287         m_parentRoom.reset();
 288         m_parentChunk.reset();
 289         return;
 290 }
 291
 292 void EditorDetail::setParent(const std::string& argument)
 293 {
 294         if(!argument.size())
 295         {
 296                 m_sock->Send("Please provide an area, room, or chunk to filter on.\n");
 297                 return;
 298         }
 299
 300         value_type id = 0;
 301         bool area = false;
 302         bool chunk = false;
 303         bool room = false;
 304
 305         bool good = parse(argument.c_str(),
 306         //  Begin grammar
 307         (
 308                         (str_p("area")[assign_a(area, true)] |
 309                         str_p("chunk")[assign_a(chunk, true)] |
 310                         str_p("room")[assign_a(room, true)])
 311
 312                         >> int_p[assign_a(id)]
 313         )
 314         ,
 315         //  End grammar
 316         space_p).full;
 317
 318         if(!good)
 319         {
 320                 m_sock->Send("Please specify what area, room, or chunk to filter on in the following format:\n");
 321                 m_sock->Send("area/room/chunk id\n");
 322                 return;
 323         }
 324
 325         Assert(area || chunk || room);
 326
 327         m_parentArea.reset();
 328         m_parentRoom.reset();
 329         m_parentChunk.reset();
 330
 331
 332         if(area)
 333         {
 334                 try {
 335                         mud::AreaPtr area = mud::Managers::Get()->Area->GetByKey(id);
 336                         m_parentArea = area;
 337                         m_sock->Send("Ok.\n");
 338                         m_sock->Sendf("Only Details that belong to area '%d' are shown, to clear this restriction type 'all'.\n", m_parentArea->getID());
 339                 } catch(RowNotFoundException& e) {
 340                         m_sock->Sendf("'%s' is not an area.\n", argument.c_str());
 341                 }
 342         }
 343
 344         if(room)
 345         {
 346                 try {
 347                         mud::RoomPtr room = mud::Managers::Get()->Room->GetByKey(id);
 348                         m_parentRoom = room;
 349                         m_sock->Send("Ok.\n");
 350                         m_sock->Sendf("Only Details that belong to room '%d' are shown, to clear this restriction type 'all'.\n", m_parentRoom->getID());
 351                 } catch(RowNotFoundException& e) {
 352                         m_sock->Sendf("'%s' is not a room.\n", argument.c_str());
 353                 }
 354         }
 355
 356         if(chunk)
 357         {
 358                 try {
 359                         mud::ChunkPtr chunk = mud::Managers::Get()->Chunk->GetByKey(id);
 360                         m_parentChunk = chunk;
 361                         m_sock->Send("Ok.\n");
 362                         m_sock->Sendf("Only Details that belong to chunk '%d' are shown, to clear this restriction type 'all'.\n", m_parentChunk->getID());
 363                 } catch(RowNotFoundException& e) {
 364                         m_sock->Sendf("'%d' is not a chunk.\n", id);
 365                 }
 366         }
 367 }