/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Roster/Roster.h>

#include <algorithm>

#include <deque>

#include <memory>

#include <set>

#include <string>

#include <boost/bind.hpp>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Roster/ContactRosterItem.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/RosterItemOperation.h>

#include <Swift/Controllers/Roster/RosterItem.h>

namespace Swift {

root_->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, root_.get()));

}

Roster::~Roster() {

std::deque<RosterItem*> queue;

while (!queue.empty()) {

RosterItem* item = *queue.begin();

queue.pop_front();

GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);

if (group) {

queue.insert(queue.begin(), group->getChildren().begin(), group->getChildren().end());

}

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

if (contact) {

contact->onVCardRequested.disconnect(boost::bind(boost::ref(onVCardUpdateRequested), contact->getJID()));

}

delete item;

}

}

GroupRosterItem* Roster::getRoot() const {

return root_.get();

}

std::set<JID> Roster::getJIDs() const {

std::set<JID> jids;

std::deque<RosterItem*> queue;

queue.push_back(root_.get());

while (!queue.empty()) {

#include <Swift/Controllers/UIInterfaces/MainWindow.h>

#include <Swift/Controllers/UIInterfaces/MainWindowFactory.h>

#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h>

namespace Swift {

/**

* The controller does not gain ownership of these parameters.

*/

RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager)

: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), vcardManager_(vcardManager), avatarManager_(avatarManager), nickManager_(nickManager), nickResolver_(nickResolver), presenceOracle_(presenceOracle), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), clientBlockListManager_(clientBlockListManager) {

iqRouter_ = iqRouter;

subscriptionManager_ = subscriptionManager;

eventController_ = eventController;

settings_ = settings;

expandiness_ = new RosterGroupExpandinessPersister(roster_, settings);

mainWindow_->setRosterModel(roster_);

rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithoutResource);

changeStatusConnection_ = mainWindow_->onChangeStatusRequest.connect(boost::bind(&RosterController::handleChangeStatusRequest, this, _1, _2));

signOutConnection_ = mainWindow_->onSignOutRequest.connect(boost::bind(boost::ref(onSignOutRequest)));

xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));

xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));

xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));

xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));

subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));

uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));

vcardManager_->onOwnVCardChanged.connect(boost::bind(&RosterController::handleOwnVCardChanged, this, _1));

avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));

presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handlePresenceChanged, this, _1));

mainWindow_->setMyAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

nickManager_->onOwnNickChanged.connect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

mainWindow_->setMyJID(jid);

mainWindow_->setMyNick(nickManager_->getOwnNick());

entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

settings_->onSettingChanged.connect(boost::bind(&RosterController::handleSettingChanged, this, _1));

handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));

ownContact_ = std::make_shared<ContactRosterItem>(myJID_.toBare(), myJID_.toBare(), nickManager_->getOwnNick(), static_cast<GroupRosterItem*>(nullptr));

ownContact_->setVCard(vcardManager_->getVCard(myJID_.toBare()));

ownContact_->setAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

mainWindow_->setMyContactRosterItem(ownContact_);

}

RosterController::~RosterController() {

settings_->onSettingChanged.disconnect(boost::bind(&RosterController::handleSettingChanged, this, _1));

nickManager_->onOwnNickChanged.disconnect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

delete offlineFilter_;

delete expandiness_;

using namespace Swift;

class DummyCapsProvider : public CapsProvider {

DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

};

class RosterControllerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(RosterControllerTest);

CPPUNIT_TEST(testAdd);

CPPUNIT_TEST(testAddSubscription);

CPPUNIT_TEST(testReceiveRename);

CPPUNIT_TEST(testReceiveRegroup);

CPPUNIT_TEST(testSendRename);

CPPUNIT_TEST(testPresence);

CPPUNIT_TEST(testHighestPresence);

CPPUNIT_TEST(testNotHighestPresence);

CPPUNIT_TEST(testUnavailablePresence);

CPPUNIT_TEST(testRemoveResultsInUnavailablePresence);

CPPUNIT_TEST(testOwnContactInRosterPresence);

CPPUNIT_TEST(testMultiResourceFileTransferFeature);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid_ = JID("testjid@swift.im/swift");

xmppRoster_ = new XMPPRosterImpl();

avatarManager_ = new NullAvatarManager();

mainWindowFactory_ = new MockMainWindowFactory();

mucRegistry_ = new MUCRegistry();

crypto_ = PlatformCryptoProvider::create();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, nullptr, mucRegistry_);

channel_ = new DummyIQChannel();

router_ = new IQRouter(channel_);

stanzaChannel_ = new DummyStanzaChannel();

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

