+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h>

+#include <Swiften/Base/Log.h>

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts) {

+ eventStream_->onUIEvent.connect(boost::bind(&ChatController::handleUIEvent, this, _1));

+ eventStream_->onUIEvent.disconnect(boost::bind(&ChatController::handleUIEvent, this, _1));

+ if (disco->hasFeature(DiscoInfo::MessageDeliveryReceiptsFeature)) {

+ contactSupportsReceipts_ = ChatWindow::Yes;

+ } else {

+ contactSupportsReceipts_ = ChatWindow::No;

+ }

+ SWIFT_LOG(debug) << "No disco info :(" << std::endl;

+ contactSupportsReceipts_ = ChatWindow::Maybe;

+ checkForDisplayingDisplayReceiptsAlert();

+

+ if (boost::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

+ SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID() << std::endl;

+ if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

+ chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

+ requestedReceipts_.erase(receipt->getReceivedID());

+ }

+ } else if (message->getPayload<DeliveryReceiptRequest>()) {

+ if (receivingPresenceFromUs_) {

+ boost::shared_ptr<Message> receiptMessage = boost::make_shared<Message>();

+ receiptMessage->setTo(toJID_);

+ receiptMessage->addPayload(boost::make_shared<DeliveryReceipt>(message->getID()));

+ stanzaChannel_->sendMessage(receiptMessage);

+ }

+ }

+ if (userWantsReceipts_ && (contactSupportsReceipts_ != ChatWindow::No) && message) {

+ message->addPayload(boost::make_shared<DeliveryReceiptRequest>());

+ }

+}

+

+void ChatController::setContactIsReceivingPresence(bool isReceivingPresence) {

+ receivingPresenceFromUs_ = isReceivingPresence;

+}

+

+void ChatController::handleUIEvent(boost::shared_ptr<UIEvent> event) {

+ if (boost::shared_ptr<ToggleRequestDeliveryReceiptsUIEvent> toggleAllowReceipts = boost::dynamic_pointer_cast<ToggleRequestDeliveryReceiptsUIEvent>(event)) {

+ userWantsReceipts_ = toggleAllowReceipts->getEnabled();

+ checkForDisplayingDisplayReceiptsAlert();

+ }

+}

+

+void ChatController::checkForDisplayingDisplayReceiptsAlert() {

+ if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::No)) {

+ chatWindow_->setAlert("This chat doesn't support delivery receipts.");

+ } else if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::Maybe)) {

+ chatWindow_->setAlert("This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent.");

+ } else {

+ chatWindow_->cancelAlert();

+ }

+

+

+ if (sentStanza->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[sentStanza->getID()] = myLastMessageUIID_;

+ chatWindow_->setMessageReceiptState(myLastMessageUIID_, ChatWindow::ReceiptRequested);

+ }

+

+#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

+

+ class UIEvent;

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts);

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/);

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+ void checkForDisplayingDisplayReceiptsAlert();

+

+ std::map<std::string, std::string> requestedReceipts_;

+ ChatWindow::Tristate contactSupportsReceipts_;

+ bool receivingPresenceFromUs_;

+ bool userWantsReceipts_;

+

+ virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

+#include <Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h>

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swiften/Roster/XMPPRoster.h>

+ XMPPRoster* roster,

+ roster_(roster),

+ roster_->onJIDAdded.connect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

+ roster_->onJIDRemoved.connect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

+ roster_->onJIDUpdated.connect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

+ roster_->onRosterCleared.connect(boost::bind(&ChatsManager::handleRosterCleared, this));

+ roster_->onJIDAdded.disconnect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

+ roster_->onJIDRemoved.disconnect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

+ roster_->onJIDUpdated.disconnect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

+ roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));

+void ChatsManager::handleJIDAddedToRoster(const JID &jid) {

+ updatePresenceReceivingStateOnChatController(jid);

+}

+

+void ChatsManager::handleJIDRemovedFromRoster(const JID &jid) {

+ updatePresenceReceivingStateOnChatController(jid);

+}

+

