std::string nick = nickResolver_->jidToNick(toJID_);

chatWindow_->setName(nick);

std::string startMessage;

Presence::ref theirPresence;

if (isInMUC) {

startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());

theirPresence = presenceOracle->getLastPresence(contact);

} else {

startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());

}

Idle::ref idle;

if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {

startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));

}

startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);

if (theirPresence && !theirPresence->getStatus().empty()) {

startMessage += " (" + theirPresence->getStatus() + ")";

}

}

void ChatController::setToJID(const JID& jid) {

chatStateNotifier_->setContact(jid);

ChatControllerBase::setToJID(jid);

Presence::ref presence;

if (isInMUC_) {

presence = presenceOracle_->getLastPresence(jid);

} else {

}

chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

handleBareJIDCapsChanged(toJID_);

}

void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

ChatControllerBase::setAvailableServerFeatures(info);

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

}

if (!presence->getStatus().empty()) {

response += " (" + presence->getStatus() + ")";

}

return response + ".";

}

void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

}

return;

}

if (!newPresence) {

newPresence = boost::make_shared<Presence>();

newPresence->setType(Presence::Unavailable);

}

lastShownStatus_ = newPresence->getShow();

chatStateTracker_->handlePresenceChange(newPresence);

chatStateNotifier_->setContactIsOnline(newPresence->getType() == Presence::Available);

std::string newStatusChangeString = getStatusChangeString(newPresence);

ChatListWindow::Chat fixedChat = chat;

if (fixedChat.isMUC) {

if (mucControllers_.find(fixedChat.jid.toBare()) != mucControllers_.end()) {

fixedChat.statusType = StatusShow::Online;

}

} else {

if (avatarManager_) {

fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);

}

fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

}

return fixedChat;

}

void ChatsManager::loadRecents() {

std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));

if (recentsString.find("\t") != std::string::npos) {

// old format

}

}

return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

}

}

void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {

const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;

ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

VCard::ref vcard = vcardManager_->getVCard(jid);

if (vcard && !vcard->getFullName().empty()) {

contact->name = vcard->getFullName();

} else {

contact->name = jid.toString();

}

}

// presence lookup

if (presence) {

contact->statusType = presence->getShow();

} else {

contact->statusType = StatusShow::None;

}

// avatar lookup

contact->avatarPath = avatarManager_->getAvatarPath(jid);

return contact;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

namespace Swift {

ContactsFromXMPPRoster::ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : roster_(roster), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

}

ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {

}

std::vector<Contact::ref> ContactsFromXMPPRoster::getContacts(bool /*withMUCNicks*/) {

std::vector<Contact::ref> results;

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

foreach(const XMPPRosterItem& rosterItem, rosterItems) {

Contact::ref contact = boost::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);

results.push_back(contact);

}

return results;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

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

#include <Swiften/Base/DateTime.h>

#include <Swiften/Elements/Idle.h>

#include <Swift/Controllers/Intl.h>

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

namespace Swift {

ContactRosterItem::ContactRosterItem(const JID& jid, const JID& displayJID, const std::string& name, GroupRosterItem* parent)

: RosterItem(name, parent), jid_(jid), displayJID_(displayJID.toBare()), mucRole_(MUCOccupant::NoRole), mucAffiliation_(MUCOccupant::NoAffiliation), blockState_(BlockingNotSupported)

{

}

ContactRosterItem::~ContactRosterItem() {

}

StatusShow::Type ContactRosterItem::getStatusShow() const {

}

StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const {

case StatusShow::Online: return StatusShow::Online;

case StatusShow::Away: return StatusShow::Away;

case StatusShow::XA: return StatusShow::Away;

case StatusShow::FFC: return StatusShow::Online;

case StatusShow::DND: return StatusShow::DND;

case StatusShow::None: return StatusShow::None;

}

assert(false);

return StatusShow::None;

}

std::string ContactRosterItem::getStatusText() const {

}

std::string ContactRosterItem::getIdleText() const {

if (!idle || idle->getSince().is_not_a_date_time()) {

return "";

} else {

return dateTimeToLocalString(idle->getSince());

}

}

std::string ContactRosterItem::getOfflineSinceText() const {

return dateTimeToLocalString(*delay);

}

}

return "";

}

void ContactRosterItem::setAvatarPath(const boost::filesystem::path& path) {

avatarPath_ = path;

onDataChanged();

}

const JID& ContactRosterItem::getDisplayJID() const {

return displayJID_;

}

typedef std::pair<std::string, boost::shared_ptr<Presence> > StringPresencePair;

void ContactRosterItem::clearPresence() {

onDataChanged();

}

void ContactRosterItem::applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence) {

onDataChanged();

}

