src/dashserver/project/store.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                      *
   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 2 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
  22 #include "store.h"
  23
  24 #include <QVariant>
  25 #include <QDir>
  26
  27 #include <dcore/debug.h>
  28 #include <dcore/algorithm.h>
  29
  30 #include "dash/projectsaver.h"
  31
  32 #include "project.h"
  33 #include "member.h"
  34
  35 #include "dashserver/connection.h"
  36 #include "dashserver/users/user.h"
  37 #include "dashserver/xdbms/manager.h"
  38 #include "dashserver/xdbms/table.h"
  39
  40 #include "dash/network/package/transfer.h"
  41 #include "dash/network/package/connected.h"
  42 #include "dash/network/package/disconnected.h"
  43 #include "dash/network/package/error.h"
  44
  45 namespace DashServer {
  46 namespace Project {
  47
  48 struct Store::Private
  49 {
  50         QHash<QString, Project *> projects;
  51
  52 };
  53
  54 Store::Store() : d(new Private)
  55 {
  56 }
  57
  58
  59 Store::~Store()
  60 {
  61         qDeleteAll(d->projects);
  62         delete d;
  63 }
  64
  65 QStringList Store::projects() const
  66 {
  67         XDBMS::Table *table = XDBMS::Manager::self()->table("projects");
  68
  69         return table->objects();
  70 }
  71
  72 Project *Store::project(const QString& name)
  73 {
  74         XDBMS::Table *table = XDBMS::Manager::self()->table("projects");
  75
  76         Project *project = new Project;
  77         project->setId(name);
  78         if(table->load(project))
  79         {
  80                 project->afterLoad();
  81                 project->setProjectName(name);
  82                 return project;
  83         }
  84         return 0;
  85 }
  86
  87 QList<Project *> Store::allProjects() const
  88 {
  89         QList<Project *> projects;
  90
  91         XDBMS::Table *table = XDBMS::Manager::self()->table("projects");
  92         foreach(QString projectName, table->objects())
  93         {
  94                 Project *project = new Project;
  95                 project->setId(projectName);
  96                 table->load(project);
  97
  98                 project->afterLoad();
  99                 project->setProjectName(projectName);
 100
 101                 projects << project;
 102         }
 103
 104
 105         return projects;
 106 }
 107
 108 bool Store::createProject(const QString &name, const QString &author, const QString &description, const QString& owner, const QList<Member *> &members)
 109 {
 110         if( !d->projects.contains(name) )
 111         {
 112                 Project *project = new Project;
 113                 project->setProjectName(name);
 114                 project->setAuthor(author);
 115                 project->setDescription(description);
 116
 117                 if(members.isEmpty())
 118                 {
 119                         Member *director = new Member;
 120                         director->setJob(QObject::tr("Director"));
 121                         director->setUser(owner);
 122                         director->addPermission(Project::All, Users::Permission::Read | Users::Permission::Write);
 123                         director->addPermission(Project::Scene, Users::Permission::Read | Users::Permission::Write);
 124                         director->addPermission(Project::Layer, Users::Permission::Read | Users::Permission::Write);
 125                         director->addPermission(Project::Frame, Users::Permission::Read | Users::Permission::Write);
 126                         director->addPermission(Project::Object, Users::Permission::Read | Users::Permission::Write);
 127
 128                         project->addMember(director);
 129                 }
 130
 131                 foreach(Member *memeber, members)
 132                 {
 133                         project->addMember(memeber);
 134                 }
 135
 136                 project->setOpen(true);
 137
 138                 d->projects[name] = project;
 139
 140                 project->aboutToSave();
 141                 XDBMS::Manager::self()->addObject("projects", project);
 142
 143                 return project->save();
 144         }
 145
 146         return false;
 147 }
 148
 149 void Store::addToProject(const QString &projectName, DashServer::Connection *cnx)
 150 {
 151         if( d->projects.contains(projectName) )
 152         {
 153                 Project *project = d->projects.value(projectName);
 154
 155                 cnx->setData(ProjectName, projectName);
 156
 157                 QStringList connections;
 158                 foreach(DashServer::Connection *connection, project->connections())
 159                 {
 160                         Dash::Network::Package::Connected pkg(cnx->user()->login());
 161                         connection->sendToClient(pkg.toString(), false);
 162
 163                         connections << connection->user()->login();
 164                 }
 165
 166                 project->addClient(cnx);
 167
 168                 if( !connections.isEmpty() )
 169                 {
 170                         Dash::Network::Package::Connected pkg(connections);
 171                         dfDebug << pkg.toString();
 172                         cnx->sendToClient(pkg.toString(), true);
 173                 }
 174         }
 175 }
 176
 177 bool Store::contains(const QString &projectName) const
 178 {
 179         return d->projects.contains(projectName);
 180 }
 181
 182 bool Store::execute(const QString &xml, DashServer::Connection *source)
 183 {
 184         QString projectName = source->data(ProjectName).toString();
 185
 186         if( d->projects.contains(projectName) )
 187         {
 188                 Project *project = d->projects.value(projectName);
 189                 project->execute(xml, source);
 190
 191                 return true;
 192         }
 193
 194         return false;
 195 }
 196
 197 bool Store::openProject(const QString &projectName, DashServer::Connection *source)
 198 {
 199         if( !d->projects.contains(projectName) )
 200         {
 201                 Project *project = new Project;
 202                 project->setId(projectName);
 203
 204                 if( ! XDBMS::Manager::self()->load("projects", project) ) return false;
 205
 206                 if( ! project->load() )
 207                 {
 208                         qWarning("Cannot load project");
 209                         return false;
 210                 }
 211
 212                 d->projects[projectName] = project;
 213         }
 214
 215         {
 216                 Project *project = d->projects.value(projectName);
 217
 218                 if( project->save() )
 219                 {
 220                         addToProject(projectName, source);
 221                         project->sendToClient(source);
 222                 }
 223
 224                 return true;
 225         }
 226
 227         return false;
 228 }
 229
 230 QList<Project *> Store::activeProjects() const
 231 {
 232         return d->projects.values();
 233 }
 234
 235 void Store::removeClient(DashServer::Connection *client)
 236 {
 237         QString projectName = client->data(ProjectName).toString();
 238
 239         if( d->projects.contains(projectName) )
 240         {
 241                 Dash::Network::Package::Disconnected pkg(client->user()->login());
 242                 sendToMembers(projectName, pkg.toString());
 243
 244                 Project *project = d->projects.value(projectName);
 245                 project->removeClient(client);
 246
 247                 if( project->clientCount() == 0 )
 248                 {
 249                         d->projects.remove(projectName);
 250                         delete project;
 251                 }
 252         }
 253 }
 254
 255 void Store::sendToMembers(const QString &projectName, const QString &pkg)
 256 {
 257         if( d->projects.contains(projectName) )
 258         {
 259                 Project *project = d->projects.value(projectName);
 260                 foreach(DashServer::Connection *cnx, project->connections())
 261                 {
 262                         cnx->sendToClient(pkg, false);
 263                 }
 264         }
 265 }
 266
 267 void Store::resendProject(const QString &projectName)
 268 {
 269         if( d->projects.contains(projectName) )
 270         {
 271                 Project *project = d->projects.value(projectName);
 272                 project->sendToAll();
 273         }
 274 }
 275
 276 bool Store::removeProject(const QString &projectName)
 277 {
 278         if( d->projects.contains(projectName))
 279         {
 280                 Project *project = d->projects.value(projectName);
 281                 if(XDBMS::Manager::self()->remove("projects", project))
 282                 {
 283                         d->projects.remove(projectName);
 284                         foreach(DashServer::Connection *connection, project->connections() )
 285                         {
 286                                 connection->sendError(QObject::tr("Project removed"), Dash::Network::Package::Error::Info);
 287                                 connection->close();
 288                         }
 289
 290                         delete project;
 291                         return true;
 292                 }
 293         }
 294         return false;
 295 }
 296
 297 void Store::importProject(DashServer::Connection *cnx, const QString &fileName)
 298 {
 299         if( QFile::exists(fileName) )
 300         {
 301                 Project::Project *project = new Project::Project;
 302                 if( !Dash::ProjectSaver::load(project, fileName) )
 303                 {
 304                         cnx->sendError( QObject::tr("Cannot import the project"), Dash::Network::Package::Error::Err);
 305                         delete project;
 306                         return;
 307                 }
 308
 309                 QString projectName = project->projectName();
 310
 311                 if( !d->projects.contains(projectName) && !projectName.isEmpty() )
 312                 {
 313                         QString owner = cnx->user()->login();
 314                         {
 315                                 Member *director = new Member;
 316                                 director->setJob(QObject::tr("Director"));
 317                                 director->setUser(owner);
 318                                 director->addPermission(Project::All, Users::Permission::Read | Users::Permission::Write);
 319                                 director->addPermission(Project::Scene, Users::Permission::Read | Users::Permission::Write);
 320                                 director->addPermission(Project::Layer, Users::Permission::Read | Users::Permission::Write);
 321                                 director->addPermission(Project::Frame, Users::Permission::Read | Users::Permission::Write);
 322                                 director->addPermission(Project::Object, Users::Permission::Read | Users::Permission::Write);
 323
 324                                 project->addMember(director);
 325                         }
 326
 327                         project->setOpen(true);
 328                         d->projects[projectName] = project;
 329
 330                         project->aboutToSave();
 331                         XDBMS::Manager::self()->addObject("projects", project);
 332
 333                         if( project->save() )
 334                         {
 335                                 cnx->sendError( QObject::tr("Project imported successfully"), Dash::Network::Package::Error::Info);
 336                         }
 337                 }
 338                 else
 339                 {
 340                         cnx->sendError( QObject::tr("Cannot import the project"), Dash::Network::Package::Error::Err);
 341                         delete project;
 342                 }
 343         }
 344 }
 345
 346 }
 347 }
 348