From 2ba5228d0483798a9e122670d15a078c4478898f Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Tue, 15 Sep 2009 16:11:54 +0200 Subject: Added UserListManager module --- src/Common/RequestManager.h | 29 ++++++- src/mad-server.conf | 2 + src/modules/CMakeLists.txt | 2 + src/modules/UserListManager/CMakeLists.txt | 14 ++++ src/modules/UserListManager/Module.cpp | 39 ++++++++++ src/modules/UserListManager/Module.h | 44 +++++++++++ .../UserListRequestHandlerGroup.cpp | 77 +++++++++++++++++++ .../RequestHandlers/UserListRequestHandlerGroup.h | 58 ++++++++++++++ .../UserListUploadRequestHandler.cpp | 83 ++++++++++++++++++++ .../RequestHandlers/UserListUploadRequestHandler.h | 51 +++++++++++++ src/modules/UserListManager/UserList.h | 40 ++++++++++ src/modules/UserListManager/UserListEntry.h | 89 ++++++++++++++++++++++ src/modules/UserListManager/UserListManager.cpp | 84 ++++++++++++++++++++ src/modules/UserListManager/UserListManager.h | 76 ++++++++++++++++++ src/modules/UserListManager/Util.cpp | 70 +++++++++++++++++ src/modules/UserListManager/Util.h | 51 +++++++++++++ 16 files changed, 806 insertions(+), 3 deletions(-) create mode 100644 src/modules/UserListManager/CMakeLists.txt create mode 100644 src/modules/UserListManager/Module.cpp create mode 100644 src/modules/UserListManager/Module.h create mode 100644 src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp create mode 100644 src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h create mode 100644 src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp create mode 100644 src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h create mode 100644 src/modules/UserListManager/UserList.h create mode 100644 src/modules/UserListManager/UserListEntry.h create mode 100644 src/modules/UserListManager/UserListManager.cpp create mode 100644 src/modules/UserListManager/UserListManager.h create mode 100644 src/modules/UserListManager/Util.cpp create mode 100644 src/modules/UserListManager/Util.h diff --git a/src/Common/RequestManager.h b/src/Common/RequestManager.h index 4704a0f..aef6b90 100644 --- a/src/Common/RequestManager.h +++ b/src/Common/RequestManager.h @@ -70,12 +70,12 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable { - template class RequestHandlerFactory : public RequestHandlerGroup { + template class RequestHandlerFactory0 : public RequestHandlerGroup { private: std::set types; public: - RequestHandlerFactory(const std::string &type) { + RequestHandlerFactory0(const std::string &type) { types.insert(type); } @@ -88,6 +88,25 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable { } }; + template class RequestHandlerFactory1 : public RequestHandlerGroup { + private: + std::set types; + T1 arg1; + + public: + RequestHandlerFactory1(const std::string &type, T1 argT1) : arg1(argT1) { + types.insert(type); + } + + virtual const std::set& getPacketTypes() { + return types; + } + + virtual boost::shared_ptr createRequestHandler(Application *application, const std::string& /*type*/) { + return boost::shared_ptr(new T(application, arg1)); + } + }; + Application *application; boost::shared_mutex mutex; @@ -146,7 +165,11 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable { } template void registerPacketType(const std::string &type) { - registerRequestHandlerGroup(boost::shared_ptr >(new RequestHandlerFactory(type))); + registerRequestHandlerGroup(boost::shared_ptr >(new RequestHandlerFactory0(type))); + } + + template void registerPacketType(const std::string &type, T1 arg1) { + registerRequestHandlerGroup(boost::shared_ptr >(new RequestHandlerFactory1(type, arg1))); } void unregisterPacketType(const std::string &type) { diff --git a/src/mad-server.conf b/src/mad-server.conf index 1fb02e2..d83f9b4 100644 --- a/src/mad-server.conf +++ b/src/mad-server.conf @@ -13,6 +13,8 @@ LoadModule "UserDBBackendMysql" LoadModule "UserConfigBackendHome" LoadModule "UserConfigBackendKrb5" +LoadModule "UserListManager" + Log Console { Level "verbose" } diff --git a/src/modules/CMakeLists.txt b/src/modules/CMakeLists.txt index 2f497de..6681ad7 100644 --- a/src/modules/CMakeLists.txt +++ b/src/modules/CMakeLists.txt @@ -53,6 +53,8 @@ if(MYSQL_FOUND) add_subdirectory(UserDBBackendMysql) endif(MYSQL_FOUND) +add_subdirectory(UserListManager) + SET(STATIC_MODULE_LOADERS "") SET(STATIC_MODULE_LIST "") diff --git a/src/modules/UserListManager/CMakeLists.txt b/src/modules/UserListManager/CMakeLists.txt new file mode 100644 index 0000000..0ab429f --- /dev/null +++ b/src/modules/UserListManager/CMakeLists.txt @@ -0,0 +1,14 @@ +include_directories(${INCLUDES}) + +mad_module(UserListManager + RequestHandlers/UserListRequestHandlerGroup.cpp RequestHandlers/UserListRequestHandlerGroup.h + RequestHandlers/UserListUploadRequestHandler.cpp RequestHandlers/UserListUploadRequestHandler.h + + Module.cpp Module.h + UserList.h + UserListEntry.h + UserListManager.cpp UserListManager.h + Util.cpp Util.h +) + +mad_module_libraries(UserListManager) diff --git a/src/modules/UserListManager/Module.cpp b/src/modules/UserListManager/Module.cpp new file mode 100644 index 0000000..2145a32 --- /dev/null +++ b/src/modules/UserListManager/Module.cpp @@ -0,0 +1,39 @@ +/* + * Module.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#include "../export.h" + +#include "Module.h" + +#include + +extern "C" { + +MAD_MODULE_EXPORT Mad::Common::Module* UserListManager_create(Mad::Common::Application *application) { + Mad::Server::Application *serverApp = dynamic_cast(application); + + if(!serverApp) { + application->log(Mad::Core::Logger::LOG_ERROR, "UserListManager: This module can be used with mad-server only."); + return 0; + } + + return new Mad::Modules::UserListManager::Module(serverApp); +} + +} diff --git a/src/modules/UserListManager/Module.h b/src/modules/UserListManager/Module.h new file mode 100644 index 0000000..035cdaa --- /dev/null +++ b/src/modules/UserListManager/Module.h @@ -0,0 +1,44 @@ +/* + * Module.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_MODULE_H_ +#define MAD_MODULES_USERLISTMANAGER_MODULE_H_ + +#include "UserListManager.h" +#include + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class Module : public Common::Module { + private: + boost::scoped_ptr userListManager; + + public: + Module(Server::Application *application) : userListManager(new UserListManager(application)) {} +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_MODULE_H_ */ diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp new file mode 100644 index 0000000..98d2815 --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp @@ -0,0 +1,77 @@ +/* + * UserListRequestHandlerGroup.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#include "UserListRequestHandlerGroup.h" +#include "../UserListManager.h" +#include "../Util.h" + +namespace Mad { +namespace Modules { +namespace UserListManager { +namespace RequestHandlers { + +void UserListRequestHandlerGroup::handleUserListListRequest(boost::shared_ptr /*packet*/, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + const std::set &userLists = userListManager->getUserLists(); + + ret->setType("OK"); + Common::XmlData::List *list = ret->createList("userLists"); + + for(std::set::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 packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + boost::shared_ptr userList = userListManager->loadUserList(packet->get("name")); + if(!userList) + throw(Core::Exception(Core::Exception::NOT_FOUND)); + + ret->setType("OK"); + Util::serializeUserList(userList.get(), ret); +} + +void UserListRequestHandlerGroup::handleUserListRemoveRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + userListManager->removeUserList(packet->get("name")); + + ret->setType("OK"); +} + +UserListRequestHandlerGroup::UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0) +: application(application0), userListManager(userListManager0) { + registerHandler("ListUserLists", boost::bind(&UserListRequestHandlerGroup::handleUserListListRequest, this, _1, _2, _3)); + registerHandler("DownloadUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListDownloadRequest, this, _1, _2, _3)); + registerHandler("RemoveUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListRemoveRequest, this, _1, _2, _3)); +} + +} +} +} +} diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h new file mode 100644 index 0000000..2aeda6b --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h @@ -0,0 +1,58 @@ +/* + * UserListRequestHandlerGroup.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ +#define MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ + +#include "../../export.h" + +#include + +namespace Mad { + +namespace Server { +class Application; +} + +namespace Modules { +namespace UserListManager { + +class UserListManager; + +namespace RequestHandlers { + +class MAD_MODULE_EXPORT UserListRequestHandlerGroup : public Common::RequestHandlers::SimpleRequestHandlerGroup { + private: + Server::Application *application; + UserListManager *userListManager; + + void handleUserListListRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDownloadRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListRemoveRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + + public: + UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0); +}; + +} +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ */ diff --git a/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp new file mode 100644 index 0000000..9d01b5e --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp @@ -0,0 +1,83 @@ +/* + * UserListUploadRequestHandler.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#include "UserListUploadRequestHandler.h" +#include "../UserListManager.h" +#include "../Util.h" + +#include + + +namespace Mad { +namespace Modules { +namespace UserListManager { +namespace RequestHandlers { + +void UserListUploadRequestHandler::handlePacket(boost::shared_ptr 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)); + + if(name.empty()) { // Request + name = packet->get("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 userList = Util::deserializeUserList(packet.get()); + userListManager->storeUserList(name, userList.get()); + + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + } +} + +} +} +} +} diff --git a/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h new file mode 100644 index 0000000..933d4a5 --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h @@ -0,0 +1,51 @@ +/* + * UserListUploadRequestHandler.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ +#define MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class UserListManager; + +namespace RequestHandlers { + +class UserListUploadRequestHandler : public Common::RequestHandler { + private: + std::string name; + + UserListManager *userListManager; + + protected: + virtual void handlePacket(boost::shared_ptr packet); + + public: + UserListUploadRequestHandler(Common::Application *application, UserListManager *userListManager0) : Common::RequestHandler(application), userListManager(userListManager0) {} +}; + +} +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ */ diff --git a/src/modules/UserListManager/UserList.h b/src/modules/UserListManager/UserList.h new file mode 100644 index 0000000..6ca3de4 --- /dev/null +++ b/src/modules/UserListManager/UserList.h @@ -0,0 +1,40 @@ +/* + * UserList.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_USERLIST_H_ +#define MAD_MODULES_USERLISTMANAGER_USERLIST_H_ + +#include "UserListEntry.h" + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class UserList : public std::list { + public: + UserList() {} +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_USERLIST_H_ */ diff --git a/src/modules/UserListManager/UserListEntry.h b/src/modules/UserListManager/UserListEntry.h new file mode 100644 index 0000000..719787f --- /dev/null +++ b/src/modules/UserListManager/UserListEntry.h @@ -0,0 +1,89 @@ +/* + * UserListEntry.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_ +#define MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_ + +#include +#include +#include + + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class UserListEntry { + private: + std::string name; + std::string group; + + std::map details; + + public: + UserListEntry(const std::string &name0 = std::string(), const std::string &group0 = std::string()) : name(name0), group(group0) {} + + const std::string& getName() const { + return name; + } + + void setName(const std::string &newName) { + name = newName; + } + + const std::string& getGroup() const { + return group; + } + + void setGroup(const std::string &newGroup) { + group = newGroup; + } + + std::set getDetailList() const { + std::set ret; + + for(std::map::const_iterator it = details.begin(); it != details.end(); ++it) + ret.insert(it->first); + + return ret; + } + + std::string getDetail(const std::string &name) const { + std::map::const_iterator it = details.find(name); + if(it != details.end()) + return it->second; + else + return std::string(); + } + + void setDetail(const std::string &name, const std::string &value) { + details.erase(name); + details.insert(std::make_pair(name, value)); + } + + void unsetDetail(const std::string &name) { + details.erase(name); + } +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_ */ diff --git a/src/modules/UserListManager/UserListManager.cpp b/src/modules/UserListManager/UserListManager.cpp new file mode 100644 index 0000000..c6e2c64 --- /dev/null +++ b/src/modules/UserListManager/UserListManager.cpp @@ -0,0 +1,84 @@ +/* + * UserListManager.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#include "UserListManager.h" +#include "Util.h" +#include "RequestHandlers/UserListRequestHandlerGroup.h" +#include "RequestHandlers/UserListUploadRequestHandler.h" + +#include +#include +#include +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +UserListManager::UserListManager(Server::Application *application0) : application(application0), requestHandlerGroup(new RequestHandlers::UserListRequestHandlerGroup(application, this)) { + application->getConfigManager()->registerConfigurable(this); +} + +UserListManager::~UserListManager() { + application->getRequestManager()->unregisterPacketType("UploadUserList"); + application->getRequestManager()->unregisterRequestHandlerGroup(requestHandlerGroup); + application->getConfigManager()->unregisterConfigurable(this); +} + + +void UserListManager::configFinished() { + userLists = application->getStorageManager()->list("UserList"); + + application->getRequestManager()->registerRequestHandlerGroup(requestHandlerGroup); + application->getRequestManager()->registerPacketType("UploadUserList", this); +} + + +const std::set& UserListManager::getUserLists() const { + return userLists; +} + + +bool UserListManager::existsUserList(const std::string &name) { + return application->getStorageManager()->exists("UserList", name); +} + +boost::shared_ptr UserListManager::loadUserList(const std::string &name) { + boost::shared_ptr data = application->getStorageManager()->load("UserList", name); + + if(!data) + return boost::shared_ptr(); + + return Util::deserializeUserList(data.get()); +} + +void UserListManager::storeUserList(const std::string &name, const UserList *list) { + Common::XmlData data; + + Util::serializeUserList(list, &data); + application->getStorageManager()->store("UserList", name, &data); +} + +void UserListManager::removeUserList(const std::string &name) { + application->getStorageManager()->remove("UserList", name); +} + +} +} +} diff --git a/src/modules/UserListManager/UserListManager.h b/src/modules/UserListManager/UserListManager.h new file mode 100644 index 0000000..b31b27a --- /dev/null +++ b/src/modules/UserListManager/UserListManager.h @@ -0,0 +1,76 @@ +/* + * UserListManager.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_ +#define MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_ + +#include "../export.h" + +#include + +#include +#include + +#include + +namespace Mad { + +namespace Server { +class Application; +} + +namespace Modules { +namespace UserListManager { + +namespace RequestHandlers { +class UserListRequestHandlerGroup; +} + +class UserList; + +class MAD_MODULE_EXPORT UserListManager : private Core::Configurable, private boost::noncopyable { + private: + Server::Application *application; + + boost::shared_ptr requestHandlerGroup; + + std::set userLists; + + protected: + virtual void configFinished(); + + public: + virtual int getPriority() const {return -1;} + + UserListManager(Server::Application *application0); + virtual ~UserListManager(); + + const std::set& getUserLists() const; + + bool existsUserList(const std::string &name); + boost::shared_ptr loadUserList(const std::string &name); + void storeUserList(const std::string &name, const UserList *list); + void removeUserList(const std::string &name); +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_ */ diff --git a/src/modules/UserListManager/Util.cpp b/src/modules/UserListManager/Util.cpp new file mode 100644 index 0000000..f9b6a55 --- /dev/null +++ b/src/modules/UserListManager/Util.cpp @@ -0,0 +1,70 @@ +/* + * Util.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#include "Util.h" +#include "UserList.h" + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +void Util::serializeUserList(const UserList *list, Common::XmlData *data) { + Common::XmlData::List *userList = data->createList("users"); + + for(UserList::const_iterator user = list->begin(); user != list->end(); ++user) { + Common::XmlData::List::iterator entry = userList->addEntry(); + + std::set details = user->getDetailList(); + for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) + entry->set(*detail, user->getDetail(*detail)); + + entry->set("name", user->getName()); + entry->set("group", user->getGroup()); + } +} + +boost::shared_ptr Util::deserializeUserList(const Common::XmlData *data) { + boost::shared_ptr users(new UserList); + + const Common::XmlData::List *userList = data->getList("users"); + + if(userList) { + for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) { + UserListEntry entry(user->get("name"), user->get("group")); + + std::set details = user->getChildren(); + for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) { + if(*detail == "user" || *detail == "group") + continue; + + entry.setDetail(*detail, user->get(*detail)); + } + + users->push_back(entry); + } + } + + return users; +} + +} +} +} diff --git a/src/modules/UserListManager/Util.h b/src/modules/UserListManager/Util.h new file mode 100644 index 0000000..6af35cc --- /dev/null +++ b/src/modules/UserListManager/Util.h @@ -0,0 +1,51 @@ +/* + * Util.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * 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 . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_UTIL_H_ +#define MAD_MODULES_USERLISTMANAGER_UTIL_H_ + +#include "../export.h" + +#include + +namespace Mad { + +namespace Common { +class XmlData; +} + +namespace Modules { +namespace UserListManager { + +class UserList; + +class MAD_MODULE_EXPORT Util { + private: + Util(); + + public: + static void serializeUserList(const UserList *list, Common::XmlData *data); + static boost::shared_ptr deserializeUserList(const Common::XmlData *data); +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_UTIL_H_ */ -- cgit v1.2.3