/// \return true if user has been found in database

		bool getUser(const std::string &barejid, UserInfo &user);

		/// Changes users online state variable in database.

		/// \param id id of user - UserInfo.id

		/// \param online online state

		void setUserOnline(long id, bool online);

		/// Removes user and all connected data from database.

		/// \param id id of user - UserInfo.id

		/// \return true if user has been found in database and removed

		bool removeUser(long id);

		/// Returns JIDs of all buddies in user's roster.

		/// \param id id of user - UserInfo.id

		/// \param roster string list used to store user's roster

		/// \return true if user has been found in database and roster has been fetched

		bool getBuddies(long id, std::list<BuddyInfo> &roster);

		long addBuddy(long userId, const BuddyInfo &buddyInfo);

		void updateBuddy(long userId, const BuddyInfo &buddyInfo);

		void removeBuddy(long id) {}

		void beginTransaction();

		void commitTransaction();

	private:

		bool exec(const std::string &query);

		sqlite3 *m_db;

		Config *m_config;

		std::string m_prefix;

		// statements

		sqlite3_stmt *m_setUser;

		sqlite3_stmt *m_getUser;

		sqlite3_stmt *m_removeUser;

		sqlite3_stmt *m_removeUserBuddies;

		sqlite3_stmt *m_removeUserSettings;

		sqlite3_stmt *m_removeUserBuddiesSettings;

		sqlite3_stmt *m_addBuddy;

		sqlite3_stmt *m_updateBuddy;

		sqlite3_stmt *m_getBuddies;

		sqlite3_stmt *m_getBuddiesSettings;

};

}

		virtual bool connect() = 0;

		/// createDatabase

		virtual bool createDatabase() = 0;

		/// setUser

		virtual void setUser(const UserInfo &user) = 0;

		/// getuser

		virtual bool getUser(const std::string &barejid, UserInfo &user) = 0;

		/// setUserOnline

		virtual void setUserOnline(long id, bool online) = 0;

		/// removeUser

		virtual bool removeUser(long id) = 0;

		/// getBuddies

		virtual bool getBuddies(long id, std::list<BuddyInfo> &roster) = 0;

		virtual long addBuddy(long userId, const BuddyInfo &buddyInfo) = 0;

		virtual void updateBuddy(long userId, const BuddyInfo &buddyInfo) = 0;

		virtual void removeBuddy(long id) = 0;

		virtual void beginTransaction() = 0;

		virtual void commitTransaction() = 0;

		/// onStorageError

		boost::signal<void (const std::string &statement, const std::string &error)> onStorageError;

};

}

 * the Free Software Foundation; either version 2 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <string>

#include <map>

#include "Swiften/Swiften.h"

namespace Transport {

class User;

class Component;

class StorageBackend;

/// Manages online XMPP Users.

/// This class handles presences and creates User classes when new user connects.

/// It also removes the User class once the last user's resource disconnected.

class UserManager {

	public:

		/// Creates new UserManager.

		/// \param component Component which's presence will be handled

		/// \param storageBackend Storage backend used to fetch UserInfos

		UserManager(Component *component, StorageBackend *storageBackend);

		/// Destroys UserManager.

		~UserManager();

		/// Returns user according to his bare JID.

		/// \param barejid bare JID of user

		/// \return User class associated with this user

		User *getUser(const std::string &barejid);

		/// Returns number of online users.

		/// \return number of online users

		int getUserCount();

		void removeUser(User *user);

		/// Called when new User class is created.

		/// \param user newly created User class

		boost::signal<void (User *user)> onUserCreated;

		/// Called when User class is going to be removed

		/// \param user removed User class

		boost::signal<void (User *user)> onUserDestroyed;

	private:

		void handlePresence(Swift::Presence::ref presence);

		void handleMessageReceived(Swift::Message::ref message);

		void handleGeneralPresenceReceived(Swift::Presence::ref presence);

		void handleProbePresence(Swift::Presence::ref presence);

		void handleSubscription(Swift::Presence::ref presence);

// 		void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

		std::map<std::string, User *> m_users;

		Component *m_component;

		StorageBackend *m_storageBackend;

};

}

	m_prefix = CONFIG_STRING(m_config, "database.prefix");

}

SQLite3Backend::~SQLite3Backend(){

	if (m_db) {

		// Would be nice to use this:

		//

		//   sqlite3_stmt *pStmt;

		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {

		//    sqlite3_finalize(pStmt);

		//   }

		//

		// But requires SQLite3 >= 3.6.0 beta

		FINALIZE_STMT(m_setUser);

		FINALIZE_STMT(m_getUser);

		FINALIZE_STMT(m_removeUser);

		FINALIZE_STMT(m_removeUserBuddies);

		FINALIZE_STMT(m_removeUserSettings);

		FINALIZE_STMT(m_removeUserBuddiesSettings);

		FINALIZE_STMT(m_addBuddy);

		FINALIZE_STMT(m_updateBuddy);

		FINALIZE_STMT(m_getBuddies);

		FINALIZE_STMT(m_getBuddiesSettings);

		sqlite3_close(m_db);

	}

}

bool SQLite3Backend::connect() {

	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {

		sqlite3_close(m_db);

		return false;

	}

	if (createDatabase() == false)

		return false;

	PREP_STMT(m_setUser, "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");

	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");

	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	PREP_STMT(m_updateBuddy, "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	PREP_STMT(m_getBuddies, "SELECT id uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");

	PREP_STMT(m_getBuddiesSettings, "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	return true;

}

bool SQLite3Backend::createDatabase() {

	int not_exist = exec("CREATE TABLE " + m_prefix + "buddies ("

				"  id INTEGER PRIMARY KEY NOT NULL,"

				"  user_id int(10) NOT NULL,"

				"  uin varchar(255) NOT NULL,"

				"  subscription varchar(20) NOT NULL,"

				"  nickname varchar(255) NOT NULL,"

				"  groups varchar(255) NOT NULL,"

				"  flags int(4) NOT NULL DEFAULT '0'"

				");");

	if (not_exist) {

		exec("CREATE UNIQUE INDEX IF NOT EXISTS user_id ON " + m_prefix + "buddies (user_id, uin);");

		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "buddies_settings ("

					"  user_id int(10) NOT NULL,"

					"  buddy_id int(10) NOT NULL,"

					"  var varchar(50) NOT NULL,"

					"  type int(4) NOT NULL,"

					"  value varchar(255) NOT NULL,"

					"  PRIMARY KEY (buddy_id, var)"

					");");

		exec("CREATE INDEX IF NOT EXISTS user_id02 ON " + m_prefix + "buddies_settings (user_id);");

		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "users ("

					"  id INTEGER PRIMARY KEY NOT NULL,"

					"  jid varchar(255) NOT NULL,"

					"  uin varchar(4095) NOT NULL,"

					"  password varchar(255) NOT NULL,"

					"  language varchar(25) NOT NULL,"

					"  encoding varchar(50) NOT NULL DEFAULT 'utf8',"

					"  last_login datetime,"

					"  vip int(1) NOT NULL DEFAULT '0',"

					"  online int(1) NOT NULL DEFAULT '0'"

					");");

		exec("CREATE UNIQUE INDEX IF NOT EXISTS jid ON " + m_prefix + "users (jid);");

		exec("CREATE TABLE " + m_prefix + "users_settings ("

					"  user_id int(10) NOT NULL,"

					"  var varchar(50) NOT NULL,"

					"  type int(4) NOT NULL,"

					"  PRIMARY KEY (user_id, var)"

					");");

		exec("CREATE INDEX IF NOT EXISTS user_id03 ON " + m_prefix + "users_settings (user_id);");

		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "db_version ("

			"  ver INTEGER NOT NULL DEFAULT '3'"

			");");

		exec("REPLACE INTO " + m_prefix + "db_version (ver) values(3)");

	}

	return true;

}

bool SQLite3Backend::exec(const std::string &query) {

	char *errMsg = 0;

	int rc = sqlite3_exec(m_db, query.c_str(), NULL, 0, &errMsg);

	if (rc != SQLITE_OK) {

		onStorageError(query, errMsg);

		sqlite3_free(errMsg);

		return false;

	}

	return true;

}

	sqlite3_reset(m_removeUserSettings);

	sqlite3_bind_int(m_removeUserSettings, 1, id);

	if(sqlite3_step(m_removeUserSettings) != SQLITE_DONE) {

		onStorageError("removeUserSettings query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return false;

	}

	sqlite3_reset(m_removeUserBuddies);

	sqlite3_bind_int(m_removeUserBuddies, 1, id);

	if(sqlite3_step(m_removeUserBuddies) != SQLITE_DONE) {

		onStorageError("removeUserBuddies query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return false;

	}

	sqlite3_reset(m_removeUserBuddiesSettings);

	sqlite3_bind_int(m_removeUserBuddiesSettings, 1, id);

	if(sqlite3_step(m_removeUserBuddiesSettings) != SQLITE_DONE) {

		onStorageError("removeUserBuddiesSettings query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return false;

	}

	return true;

}

void SQLite3Backend::beginTransaction() {

	exec("BEGIN TRANSACTION;");

}

void SQLite3Backend::commitTransaction() {

	exec("COMMIT TRANSACTION;");

}

}

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "transport/usermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

namespace Transport {

UserManager::UserManager(Component *component, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

// 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));

}

UserManager::~UserManager(){

}

void UserManager::addUser(User *user) {

	m_users[user->getJID().toBare().toString()] = user;

	onUserCreated(user);

}

User *UserManager::getUser(const std::string &barejid){

	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

		return m_cachedUser;

	}

	if (m_users.find(barejid) != m_users.end()) {

		User *user = m_users[barejid];

		m_cachedUser = user;

		return user;

	}

	return NULL;

}

void UserManager::removeUser(User *user) {

	m_users.erase(user->getJID().toBare().toString());

	if (m_cachedUser == user)

		m_cachedUser = NULL;