+void ChatsManager::handleJIDUpdatedInRoster(const JID &jid) {

+ updatePresenceReceivingStateOnChatController(jid);

+}

+

+void ChatsManager::handleRosterCleared() {

+ /* Setting that all chat controllers aren't receiving presence anymore;

+ including MUC 1-to-1 chats due to the assumtion that this handler

+ is only called on log out. */

+ foreach(JIDChatControllerPair pair, chatControllers_) {

+ pair.second->setContactIsReceivingPresence(false);

+ }

+}

+

+void ChatsManager::updatePresenceReceivingStateOnChatController(const JID &jid) {

+ ChatController* controller = getChatControllerIfExists(jid);

+ if (controller) {

+ if (!mucRegistry_->isMUC(jid.toBare())) {

+ RosterItemPayload::Subscription subscription = roster_->getSubscriptionStateForJID(jid);

+ controller->setContactIsReceivingPresence(subscription == RosterItemPayload::From || subscription == RosterItemPayload::Both);

+ } else {

+ controller->setContactIsReceivingPresence(true);

+ }

+ }

+}

+

+ boost::shared_ptr<ToggleRequestDeliveryReceiptsUIEvent> toggleRequestDeliveryReceipsEvent = boost::dynamic_pointer_cast<ToggleRequestDeliveryReceiptsUIEvent>(event);

+ if (toggleRequestDeliveryReceipsEvent) {

+ userWantsReceipts_ = toggleRequestDeliveryReceipsEvent->getEnabled();

+ return;

+ }

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_);

+ updatePresenceReceivingStateOnChatController(contact);

+ if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !message->hasSubject()) {

+ class XMPPRoster;

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* settings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode);

+ void handleJIDAddedToRoster(const JID&);

+ void handleJIDRemovedFromRoster(const JID&);

+ void handleJIDUpdatedInRoster(const JID&);

+ void handleRosterCleared();

+

+ void updatePresenceReceivingStateOnChatController(const JID&);

+ XMPPRoster* roster_;

+ bool userWantsReceipts_;

+#include "Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h"

+#include "Swiften/Elements/DeliveryReceiptRequest.h"

+#include "Swiften/Elements/DeliveryReceipt.h"

+ CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

+ CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

+ CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

+ CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

+

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false);

+

+ /**

+ * Test that ChatController doesn't send receipts anymore after removal of the contact from the roster.

+ */

+ void testChatControllerPresenceAccessUpdatedOnRemoveFromRoster() {

+ JID messageJID("testling@test.com/resource1");

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), RosterItemPayload::Both);

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT_EQUAL((size_t)1, stanzaChannel_->sentStanzas.size());

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+

+ xmppRoster_->removeContact(messageJID);

+

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+ CPPUNIT_ASSERT_EQUAL((size_t)1, stanzaChannel_->sentStanzas.size());

+ }

+

+ /**

+ * Test that ChatController sends receipts after the contact has been added to the roster.

+ */

+ void testChatControllerPresenceAccessUpdatedOnAddToRoster() {

+ JID messageJID("testling@test.com/resource1");

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL((size_t)0, stanzaChannel_->sentStanzas.size());

+

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), RosterItemPayload::Both);

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL((size_t)1, stanzaChannel_->sentStanzas.size());

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+ }

+

+ /**

+ * Test that ChatController sends receipts if requested after change from subscription state To to subscription state Both.

+ */

+ void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth() {

+ testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::Both);

+ }

+

+ /**

+ * Test that ChatController sends receipts if requested after change from subscription state To to subscription state From.

+ */

+ void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom() {

+ testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::From);

+ }

+

+ void testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::Subscription from, RosterItemPayload::Subscription to) {

+ JID messageJID("testling@test.com/resource1");

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), from);

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL((size_t)0, stanzaChannel_->sentStanzas.size());

+

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL((size_t)1, stanzaChannel_->sentStanzas.size());

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+ }

+

+private:

+ boost::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

+ boost::shared_ptr<Message> message = boost::make_shared<Message>();

+ message->setFrom(from);

+ message->setID(id);

+ message->addPayload(boost::make_shared<DeliveryReceiptRequest>());

