src/dashserver/project/projectmanager.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 "projectmanager.h"
  23
  24 #include <QVariant>
  25 #include <QXmlStreamReader>
  26 #include <QXmlStreamWriter>
  27
  28 #include <dashserver/server.h>
  29 #include <dashserver/package.h>
  30 #include <dashserver/connection.h>
  31
  32 #include <dash/network/package/error.h>
  33 #include <dash/network/package/projectlist.h>
  34 #include <dash/network/parser/projectactionparser.h>
  35
  36 #include <dcore/debug.h>
  37
  38 #include "store.h"
  39 #include "project.h"
  40 #include "member.h"
  41
  42 #include "dashserver/users/user.h"
  43 #include "dashserver/xdbms/manager.h"
  44 #include "dashserver/xdbms/table.h"
  45
  46
  47 namespace DashServer {
  48 namespace Project {
  49
  50 struct Manager::Private
  51 {
  52         Store *store;
  53 };
  54
  55 Manager::Manager()
  56  : DashServer::Observer(), d(new Private)
  57 {
  58         d->store = new Store;
  59 }
  60
  61
  62 Manager::~Manager()
  63 {
  64         delete d->store;
  65         delete d;
  66 }
  67
  68 void Manager::handlePackage(DashServer::Package* const pkg)
  69 {
  70         DashServer::TcpServer *server = pkg->source()->server();
  71
  72         if( pkg->root() == "command" )
  73         {
  74                 if( !d->store->execute(pkg->xml(), pkg->source() ) )
  75                 {
  76                         pkg->source()->sendError(QObject::tr("Cannot execute command"), Dash::Network::Package::Error::Err);
  77                 }
  78                 pkg->accept();
  79         }
  80         else if( pkg->root() == "listprojects" )
  81         {
  82                 QList<Project *> projects = d->store->allProjects();
  83
  84                 Dash::Network::Package::ProjectList plist;
  85
  86                 foreach(Project *p, projects)
  87                 {
  88                         plist.addProject(p->projectName(), p->author(), p->description());
  89                 }
  90
  91                 pkg->source()->sendToClient(plist.toString(), true);
  92
  93
  94                 qDeleteAll(projects);
  95                 pkg->accept();
  96         }
  97         else if( pkg->root() == "openproject" )
  98         {
  99                 QString project;
 100                 {
 101                         QXmlStreamReader reader(pkg->xml());
 102                         while(!reader.atEnd())
 103                         {
 104                                 reader.readNext();
 105
 106                                 if( reader.tokenType() == QXmlStreamReader::StartElement )
 107                                 {
 108                                         if( reader.name().toString() == "project" )
 109                                         {
 110                                                 project = reader.attributes().value("name").toString();
 111                                                 break;
 112                                         }
 113                                 }
 114                         }
 115                 }
 116
 117                 if( !project.isEmpty() )
 118                 {
 119                         d->store->openProject(project, pkg->source());
 120                         pkg->accept();
 121                 }
 122                 else
 123                 {
 124                         // TODO: Enviar mensaje de error.
 125                 }
 126         }
 127         else if( pkg->root() == "newproject" )
 128         {
 129                 QString projectName, author, description;
 130
 131                 QXmlStreamReader reader(pkg->xml());
 132                 while(!reader.atEnd())
 133                 {
 134                         reader.readNext();
 135
 136                         if( reader.tokenType() == QXmlStreamReader::StartElement )
 137                         {
 138                                 if( reader.name().toString() == "name" )
 139                                 {
 140                                         projectName = reader.readElementText();
 141                                 }
 142                                 else if( reader.name().toString() == "author" )
 143                                 {
 144                                         author = reader.readElementText();
 145                                 }
 146                                 else if( reader.name().toString() == "description" )
 147                                 {
 148                                         description = reader.readElementText();
 149                                 }
 150                         }
 151                 }
 152
 153                 if( !d->store->contains(projectName) )
 154                 {
 155                         if( d->store->createProject(projectName, author, description, pkg->source()->user()->login()) )
 156                         {
 157                                 dfDebug << "Created project: " << projectName;
 158                                 d->store->addToProject(projectName, pkg->source());
 159                         }
 160                 }
 161                 else
 162                 {
 163                         // TODO: enviar mensaje de error
 164                 }
 165
 166                 pkg->accept();
 167         }
 168         else if(pkg->root() == "updateproject" )
 169         {
 170                 Dash::Network::Parser::ProjectAction parser;
 171
 172                 if(parser.parse(pkg->xml()))
 173                 {
 174                         QString projectName = parser.name();
 175                         QString newDescription = parser.description();
 176                         QString newAuthor =  parser.author();
 177
 178                         if(Project::Project *project = d->store->project(projectName))
 179                         {
 180                                 if(!newDescription.isEmpty())
 181                                 {
 182                                         project->setDescription(newDescription);
 183                                 }
 184                                 if(!newAuthor.isEmpty())
 185                                 {
 186                                         project->setAuthor(newAuthor);
 187                                 }
 188
 189
 190                                 QList<Dash::Network::Parser::ProjectAction::Member> members = parser.members();
 191
 192                                 foreach(Dash::Network::Parser::ProjectAction::Member member, members)
 193                                 {
 194                                         Member *mem = new Member();
 195                                         mem->setUser(member.login);
 196                                         mem->setJob(member.job);
 197                                         D_SHOW_VAR(member.login);
 198                                         QList<Dash::Network::Permission> permissions = member.profile.permissions();
 199
 200
 201                                         foreach(Dash::Network::Permission permission, permissions)
 202                                         {
 203                                                 Users::Permission *perm = new Users::Permission();
 204
 205                                                 perm->setId(permission.name());
 206                                                 perm->setName(permission.name());
 207                                                 perm->setRead(permission.read());
 208                                                 perm->setWrite(permission.write());
 209
 210                                                 mem->addPermission(perm);
 211                                         }
 212
 213                                         D_SHOW_VAR(mem->objects().size());
 214                                         project->addMember(mem);
 215                                 }
 216
 217                                 project->aboutToSave();
 218
 219                                 if( XDBMS::Manager::self()->update("projects", project) )
 220                                 {
 221                                         server->sendToAdmins(pkg->xml());
 222                                         pkg->accept();
 223                                 }
 224                                 delete project;
 225                         }
 226                         else
 227                         {
 228                                 pkg->source()->sendError(QObject::tr("Project not exist"), Dash::Network::Package::Error::Err);
 229                         }
 230
 231                         pkg->accept();
 232                 }
 233         }
 234         else if(pkg->root() == "queryproject" )
 235         {
 236                 QString projectName;
 237                 QXmlStreamReader reader(pkg->xml());
 238                 while(!reader.atEnd())
 239                 {
 240                         reader.readNext();
 241
 242                         if( reader.tokenType() == QXmlStreamReader::StartElement )
 243                         {
 244                                 if( reader.name().toString() == "name" )
 245                                 {
 246                                         projectName = reader.readElementText();
 247                                 }
 248                         }
 249                 }
 250
 251                 if(!projectName.isEmpty())
 252                 {
 253                         if(Project::Project *project = d->store->project(projectName))
 254                         {
 255                                 QString xml;
 256                                 {
 257                                         QXmlStreamWriter writer(&xml);
 258                                         writer.writeStartElement("projectquery");
 259
 260                                         writer.writeStartElement("name");
 261                                         writer.writeCharacters(project->projectName());
 262                                         writer.writeEndElement();
 263
 264                                         writer.writeStartElement("description");
 265                                         writer.writeCharacters(project->description());
 266                                         writer.writeEndElement();
 267
 268                                         writer.writeStartElement("author");
 269                                         writer.writeCharacters(project->author());
 270                                         writer.writeEndElement();
 271
 272                                         writer.writeStartElement("members");
 273
 274                                         QHash<QString, Member *> members = project->members();
 275                                         foreach(Member *member, members)
 276                                         {
 277                                                 writer.writeStartElement("user");
 278                                                 writer.writeAttribute("login", member->user().login());
 279                                                 writer.writeAttribute("job", member->job());
 280
 281                                                 QHash<QString, Users::Permission *> permissions = member->permissions();
 282                                                 QHash<QString, Users::Permission *>::iterator it = permissions.begin();
 283
 284                                                 writer.writeStartElement("permissions");
 285
 286                                                 while(it != permissions.end())
 287                                                 {
 288                                                         writer.writeStartElement("module");
 289                                                         writer.writeAttribute("name", it.key());
 290                                                         writer.writeAttribute("read", QString::number(it.value()->read()));
 291                                                         writer.writeAttribute("write", QString::number(it.value()->write()));
 292                                                         writer.writeEndElement();
 293
 294                                                         it++;
 295                                                 }
 296
 297                                                 writer.writeEndElement();
 298                                                 writer.writeEndElement();
 299                                         }
 300                                         writer.writeEndElement();
 301                                         writer.writeEndElement();
 302
 303                                         DashServer::Connection *cnn = pkg->source();
 304                                         cnn->sendToClient(xml, true);
 305                                         delete project;
 306                                 }
 307                         }
 308                 }
 309                 else
 310                 {
 311                         pkg->source()->sendError(QObject::tr("Project not exist"), Dash::Network::Package::Error::Err);
 312                 }
 313                 pkg->accept();
 314         }
 315         else
 316         {
 317                 dfDebug << "Unhandled package: " << pkg->root();
 318         }
 319 }
 320
 321 void Manager::connectionClosed(DashServer::Connection *cnx)
 322 {
 323         d->store->removeClient(cnx);
 324 }
 325
 326 void Manager::sendToMembers(const QString &projectName, const QString &pkg)
 327 {
 328         d->store->sendToMembers(projectName, pkg);
 329 }
 330
 331 void Manager::resendProject(const QString &projectName)
 332 {
 333         d->store->resendProject(projectName);
 334 }
 335
 336 }
 337
 338 }