subscriptionManager_ = new SubscriptionManager(stanzaChannel_);

eventController_ = new EventController();

uiEventStream_ = new UIEventStream();

settings_ = new DummySettingsProvider();

nickManager_ = new DummyNickManager();

entityCapsManager_ = new EntityCapsManager(capsManager_.get(), stanzaChannel_);

jingleSessionManager_ = new JingleSessionManager(router_);

clientBlockListManager_ = new ClientBlockListManager(router_);

vcardStorage_ = new VCardMemoryStorage(crypto_);

vcardManager_ = new VCardManager(jid_, router_, vcardStorage_);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, clientBlockListManager_, vcardManager_);

mainWindow_ = mainWindowFactory_->last;

}

void tearDown() {

delete rosterController_;

delete vcardManager_;

delete vcardStorage_;

delete crypto_;

delete clientBlockListManager_;

delete jingleSessionManager_;

delete entityCapsManager_;

delete nickManager_;

delete nickResolver_;

delete mucRegistry_;

delete mainWindowFactory_;

delete avatarManager_;

delete router_;

delete channel_;

delete eventController_;

delete subscriptionManager_;

delete presenceOracle_;

delete stanzaChannel_;

delete uiEventStream_;

delete settings_;

delete xmppRoster_;

}

GroupRosterItem* groupChild(size_t i) {

return dynamic_cast<GroupRosterItem*>(getUIRosterChildren()[i]);

}

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

#include <Swift/Controllers/Roster/Roster.h>

using namespace Swift;

class RosterTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(RosterTest);

CPPUNIT_TEST(testGetGroup);

CPPUNIT_TEST(testRemoveContact);

CPPUNIT_TEST(testRemoveSecondContact);

CPPUNIT_TEST(testRemoveSecondContactSameBare);

CPPUNIT_TEST(testApplyPresenceLikeMUC);

CPPUNIT_TEST(testReSortLikeMUC);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1_ = JID("a@b.c");

jid2_ = JID("b@c.d");

jid3_ = JID("c@d.e");

}

void testGetGroup() {

roster_->addContact(jid1_, JID(), "Bert", "group1", "");

roster_->addContact(jid2_, JID(), "Ernie", "group2", "");

roster_->addContact(jid3_, JID(), "Cookie", "group1", "");

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(roster_->getRoot()->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("group1"), roster_->getRoot()->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("group2"), roster_->getRoot()->getChildren()[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Ernie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[1])->getChildren()[0]->getDisplayName());

}

void testRemoveContact() {

roster_->addContact(jid1_, jid1_, "Bert", "group1", "");

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

roster_->removeContact(jid1_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren().size()));

}

void testRemoveSecondContact() {

roster_->addContact(jid1_, jid1_, "Bert", "group1", "");

roster_->addContact(jid2_, jid2_, "Cookie", "group1", "");

CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

roster_->removeContact(jid2_);

#include <Swift/Controllers/Roster/TableRoster.h>

std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i);

std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i) {

os << "(" << i.section << ", " << i.row << ")";

return os;

}

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/variant.hpp>

#include <Swiften/Network/DummyTimerFactory.h>

#include <Swift/Controllers/Roster/Roster.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

using namespace Swift;

class TableRosterTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(TableRosterTest);

CPPUNIT_TEST(testAddContact_EmptyRoster);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1 = JID("jid1@example.com");

jid2 = JID("jid2@example.com");

}

void testAddContact_EmptyRoster() {

/*

std::shared_ptr<TableRoster> tableRoster(createTestling());

addContact(jid1, "1", "group1");

CPPUNIT_ASSERT_EQUAL(4, static_cast<int>(events.size()));

CPPUNIT_ASSERT(boost::get<BeginUpdatesEvent>(&events[0]));

CPPUNIT_ASSERT(boost::get<SectionsInsertedEvent>(&events[1]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections[0]));

CPPUNIT_ASSERT(boost::get<RowsInsertedEvent>(&events[2]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<RowsInsertedEvent>(events[2]).rows.size()));

CPPUNIT_ASSERT_EQUAL(TableRoster::Index(0, 0), boost::get<RowsInsertedEvent>(events[2]).rows[0]);

CPPUNIT_ASSERT(boost::get<EndUpdatesEvent>(&events[3]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfSections()));

CPPUNIT_ASSERT_EQUAL(std::string("group1"), tableRoster->getSectionTitle(0));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfRowsInSection(0)));

CPPUNIT_ASSERT_EQUAL(jid1, tableRoster->getItem(TableRoster::Index(0, 0)).jid);

*/

}

private:

void addContact(const JID& jid, const std::string& name, const std::string& group) {

roster->addContact(jid, JID(), name, group, "");