const std::vector<std::string>& ContactRosterItem::getGroups() const {

return groups_;

}

/** Only used so a contact can know about the groups it's in*/

void ContactRosterItem::addGroup(const std::string& group) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <set>

#include <string>

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/ptime.hpp>

#include <boost/filesystem/path.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

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

namespace Swift {

class GroupRosterItem;

class ContactRosterItem : public RosterItem {

std::string getStatusText() const;

std::string getIdleText() const;

std::string getOfflineSinceText() const;

void setAvatarPath(const boost::filesystem::path& path);

const boost::filesystem::path& getAvatarPath() const;

const JID& getJID() const;

void setDisplayJID(const JID& jid);

const JID& getDisplayJID() const;

void applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence);

const std::vector<std::string>& getGroups() const;

/** Only used so a contact can know about the groups it's in*/

void addGroup(const std::string& group);

void removeGroup(const std::string& group);

MUCOccupant::Role getMUCRole() const;

void setMUCRole(const MUCOccupant::Role& role);

MUCOccupant::Affiliation getMUCAffiliation() const;

void setMUCAffiliation(const MUCOccupant::Affiliation& affiliation);

std::string getMUCAffiliationText() const;

void setSupportedFeatures(const std::set<Feature>& features);

bool supportsFeature(Feature feature) const;

void setVCard(VCard::ref vcard);

boost::signal<void ()> onVCardRequested;

private:

JID jid_;

JID displayJID_;

boost::posix_time::ptime lastAvailableTime_;

boost::filesystem::path avatarPath_;

std::vector<std::string> groups_;

MUCOccupant::Role mucRole_;

MUCOccupant::Affiliation mucAffiliation_;

std::set<Feature> features_;

BlockState blockState_;

VCard::ref vcard_;

};

}

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);

}

boost::shared_ptr<ErrorEvent> errorEvent(new ErrorEvent(JID(myJID_.getDomain()), text));

eventController_->handleIncomingEvent(errorEvent);

}

void RosterController::handleIncomingPresence(Presence::ref newPresence) {

if (newPresence->getType() == Presence::Error) {

return;

}

}

void RosterController::handleSubscriptionRequest(const JID& jid, const std::string& message) {

if (xmppRoster_->containsJID(jid) && (xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::To || xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::Both)) {

subscriptionManager_->confirmSubscription(jid);

return;

}

SubscriptionRequestEvent* eventPointer = new SubscriptionRequestEvent(jid, message);

eventPointer->onAccept.connect(boost::bind(&RosterController::handleSubscriptionRequestAccepted, this, eventPointer));

mainWindow_->setMyContactRosterItem(ownContact_);

}

}

void RosterController::handlePresenceChanged(Presence::ref presence) {

if (presence->getFrom().equals(myJID_, JID::WithResource)) {

ownContact_->applyPresence(std::string(), presence);

mainWindow_->setMyContactRosterItem(ownContact_);

}

}

boost::optional<XMPPRosterItem> RosterController::getItem(const JID& jid) const {

return xmppRoster_->getItem(jid);

}

std::set<std::string> RosterController::getGroups() const {

return xmppRoster_->getGroups();

}

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(highPresence->getStatus(), item->getStatusText());

}

void testUnavailablePresence() {

std::vector<std::string> groups;

groups.push_back("testGroup1");

JID from("test@testdomain.com");

xmppRoster_->addContact(from, "name", groups, RosterItemPayload::Both);

Presence::ref lowPresence(new Presence());

lowPresence->setFrom(withResource(from, "bob"));

lowPresence->setPriority(2);

lowPresence->setStatus("Not here");

Presence::ref highPresence(new Presence());

highPresence->setFrom(withResource(from, "bert"));

highPresence->setPriority(10);

highPresence->setStatus("So totally here");

Presence::ref highPresenceOffline(new Presence());

highPresenceOffline->setFrom(withResource(from, "bert"));

highPresenceOffline->setType(Presence::Unavailable);

stanzaChannel_->onPresenceReceived(lowPresence);

stanzaChannel_->onPresenceReceived(highPresence);

stanzaChannel_->onPresenceReceived(highPresenceOffline);

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(lowPresence->getStatus(), item->getStatusText());

stanzaChannel_->onPresenceReceived(lowPresenceOffline);

item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

/* A verification that if the test fails, it's the RosterController, not the PresenceOracle. */

CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());

}

void testAdd() {

std::vector<std::string> groups;

groups.push_back("testGroup1");

groups.push_back("testGroup2");

xmppRoster_->addContact(JID("test@testdomain.com/bob"), "name", groups, RosterItemPayload::Both);