+ return message;

+ }

+

+ DummyStanzaChannel* stanzaChannel_;

+#include "Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h"

+static const std::string REQUEST_DELIVERYRECEIPTS = "requestDeliveryReceipts";

+ boost::shared_ptr<ToggleRequestDeliveryReceiptsUIEvent> deliveryReceiptEvent = boost::dynamic_pointer_cast<ToggleRequestDeliveryReceiptsUIEvent>(event);

+ if (deliveryReceiptEvent) {

+ settings_->storeBool(REQUEST_DELIVERYRECEIPTS, deliveryReceiptEvent->getEnabled());

+ }

+

+ 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(), eagleMode_);

+ discoInfo.addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

+

+ // notify world about current delivey receipt request setting state.

+ uiEventStream_->send(boost::make_shared<ToggleRequestDeliveryReceiptsUIEvent>(settings_->getBoolSetting(REQUEST_DELIVERYRECEIPTS, false)));

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include "Swift/Controllers/UIEvents/UIEvent.h"

+

+namespace Swift {

+ class ToggleRequestDeliveryReceiptsUIEvent : public UIEvent {

+ public:

+ ToggleRequestDeliveryReceiptsUIEvent(bool enable) : enabled_(enable) {}

+ bool getEnabled() {return enabled_;}

+ private:

+ bool enabled_;

+ };

+}

+ enum ReceiptState {ReceiptRequested, ReceiptReceived};

+ // message receipts

+ virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) = 0;

+

+ virtual void setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }

+

+ content_.replace("%message%", "<span class='swift_message'>" + escape(message) + "</span><span class='swift_ack'></span><span class='swift_receipt'></span>");

+void QtChatView::setReceiptXML(const QString& id, const QString& xml) {

+ QWebElement message = document_.findFirst("#" + id);

+ if (message.isNull()) return;

+ QWebElement receiptElement = message.findFirst("span.swift_receipt");

+ assert(!receiptElement.isNull());

+ receiptElement.setInnerXml(xml);

+}

+

+void QtChatView::displayReceiptInfo(const QString& id, bool showIt) {

+ QWebElement message = document_.findFirst("#" + id);

+ if (message.isNull()) return;

+ QWebElement receiptElement = message.findFirst("span.swift_receipt");

+ assert(!receiptElement.isNull());

+ receiptElement.setStyleProperty("display", showIt ? "inline" : "none");

+}

+

+ void setReceiptXML(const QString& id, const QString& xml);

+ void displayReceiptInfo(const QString& id, bool showIt);

+

+ case ChatWindow::Pending:

+ xml = "<img src='qrc:/icons/throbber.gif' alt='" + tr("This message has not been received by your server yet.") + "'/>";

+ messageLog_->displayReceiptInfo(P2QSTRING(id), false);

+ break;

+ case ChatWindow::Received:

+ xml = "";

+ messageLog_->displayReceiptInfo(P2QSTRING(id), true);

+ break;

+void QtChatWindow::setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) {

+ QString xml;

+ switch (state) {

+ case ChatWindow::ReceiptReceived:

+ xml = "<img src='qrc:/icons/check.png' alt'" + tr("The receipt for this message has been received.") + "'/>";

+ break;

+ case ChatWindow::ReceiptRequested:

+ xml = "<img src='qrc:/icons/warn.png' alt='" + tr("The receipt for this message has not yet been received. The receipient(s) might not have received this message.") + "'/>";

+ break;

+ }

+ messageLog_->setReceiptXML(P2QSTRING(id), xml);

+}

+

+

+ // message receipts

+ void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state);

+

+QtLoginWindow::QtMenus QtLoginWindow::getMenus() const {

+ return QtMenus(swiftMenu_, generalMenu_);

+}

+

+ struct QtMenus {

+ QtMenus(QMenu* swiftMenu, QMenu* generalMenu) : swiftMenu(swiftMenu), generalMenu(generalMenu) {}

+ QMenu* swiftMenu;

+ QMenu* generalMenu;

+ };

+

+ public:

+ QtMenus getMenus() const;

