diff options
Diffstat (limited to 'src/Server/RequestHandlers')
6 files changed, 483 insertions, 0 deletions
diff --git a/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.cpp b/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.cpp new file mode 100644 index 0000000..05aadf8 --- /dev/null +++ b/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.cpp @@ -0,0 +1,84 @@ +/* + * UserListDiffUploadRequestHandler.cpp + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "UserListDiffUploadRequestHandler.h" +#include "../Application.h" +#include "../UserListManager.h" + +#include <Common/UserLists/Util.h> + +#include <boost/date_time/posix_time/posix_time.hpp> + +namespace Mad { +namespace Server { +namespace RequestHandlers { + +void UserListDiffUploadRequestHandler::handlePacket(boost::shared_ptr<const Common::XmlData> packet) { + if(packet->getType() == "Cancel") { + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + return; + } + else if(packet->getType() != "UploadUserListDiff") { + getApplication()->log(Core::Logger::LOG_ERROR, "Received an unexpected packet."); + + Common::XmlData ret; + ret.setType("Error"); + ret.set("ErrorCode", Core::Exception::UNEXPECTED_PACKET); + + sendPacket(ret); + + signalFinished(); + return; + } + + if(!getConnection()->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + UserListManager *userListManager = dynamic_cast<Application*>(getApplication())->getUserListManager(); + + if(name.empty()) { // Request + name = packet->get<const std::string&>("name"); + + if(name.empty()) + name = boost::posix_time::to_simple_string(boost::posix_time::second_clock::universal_time()); + + Common::XmlData ret; + ret.setType("Continue"); + ret.set("exists", userListManager->existsUserListDiff(name)); + sendPacket(ret); + } + else { // Upload + boost::shared_ptr<Common::UserLists::UserListDiff> diff = Common::UserLists::Util::deserializeUserListDiff(packet.get()); + userListManager->storeUserListDiff(name, diff.get()); + + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + } +} + +} +} +} diff --git a/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.h b/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.h new file mode 100644 index 0000000..3d74253 --- /dev/null +++ b/src/Server/RequestHandlers/UserListDiffUploadRequestHandler.h @@ -0,0 +1,47 @@ +/* + * UserListDiffUploadRequestHandler.h + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef MAD_SERVER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ +#define MAD_SERVER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ + +#include <Common/RequestHandler.h> + +namespace Mad { +namespace Server { + +class UserListManager; + +namespace RequestHandlers { + +class UserListDiffUploadRequestHandler : public Common::RequestHandler { + private: + std::string name; + + protected: + virtual void handlePacket(boost::shared_ptr<const Common::XmlData> packet); + + public: + UserListDiffUploadRequestHandler(Common::Application *application) : Common::RequestHandler(application) {} +}; + +} +} +} + +#endif /* MAD_SERVER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ */ diff --git a/src/Server/RequestHandlers/UserListRequestHandlerGroup.cpp b/src/Server/RequestHandlers/UserListRequestHandlerGroup.cpp new file mode 100644 index 0000000..bb18194 --- /dev/null +++ b/src/Server/RequestHandlers/UserListRequestHandlerGroup.cpp @@ -0,0 +1,161 @@ +/* + * UserListRequestHandlerGroup.cpp + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "UserListRequestHandlerGroup.h" +#include "../Application.h" +#include "../UserListManager.h" + +#include <Common/UserLists/Util.h> + +namespace Mad { +namespace Server { +namespace RequestHandlers { + +void UserListRequestHandlerGroup::handleUserListListRequest(boost::shared_ptr<const Common::XmlData> /*packet*/, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + const std::set<std::string> &userLists = application->getUserListManager()->getUserLists(); + + ret->setType("OK"); + Common::XmlData::List *list = ret->createList("userLists"); + + for(std::set<std::string>::const_iterator userList = userLists.begin(); userList != userLists.end(); ++userList) { + Common::XmlData::List::iterator entry = list->addEntry(); + + entry->set("name", *userList); + } + +} + +void UserListRequestHandlerGroup::handleUserListDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + boost::shared_ptr<Common::UserLists::UserList> userList = application->getUserListManager()->loadUserList(packet->get<const std::string&>("name")); + if(!userList) + throw(Core::Exception(Core::Exception::NOT_FOUND)); + + ret->setType("OK"); + Common::UserLists::Util::serializeUserList(userList.get(), ret); +} + +void UserListRequestHandlerGroup::handleUserListCopyRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->copyUserList(packet->get<const std::string&>("fromName"), packet->get<const std::string&>("toName")); + + ret->setType("OK"); +} + +void UserListRequestHandlerGroup::handleUserListRenameRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->renameUserList(packet->get<const std::string&>("fromName"), packet->get<const std::string&>("toName")); + + ret->setType("OK"); +} + +void UserListRequestHandlerGroup::handleUserListRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->removeUserList(packet->get<const std::string&>("name")); + + ret->setType("OK"); +} + + +void UserListRequestHandlerGroup::handleUserListDiffListRequest(boost::shared_ptr<const Common::XmlData> /*packet*/, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + const std::set<std::string> &userListDiffs = application->getUserListManager()->getUserListDiffs(); + + ret->setType("OK"); + Common::XmlData::List *list = ret->createList("userListDiffs"); + + for(std::set<std::string>::const_iterator diff = userListDiffs.begin(); diff != userListDiffs.end(); ++diff) { + Common::XmlData::List::iterator entry = list->addEntry(); + + entry->set("name", *diff); + } + +} + +void UserListRequestHandlerGroup::handleUserListDiffDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + boost::shared_ptr<Common::UserLists::UserListDiff> diff = application->getUserListManager()->loadUserListDiff(packet->get<const std::string&>("name")); + if(!diff) + throw(Core::Exception(Core::Exception::NOT_FOUND)); + + ret->setType("OK"); + Common::UserLists::Util::serializeUserListDiff(diff.get(), ret); +} + +void UserListRequestHandlerGroup::handleUserListDiffCopyRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->copyUserListDiff(packet->get<const std::string&>("fromName"), packet->get<const std::string&>("toName")); + + ret->setType("OK"); +} + +void UserListRequestHandlerGroup::handleUserListDiffRenameRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->renameUserListDiff(packet->get<const std::string&>("fromName"), packet->get<const std::string&>("toName")); + + ret->setType("OK"); +} + +void UserListRequestHandlerGroup::handleUserListDiffRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + application->getUserListManager()->removeUserListDiff(packet->get<const std::string&>("name")); + + ret->setType("OK"); +} + + +UserListRequestHandlerGroup::UserListRequestHandlerGroup(Application *application0) +: application(application0) { + registerHandler("ListUserLists", boost::bind(&UserListRequestHandlerGroup::handleUserListListRequest, this, _1, _2, _3)); + registerHandler("DownloadUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListDownloadRequest, this, _1, _2, _3)); + registerHandler("CopyUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListCopyRequest, this, _1, _2, _3)); + registerHandler("RenameUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListRenameRequest, this, _1, _2, _3)); + registerHandler("RemoveUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListRemoveRequest, this, _1, _2, _3)); + + registerHandler("ListUserListDiffs", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffListRequest, this, _1, _2, _3)); + registerHandler("DownloadUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffDownloadRequest, this, _1, _2, _3)); + registerHandler("CopyUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffCopyRequest, this, _1, _2, _3)); + registerHandler("RenameUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffRenameRequest, this, _1, _2, _3)); + registerHandler("RemoveUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffRemoveRequest, this, _1, _2, _3)); +} + +} +} +} diff --git a/src/Server/RequestHandlers/UserListRequestHandlerGroup.h b/src/Server/RequestHandlers/UserListRequestHandlerGroup.h new file mode 100644 index 0000000..a7e09b3 --- /dev/null +++ b/src/Server/RequestHandlers/UserListRequestHandlerGroup.h @@ -0,0 +1,59 @@ +/* + * UserListRequestHandlerGroup.h + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef MAD_SERVER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ +#define MAD_SERVER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ + +#include "../export.h" + +#include <Common/RequestHandlers/SimpleRequestHandlerGroup.h> + +namespace Mad { +namespace Server { + +class Application; +class UserListManager; + +namespace RequestHandlers { + +class MAD_SERVER_EXPORT UserListRequestHandlerGroup : public Common::RequestHandlers::SimpleRequestHandlerGroup { + private: + Application *application; + + void handleUserListListRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListCopyRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListRenameRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + + void handleUserListDiffListRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffCopyRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffRenameRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection); + + public: + UserListRequestHandlerGroup(Application *application0); +}; + +} +} +} + +#endif /* MAD_SERVER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ */ diff --git a/src/Server/RequestHandlers/UserListUploadRequestHandler.cpp b/src/Server/RequestHandlers/UserListUploadRequestHandler.cpp new file mode 100644 index 0000000..307863a --- /dev/null +++ b/src/Server/RequestHandlers/UserListUploadRequestHandler.cpp @@ -0,0 +1,85 @@ +/* + * UserListUploadRequestHandler.cpp + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "UserListUploadRequestHandler.h" +#include "../Application.h" +#include "../UserListManager.h" + +#include <Common/UserLists/Util.h> + +#include <boost/date_time/posix_time/posix_time.hpp> + + +namespace Mad { +namespace Server { +namespace RequestHandlers { + +void UserListUploadRequestHandler::handlePacket(boost::shared_ptr<const Common::XmlData> packet) { + if(packet->getType() == "Cancel") { + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + return; + } + else if(packet->getType() != "UploadUserList") { + getApplication()->log(Core::Logger::LOG_ERROR, "Received an unexpected packet."); + + Common::XmlData ret; + ret.setType("Error"); + ret.set("ErrorCode", Core::Exception::UNEXPECTED_PACKET); + + sendPacket(ret); + + signalFinished(); + return; + } + + if(!getConnection()->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + UserListManager *userListManager = dynamic_cast<Application*>(getApplication())->getUserListManager(); + + if(name.empty()) { // Request + name = packet->get<const std::string&>("name"); + + if(name.empty()) + name = boost::posix_time::to_simple_string(boost::posix_time::second_clock::universal_time()); + + Common::XmlData ret; + ret.setType("Continue"); + ret.set("exists", userListManager->existsUserList(name)); + sendPacket(ret); + } + else { // Upload + boost::shared_ptr<Common::UserLists::UserList> userList = Common::UserLists::Util::deserializeUserList(packet.get()); + userListManager->storeUserList(name, userList.get()); + + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + } +} + +} +} +} diff --git a/src/Server/RequestHandlers/UserListUploadRequestHandler.h b/src/Server/RequestHandlers/UserListUploadRequestHandler.h new file mode 100644 index 0000000..4a20a4c --- /dev/null +++ b/src/Server/RequestHandlers/UserListUploadRequestHandler.h @@ -0,0 +1,47 @@ +/* + * UserListUploadRequestHandler.h + * + * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de> + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef MAD_SERVER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ +#define MAD_SERVER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ + +#include <Common/RequestHandler.h> + +namespace Mad { +namespace Server { + +class UserListManager; + +namespace RequestHandlers { + +class UserListUploadRequestHandler : public Common::RequestHandler { + private: + std::string name; + + protected: + virtual void handlePacket(boost::shared_ptr<const Common::XmlData> packet); + + public: + UserListUploadRequestHandler(Common::Application *application) : Common::RequestHandler(application) {} +}; + +} +} +} + +#endif /* MAD_SERVER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ */ |