*/

#include <Swift/Controllers/HistoryController.h>

#include <Swiften/History/HistoryMessage.h>

#include <boost/date_time/c_local_time_adjustor.hpp>

namespace Swift {

}

HistoryController::~HistoryController() {

}

void HistoryController::addMessage(const std::string& message, const JID& fromJID, const JID& toJID, HistoryMessage::Type type, const boost::posix_time::ptime& timeStamp) {

#include <set>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/History/HistoryMessage.h>

namespace Swift {

class JID;

class HistoryController {

public:

~HistoryController();

void addMessage(const std::string& message, const JID& fromJID, const JID& toJID, HistoryMessage::Type type, const boost::posix_time::ptime& timeStamp);

boost::signal<void (const HistoryMessage&)> onNewMessage;

private:

bool remoteArchiveSupported_;

};

}

#include <boost/shared_ptr.hpp>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <set>

namespace Swift {

class HistoryController;

class NickResolver;

class AvatarManager;

class HistoryViewController {

public:

idleDetector_->onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

resetClient();

delete fileTransferListController_;

delete xmlConsoleController_;

delete xmppURIController_;

delete soundEventController_;

delete systemTrayController_;

eventWindowController_ = NULL;

delete chatsManager_;

chatsManager_ = NULL;

delete historyViewController_;

historyViewController_ = NULL;

delete ftOverview_;

* want to have the user's nick available and this means it will

* be before they receive stanzas that need it (e.g. bookmarks).*/

client_->getVCardManager()->requestOwnVCard();

chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_);

historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

#include "Swift/Controllers/Storages/AvatarFileStorage.h"

#include "Swift/Controllers/Storages/CapsFileStorage.h"

#include "Swift/Controllers/Storages/RosterFileStorage.h"

namespace Swift {

capsStorage = new CapsFileStorage(baseDir / "caps");

avatarStorage = new AvatarFileStorage(baseDir / "avatars", baseDir / profile / "avatars");

rosterStorage = new RosterFileStorage(baseDir / profile / "roster.xml");

}

FileStorages::~FileStorages() {

delete avatarStorage;

delete capsStorage;

delete vcardStorage;

}

VCardStorage* FileStorages::getVCardStorage() const {

return rosterStorage;

}

}

class AvatarFileStorage;

class CapsFileStorage;

class RosterFileStorage;

class JID;

/**

virtual AvatarStorage* getAvatarStorage() const;

virtual CapsStorage* getCapsStorage() const;

virtual RosterStorage* getRosterStorage() const;

private:

VCardFileStorage* vcardStorage;

AvatarFileStorage* avatarStorage;

CapsFileStorage* capsStorage;

RosterFileStorage* rosterStorage;

};

}

#include <Swiften/Avatars/AvatarMemoryStorage.h>

#include <Swiften/Disco/CapsMemoryStorage.h>

#include <Swiften/Roster/RosterMemoryStorage.h>

namespace Swift {

capsStorage = new CapsMemoryStorage();

avatarStorage = new AvatarMemoryStorage();

rosterStorage = new RosterMemoryStorage();

}

MemoryStorages::~MemoryStorages() {

delete avatarStorage;

delete capsStorage;

delete vcardStorage;

}

VCardStorage* MemoryStorages::getVCardStorage() const {

return rosterStorage;

}

}

virtual AvatarStorage* getAvatarStorage() const;

virtual CapsStorage* getCapsStorage() const;

virtual RosterStorage* getRosterStorage() const;

private:

VCardMemoryStorage* vcardStorage;

AvatarStorage* avatarStorage;

CapsStorage* capsStorage;

RosterStorage* rosterStorage;

};

}

class AvatarStorage;

class CapsStorage;

class RosterStorage;

/**

* An interface to hold storage classes for different

virtual AvatarStorage* getAvatarStorage() const = 0;

virtual CapsStorage* getCapsStorage() const = 0;

virtual RosterStorage* getRosterStorage() const = 0;

};

}

namespace Swift {

typedef std::map<JID, std::set<boost::gregorian::date> > ContactsMap;

/**

* Messages are stored using localtime timestamps.

*/

public:

virtual void addMessage(const HistoryMessage& message) = 0;

virtual std::vector<HistoryMessage> getMessagesFromDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const = 0;

virtual std::vector<HistoryMessage> getMessagesFromNextDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const = 0;

virtual std::vector<HistoryMessage> getMessagesFromPreviousDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const = 0;

myenv.MergeFlags(swiften_env.get("SQLITE_FLAGS", {}))

objects = myenv.SwiftenObject([

])

swiften_env.Append(SWIFTEN_OBJECTS = [objects])

#include <boost/lexical_cast.hpp>

#include <sqlite3.h>

#include <boost/date_time/gregorian/gregorian.hpp>

inline std::string getEscapedString(const std::string& s) {

namespace Swift {

sqlite3_open(file.c_str(), &db_);

if (!db_) {

}

char* errorMessage;

}

}

sqlite3_close(db_);

}

int secondsSinceEpoch = (message.getTime() - boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1))).total_seconds();

std::string statement = std::string("INSERT INTO messages('message', 'fromBare', 'fromResource', 'toBare', 'toResource', 'type', 'time', 'offset') VALUES(") +

}

}

sqlite3_stmt* selectStatement;

boost::optional<int> selfID = getIDFromJID(selfJID.toBare());

return result;

}

boost::optional<int> id = getIDFromJID(jid);

if (id) {

return *id;

}

}

std::string statement = std::string("INSERT INTO jids('jid') VALUES('") + getEscapedString(jid.toString()) + "')";

char* errorMessage;

int result = sqlite3_exec(db_, statement.c_str(), 0, 0, &errorMessage);

return sqlite3_last_insert_rowid(db_);

}

boost::optional<JID> result;

sqlite3_stmt* selectStatement;

std::string selectQuery("SELECT jid FROM jids WHERE id=" + boost::lexical_cast<std::string>(id));

return result;

}

boost::optional<int> result;

sqlite3_stmt* selectStatement;

std::string selectQuery("SELECT id FROM jids WHERE jid='" + jid.toString() + "'");

return result;

}

ContactsMap result;

sqlite3_stmt* selectStatement;

return result;

}

sqlite3_stmt* selectStatement;

boost::optional<int> selfID = getIDFromJID(selfJID.toBare());

boost::optional<int> contactID = getIDFromJID(contactJID.toBare());

return boost::gregorian::date(boost::gregorian::not_a_date_time);

}

boost::gregorian::date nextDate = getNextDateWithLogs(selfJID, contactJID, type, date, false);

if (nextDate.is_not_a_date()) {

return getMessagesFromDate(selfJID, contactJID, type, nextDate);

}

boost::gregorian::date previousDate = getNextDateWithLogs(selfJID, contactJID, type, date, true);

if (previousDate.is_not_a_date()) {

return getMessagesFromDate(selfJID, contactJID, type, previousDate);

}

boost::optional<int> selfID = getIDFromJID(selfJID.toBare());

boost::optional<int> mucID = getIDFromJID(mucJID.toBare());

#include <boost/optional.hpp>

struct sqlite3;

namespace Swift {

public:

void addMessage(const HistoryMessage& message);

ContactsMap getContacts(const JID& selfJID, HistoryMessage::Type type, const std::string& keyword) const;