+#include <Swift/QtUI/QtLoginWindow.h>

+#include <Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h>

+QtMainWindow::QtMainWindow(QtSettingsProvider* settings, UIEventStream* uiEventStream, QtUIPreferences* uiPreferences, QtLoginWindow::QtMenus loginMenus) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {

+ toggleRequestDeliveryReceipts_ = new QAction(tr("&Request Delivery Receipts"), this);

+ toggleRequestDeliveryReceipts_->setCheckable(true);

+ toggleRequestDeliveryReceipts_->setChecked(false);

+ connect(toggleRequestDeliveryReceipts_, SIGNAL(toggled(bool)), SLOT(handleToggleRequestDeliveryReceipts(bool)));

+ loginMenus_.generalMenu->addAction(toggleRequestDeliveryReceipts_);

+

+void QtMainWindow::handleToggleRequestDeliveryReceipts(bool enabled) {

+ uiEventStream_->send(boost::make_shared<ToggleRequestDeliveryReceiptsUIEvent>(enabled));

+}

+

+ loginMenus_.generalMenu->removeAction(toggleRequestDeliveryReceipts_);

+ boost::shared_ptr<ToggleRequestDeliveryReceiptsUIEvent> deliveryReceiptEvent = boost::dynamic_pointer_cast<ToggleRequestDeliveryReceiptsUIEvent>(event);

+ if (deliveryReceiptEvent) {

+ toggleRequestDeliveryReceipts_->setChecked(deliveryReceiptEvent->getEnabled());

+ }

+#include "Swift/QtUI/QtLoginWindow.h"

+ QtMainWindow(QtSettingsProvider*, UIEventStream* eventStream, QtUIPreferences* uiPreferences, QtLoginWindow::QtMenus loginMenus);

+ void handleToggleRequestDeliveryReceipts(bool enabled);

+ QtLoginWindow::QtMenus loginMenus_;

+ QAction* toggleRequestDeliveryReceipts_;

+ lastMainWindow = new QtMainWindow(settings, eventStream, uiPreferences, loginWindow->getMenus());

+ <file alias="icons/warn.png">../resources/icons/warn.png</file>

+ <file alias="icons/check.png">../resources/icons/check.png</file>

+Resources:

+

+Filename Source License

+warn.png Swift/resources/themes/Default/images/warn.png BSD

+check.png http://en.wikipedia.org/wiki/File:Green_check.svg Public Domain \ No newline at end of file

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Elements/Payload.h>

+

+namespace Swift {

+

+class DeliveryReceipt : public Payload {

+ public:

+ typedef boost::shared_ptr<DeliveryReceipt> ref;

+

+ public:

+ DeliveryReceipt() {}

+

+ DeliveryReceipt(const std::string& msgId) : receivedID_(msgId) {}

+

+ void setReceivedID(const std::string& msgId) {

+ receivedID_ = msgId;

+ }

+

+ std::string getReceivedID() const {

+ return receivedID_;

+ }

+

+ private:

+ std::string receivedID_;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Elements/Payload.h>

+

+namespace Swift {

+

+class DeliveryReceiptRequest : public Payload {

+ public:

+ typedef boost::shared_ptr<DeliveryReceiptRequest> ref;

+

+ public:

+ DeliveryReceiptRequest() {}

+};

+

+}

+const std::string DiscoInfo::MessageDeliveryReceiptsFeature = std::string("urn:xmpp:receipts");

+ static const std::string MessageDeliveryReceiptsFeature;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptParser.h>

+

+#include <boost/optional.hpp>

+

+namespace Swift {

+

+DeliveryReceiptParser::DeliveryReceiptParser() : level_(0) {

+}

+

+void DeliveryReceiptParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributeMap) {

+ if (level_ == 0) {

+ if (element == "received") {

+ if (attributeMap.getAttributeValue("id").is_initialized()) {

+ getPayloadInternal()->setReceivedID(attributeMap.getAttributeValue("id").get());

+ }

+ }

+ }

+ ++level_;

+}

+

+void DeliveryReceiptParser::handleEndElement(const std::string&, const std::string&) {

+ --level_;

+}

+

+void DeliveryReceiptParser::handleCharacterData(const std::string&) {

+

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Parser/GenericPayloadParser.h>

+

+namespace Swift {

+ class DeliveryReceiptParser : public GenericPayloadParser<DeliveryReceipt> {

+ public:

+ DeliveryReceiptParser();

+

+ virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributeMap);

+ virtual void handleEndElement(const std::string& element, const std::string&);

+ virtual void handleCharacterData(const std::string& data);

+

+ private:

+ int level_;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Parser/PayloadParserFactory.h>

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptParser.h>

+

+namespace Swift {

+ class PayloadParserFactoryCollection;

+

+ class DeliveryReceiptParserFactory : public PayloadParserFactory {

+ public:

+ DeliveryReceiptParserFactory() {

+ }

+

+ virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

+ return ns == "urn:xmpp:receipts" && element == "received";

+ }

+

+ virtual PayloadParser* createPayloadParser() {

+ return new DeliveryReceiptParser();

+ }

+

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptRequestParser.h>

+

+#include <boost/optional.hpp>

+

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+DeliveryReceiptRequestParser::DeliveryReceiptRequestParser() {

+}

+

+void DeliveryReceiptRequestParser::handleStartElement(const std::string&, const std::string&, const AttributeMap&) {

+

+}

+

+void DeliveryReceiptRequestParser::handleEndElement(const std::string&, const std::string&) {

+

+}

+

+void DeliveryReceiptRequestParser::handleCharacterData(const std::string&) {

+

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swiften/Parser/GenericPayloadParser.h>

+

+namespace Swift {

+ class DeliveryReceiptRequestParser : public GenericPayloadParser<DeliveryReceiptRequest> {

+ public:

+ DeliveryReceiptRequestParser();

+

+ virtual void handleStartElement(const std::string&, const std::string&, const AttributeMap&);

+ virtual void handleEndElement(const std::string&, const std::string&);

+ virtual void handleCharacterData(const std::string& data);

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Parser/PayloadParserFactory.h>

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptRequestParser.h>

+

+namespace Swift {

+ class PayloadParserFactoryCollection;

+

+ class DeliveryReceiptRequestParserFactory : public PayloadParserFactory {

+ public:

+ DeliveryReceiptRequestParserFactory() {

+ }

+

+ virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

+ return ns == "urn:xmpp:receipts" && element == "request";

+ }

+

+ virtual PayloadParser* createPayloadParser() {

+ return new DeliveryReceiptRequestParser();

+ }

+

+ };

+}

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptParserFactory.h>

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptRequestParserFactory.h>

+ factories_.push_back(boost::make_shared<DeliveryReceiptParserFactory>());

+ factories_.push_back(boost::make_shared<DeliveryReceiptRequestParserFactory>());

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Elements/Message.h>

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptParser.h>

+#include <Swiften/Parser/PayloadParsers/DeliveryReceiptRequestParser.h>

+#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>

+

+using namespace Swift;

+

+class DeliveryReceiptParserTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(DeliveryReceiptParserTest);

+ CPPUNIT_TEST(testParseXEP0184Example3);

+ CPPUNIT_TEST(testParseXEP0184Example4);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testParseXEP0184Example3() {

+ PayloadsParserTester parser;

+ CPPUNIT_ASSERT(parser.parse("<request xmlns='urn:xmpp:receipts'/>"));

+

+ DeliveryReceiptRequest::ref request = boost::dynamic_pointer_cast<DeliveryReceiptRequest>(parser.getPayload());

+

+ CPPUNIT_ASSERT(request);

+ }

+

+ void testParseXEP0184Example4() {

+ PayloadsParserTester parser;

+ CPPUNIT_ASSERT(parser.parse("<received xmlns='urn:xmpp:receipts' id='richard2-4.1.247'/>"));

+

+ DeliveryReceipt::ref receipt = boost::dynamic_pointer_cast<DeliveryReceipt>(parser.getPayload());

+

+ CPPUNIT_ASSERT_EQUAL(std::string("richard2-4.1.247"), receipt->getReceivedID());

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(DeliveryReceiptParserTest);

+

+ "PayloadParsers/DeliveryReceiptParser.cpp",

+ "PayloadParsers/DeliveryReceiptRequestParser.cpp",

+ "Serializer/PayloadSerializers/DeliveryReceiptSerializer.cpp",

+ "Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.cpp",

+ File("Parser/PayloadParsers/UnitTest/DeliveryReceiptParserTest.cpp"),

+ File("Serializer/PayloadSerializers/UnitTest/DeliveryReceiptSerializerTest.cpp"),

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.h>

+#include <Swiften/Serializer/XML/XMLElement.h>

+

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+DeliveryReceiptRequestSerializer::DeliveryReceiptRequestSerializer() : GenericPayloadSerializer<DeliveryReceiptRequest>() {

+}

+

+std::string DeliveryReceiptRequestSerializer::serializePayload(boost::shared_ptr<DeliveryReceiptRequest> /* request*/) const {

+ XMLElement requestXML("request", "urn:xmpp:receipts");

+ return requestXML.serialize();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+

+namespace Swift {

+ class DeliveryReceiptRequestSerializer : public GenericPayloadSerializer<DeliveryReceiptRequest> {

+ public:

+ DeliveryReceiptRequestSerializer();

+

+ virtual std::string serializePayload(boost::shared_ptr<DeliveryReceiptRequest> request) const;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptSerializer.h>

+#include <Swiften/Serializer/XML/XMLElement.h>

+

+namespace Swift {

+

+DeliveryReceiptSerializer::DeliveryReceiptSerializer() : GenericPayloadSerializer<DeliveryReceipt>() {

+}

+

+std::string DeliveryReceiptSerializer::serializePayload(boost::shared_ptr<DeliveryReceipt> receipt) const {

+ XMLElement received("received", "urn:xmpp:receipts");

+ received.setAttribute("id", receipt->getReceivedID());

+ return received.serialize();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the BSD license.

+ * See http://www.opensource.org/licenses/bsd-license.php for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+#include <Swiften/Elements/DeliveryReceipt.h>

+

+namespace Swift {

+ class DeliveryReceiptSerializer : public GenericPayloadSerializer<DeliveryReceipt> {

+ public:

+ DeliveryReceiptSerializer();

+

+ virtual std::string serializePayload(boost::shared_ptr<DeliveryReceipt> receipt) const;

+ };

+}

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptSerializer.h>

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.h>

+ serializers_.push_back(new DeliveryReceiptSerializer());

+ serializers_.push_back(new DeliveryReceiptRequestSerializer());

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <boost/shared_ptr.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptSerializer.h>

+#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.h>

+

+using namespace Swift;

+

+class DeliveryReceiptSerializerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(DeliveryReceiptSerializerTest);

+ CPPUNIT_TEST(testSerialize_XEP0184Example3);

+ CPPUNIT_TEST(testSerialize_XEP0184Example4);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testSerialize_XEP0184Example3() {

+ std::string expected = "<request xmlns=\"urn:xmpp:receipts\"/>";

+

+ DeliveryReceiptRequest::ref receipt = boost::make_shared<DeliveryReceiptRequest>();

+

+ boost::shared_ptr<DeliveryReceiptRequestSerializer> serializer = boost::make_shared<DeliveryReceiptRequestSerializer>();

+ CPPUNIT_ASSERT_EQUAL(expected, serializer->serializePayload(receipt));

+ }

+

+ void testSerialize_XEP0184Example4() {

+ std::string expected = "<received id=\"richard2-4.1.247\" xmlns=\"urn:xmpp:receipts\"/>";

+

+ DeliveryReceipt::ref receipt = boost::make_shared<DeliveryReceipt>("richard2-4.1.247");

+

+ boost::shared_ptr<DeliveryReceiptSerializer> serializer = boost::make_shared<DeliveryReceiptSerializer>();

+ CPPUNIT_ASSERT_EQUAL(expected, serializer->serializePayload(receipt));

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(DeliveryReceiptSerializerTest);

+