From 91e29f1cacf03a1448efbc72145a396c16df873d Mon Sep 17 00:00:00 2001 From: Bartek Cichocki Date: Mon, 20 Jul 2020 20:27:32 +0200 Subject: [PATCH] [EGD-3486] Implementation of SMS handling in service-desktop added message removal method added message marking as read/unread added message thread to_json() method, fixed unit test added template processing except search added SMS gathering by contactID added getByText sms query added template search query --- .vscode/settings.json | 22 +- .../models/NewEditEventModel.cpp | 2 +- .../windows/CalendarMainWindow.cpp | 2 +- module-db/CMakeLists.txt | 4 + module-db/Interface/SMSRecord.cpp | 61 +++- module-db/Interface/SMSTemplateRecord.cpp | 13 + module-db/Interface/SMSTemplateRecord.hpp | 2 + module-db/Tables/SMSTable.cpp | 53 ++++ module-db/Tables/SMSTable.hpp | 2 + .../queries/sms/QuerySMSGetByContactID.cpp | 24 ++ .../queries/sms/QuerySMSGetByContactID.hpp | 29 ++ module-db/queries/sms/QuerySMSGetByID.cpp | 24 ++ module-db/queries/sms/QuerySMSGetByID.hpp | 29 ++ module-db/queries/sms/QuerySMSGetByText.cpp | 24 ++ module-db/queries/sms/QuerySMSGetByText.hpp | 29 ++ .../queries/sms/QuerySMSTemplateGetByID.cpp | 24 ++ .../queries/sms/QuerySMSTemplateGetByID.hpp | 29 ++ .../service-db/api/DBServiceAPI.cpp | 6 +- .../service-desktop/ServiceDesktop.cpp | 10 + .../service-desktop/endpoints/CMakeLists.txt | 1 + .../service-desktop/endpoints/Contacts.cpp | 1 + .../service-desktop/endpoints/Messages.cpp | 274 ++++++++++++++++++ .../service-desktop/endpoints/Messages.hpp | 43 +++ .../parser/EndpointHandler.cpp | 151 +++++++++- .../parser/EndpointHandler.hpp | 18 +- .../service-desktop/parser/MessageHandler.cpp | 5 + .../service-desktop/parser/ParserUtils.hpp | 28 +- .../service-desktop/tests/unittest.cpp | 47 ++- 28 files changed, 938 insertions(+), 19 deletions(-) create mode 100644 module-db/queries/sms/QuerySMSGetByContactID.cpp create mode 100644 module-db/queries/sms/QuerySMSGetByContactID.hpp create mode 100644 module-db/queries/sms/QuerySMSGetByID.cpp create mode 100644 module-db/queries/sms/QuerySMSGetByID.hpp create mode 100644 module-db/queries/sms/QuerySMSGetByText.cpp create mode 100644 module-db/queries/sms/QuerySMSGetByText.hpp create mode 100644 module-db/queries/sms/QuerySMSTemplateGetByID.cpp create mode 100644 module-db/queries/sms/QuerySMSTemplateGetByID.hpp create mode 100644 module-services/service-desktop/endpoints/Messages.cpp create mode 100644 module-services/service-desktop/endpoints/Messages.hpp diff --git a/.vscode/settings.json b/.vscode/settings.json index 48d6890a5d40183ecbe686b5f55c16ff6c1caf00..82ca67cd3e95dcc91052daa1fddb84e6d5428bc8 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -55,6 +55,26 @@ "sstream": "cpp", "stdexcept": "cpp", "streambuf": "cpp", - "typeinfo": "cpp" + "typeinfo": "cpp", + "bitset": "cpp", + "chrono": "cpp", + "cinttypes": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "forward_list": "cpp", + "unordered_set": "cpp", + "ratio": "cpp", + "regex": "cpp", + "future": "cpp", + "mutex": "cpp", + "ranges": "cpp", + "shared_mutex": "cpp", + "stop_token": "cpp", + "thread": "cpp", + "typeindex": "cpp", + "valarray": "cpp", + "variant": "cpp" }, } \ No newline at end of file diff --git a/module-apps/application-calendar/models/NewEditEventModel.cpp b/module-apps/application-calendar/models/NewEditEventModel.cpp index d0c60d64952abf78e8e5f89a0bf191cfa5b2ce62..c40b5f3d61bea1072168631046cfd0f925acbcc4 100644 --- a/module-apps/application-calendar/models/NewEditEventModel.cpp +++ b/module-apps/application-calendar/models/NewEditEventModel.cpp @@ -105,7 +105,7 @@ void NewEditEventModel::loadDataWithoutTimeItem() void NewEditEventModel::reloadDataWithTimeItem() { - auto app = application; + [[maybe_unused]] auto app = application; assert(app != nullptr); internalData.clear(); diff --git a/module-apps/application-calendar/windows/CalendarMainWindow.cpp b/module-apps/application-calendar/windows/CalendarMainWindow.cpp index 916039d3aa19e28340604dd0824712187868ded6..ba77801c81404557c68b40078b2367fadefbc523 100644 --- a/module-apps/application-calendar/windows/CalendarMainWindow.cpp +++ b/module-apps/application-calendar/windows/CalendarMainWindow.cpp @@ -217,7 +217,7 @@ namespace gui AppWindow::buildInterface(); LOG_DEBUG("Start build interface for calendar main window"); - auto app = dynamic_cast(application); + [[maybe_unused]] auto app = dynamic_cast(application); assert(app != nullptr); setTitle(utils::localize.get("app_calendar_title_main")); diff --git a/module-db/CMakeLists.txt b/module-db/CMakeLists.txt index 0f24dd0f022a24238fbdda7ba461c0a5a6203a50..0665dfd1fc092d5d9cda2d05257176aeb3328d51 100644 --- a/module-db/CMakeLists.txt +++ b/module-db/CMakeLists.txt @@ -61,6 +61,10 @@ set(SOURCES queries/sms/QuerySMSThreadsGet.cpp queries/sms/QuerySMSSearchByType.cpp queries/sms/QuerySmsThreadMarkAsRead.cpp + queries/sms/QuerySMSGetByID.cpp + queries/sms/QuerySMSGetByContactID.cpp + queries/sms/QuerySMSGetByText.cpp + queries/sms/QuerySMSTemplateGetByID.cpp queries/calllog/QueryCalllogSetAllRead.cpp queries/notifications/QueryNotificationsGet.cpp queries/notifications/QueryNotificationsIncrement.cpp diff --git a/module-db/Interface/SMSRecord.cpp b/module-db/Interface/SMSRecord.cpp index d8753890bd68dbe891ed3cc7a9244653c37fa6bb..2a9d534c1ba4c57a221de6c732775baee59e5568 100644 --- a/module-db/Interface/SMSRecord.cpp +++ b/module-db/Interface/SMSRecord.cpp @@ -1,6 +1,11 @@ #include "SMSRecord.hpp" +#include "Common/Query.hpp" #include "ContactRecord.hpp" #include "ThreadRecord.hpp" +#include "queries/sms/QuerySMSGetByContactID.hpp" +#include "queries/sms/QuerySMSGetByID.hpp" +#include "queries/sms/QuerySMSGetByText.hpp" +#include "queries/sms/QuerySMSSearch.hpp" #include "queries/sms/QuerySMSSearchByType.hpp" #include @@ -288,9 +293,61 @@ SMSRecord SMSRecordInterface::GetByID(uint32_t id) std::unique_ptr SMSRecordInterface::runQuery(std::shared_ptr query) { - if (const auto local_query = dynamic_cast(query.get())) { - return runQueryImpl(local_query); + if (const auto localQuery = dynamic_cast(query.get())) { + return runQueryImpl(localQuery); } + else if (const auto localQuery = dynamic_cast(query.get())) { + auto sms = smsDB->sms.getById(localQuery->id); + SMSRecord record; + + record.body = sms.body; + record.contactID = sms.contactID; + record.date = sms.date; + record.dateSent = sms.dateSent; + record.errorCode = sms.errorCode; + record.threadID = sms.threadID; + record.type = sms.type; + record.ID = sms.ID; + + return std::make_unique(record); + } + else if (const auto localQuery = dynamic_cast(query.get())) { + auto smsVector = smsDB->sms.getByContactId(localQuery->contactId); + std::vector recordVector; + for (auto sms : smsVector) { + SMSRecord record; + record.body = sms.body; + record.contactID = sms.contactID; + record.date = sms.date; + record.dateSent = sms.dateSent; + record.errorCode = sms.errorCode; + record.threadID = sms.threadID; + record.type = sms.type; + record.ID = sms.ID; + recordVector.emplace_back(record); + } + + return std::make_unique(recordVector); + } + else if (const auto localQuery = dynamic_cast(query.get())) { + auto smsVector = smsDB->sms.getByText(localQuery->text); + std::vector recordVector; + for (auto sms : smsVector) { + SMSRecord record; + record.body = sms.body; + record.contactID = sms.contactID; + record.date = sms.date; + record.dateSent = sms.dateSent; + record.errorCode = sms.errorCode; + record.threadID = sms.threadID; + record.type = sms.type; + record.ID = sms.ID; + recordVector.emplace_back(record); + } + + return std::make_unique(recordVector); + } + return nullptr; } diff --git a/module-db/Interface/SMSTemplateRecord.cpp b/module-db/Interface/SMSTemplateRecord.cpp index 3094736875ad80c61db16b852fa8067bdee02b89..120cbefd80fc09af41193ea6fe971c0667b04be7 100644 --- a/module-db/Interface/SMSTemplateRecord.cpp +++ b/module-db/Interface/SMSTemplateRecord.cpp @@ -1,4 +1,5 @@ #include "SMSTemplateRecord.hpp" +#include "queries/sms/QuerySMSTemplateGetByID.hpp" #include @@ -73,3 +74,15 @@ SMSTemplateRecord SMSTemplateRecordInterface::GetByID(uint32_t id) return SMSTemplateRecord{templ}; } + +std::unique_ptr SMSTemplateRecordInterface::runQuery(std::shared_ptr query) +{ + if (const auto local_query = dynamic_cast(query.get())) { + + auto smsTemplate = smsDB->templates.getById(local_query->id); + return std::make_unique(std::move(smsTemplate)); + } + else { + return std::make_unique(SMSTemplateRecord()); + } +} diff --git a/module-db/Interface/SMSTemplateRecord.hpp b/module-db/Interface/SMSTemplateRecord.hpp index 1162d401ba059222f93f16dafe9df9b39fc7b404..4b24fa3cfffbfff966779c1b8e3e7338ba91c5cf 100644 --- a/module-db/Interface/SMSTemplateRecord.hpp +++ b/module-db/Interface/SMSTemplateRecord.hpp @@ -42,6 +42,8 @@ class SMSTemplateRecordInterface : public RecordInterface runQuery(std::shared_ptr query) override; + private: SmsDB *smsDB = nullptr; }; diff --git a/module-db/Tables/SMSTable.cpp b/module-db/Tables/SMSTable.cpp index 66b8282c82ec426d65378753cbb15195a4a8db5b..5c8a163a77b0af0634c417365470df0edd9f1f8c 100644 --- a/module-db/Tables/SMSTable.cpp +++ b/module-db/Tables/SMSTable.cpp @@ -82,6 +82,59 @@ SMSTableRow SMSTable::getById(uint32_t id) }; } +std::vector SMSTable::getByContactId(uint32_t contactId) +{ + auto retQuery = db->query("SELECT * FROM sms WHERE contact_id= %u;", contactId); + + if ((retQuery == nullptr) || (retQuery->getRowCount() == 0)) { + return std::vector(); + } + + std::vector ret; + + do { + ret.push_back(SMSTableRow{ + (*retQuery)[0].getUInt32(), // ID + (*retQuery)[1].getUInt32(), // threadID + (*retQuery)[2].getUInt32(), // contactID + (*retQuery)[3].getUInt32(), // date + (*retQuery)[4].getUInt32(), // dateSent + (*retQuery)[5].getUInt32(), // errorCode + (*retQuery)[6].getString(), // body + static_cast((*retQuery)[7].getUInt32()), // type + }); + } while (retQuery->nextRow()); + + return ret; +} + +std::vector SMSTable::getByText(std::string text) +{ + + auto retQuery = db->query("SELECT *, INSTR(body,'%s') pos FROM sms WHERE pos > 0;", text.c_str()); + + if ((retQuery == nullptr) || (retQuery->getRowCount() == 0)) { + return std::vector(); + } + + std::vector ret; + + do { + ret.push_back(SMSTableRow{ + (*retQuery)[0].getUInt32(), // ID + (*retQuery)[1].getUInt32(), // threadID + (*retQuery)[2].getUInt32(), // contactID + (*retQuery)[3].getUInt32(), // date + (*retQuery)[4].getUInt32(), // dateSent + (*retQuery)[5].getUInt32(), // errorCode + (*retQuery)[6].getString(), // body + static_cast((*retQuery)[7].getUInt32()), // type + }); + } while (retQuery->nextRow()); + + return ret; +} + std::vector SMSTable::getLimitOffset(uint32_t offset, uint32_t limit) { auto retQuery = db->query("SELECT * from sms ORDER BY date DESC LIMIT %lu OFFSET %lu;", limit, offset); diff --git a/module-db/Tables/SMSTable.hpp b/module-db/Tables/SMSTable.hpp index ee223d4f5d93cacdca429cfbea58589c9b20f858..52e7a940af1bf8f087ad21f2ec07f21db4131469 100644 --- a/module-db/Tables/SMSTable.hpp +++ b/module-db/Tables/SMSTable.hpp @@ -44,6 +44,8 @@ class SMSTable : public Table uint32_t count() override final; uint32_t countByFieldId(const char *field, uint32_t id) override final; + std::vector getByContactId(uint32_t contactId); + std::vector getByText(std::string text); std::pair> getManyByType(SMSType type, uint32_t offset, uint32_t limit); diff --git a/module-db/queries/sms/QuerySMSGetByContactID.cpp b/module-db/queries/sms/QuerySMSGetByContactID.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1dffe9072e0192d22c73ff41f9805617d606391e --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByContactID.cpp @@ -0,0 +1,24 @@ +#include "QuerySMSGetByContactID.hpp" + +namespace db::query +{ + SMSGetByContactID::SMSGetByContactID(unsigned int contactId) : Query(Query::Type::Read), contactId(contactId) + {} + + auto SMSGetByContactID::debugInfo() const -> std::string + { + return "SMSGetByContactID"; + } + + SMSGetByContactIDResult::SMSGetByContactIDResult(std::vector result) : result(std::move(result)) + {} + auto SMSGetByContactIDResult::getResults() const -> std::vector + { + return result; + } + auto SMSGetByContactIDResult::debugInfo() const -> std::string + { + return "SMSGetByContactIDResult"; + } + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSGetByContactID.hpp b/module-db/queries/sms/QuerySMSGetByContactID.hpp new file mode 100644 index 0000000000000000000000000000000000000000..eef57bf75680c0ed863933f3a6dec0802c92a1e6 --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByContactID.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include +#include "Interface/SMSRecord.hpp" + +namespace db::query +{ + /// implements search for SMS by type + class SMSGetByContactID : public Query + { + public: + SMSGetByContactID(unsigned int id); + unsigned int contactId; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class SMSGetByContactIDResult : public QueryResult + { + std::vector result; + + public: + SMSGetByContactIDResult(std::vector result); + [[nodiscard]] auto getResults() const -> std::vector; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSGetByID.cpp b/module-db/queries/sms/QuerySMSGetByID.cpp new file mode 100644 index 0000000000000000000000000000000000000000..42ce6d8b0623698d56df8a1fe79a2cd4bfbeb174 --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByID.cpp @@ -0,0 +1,24 @@ +#include "QuerySMSGetByID.hpp" + +namespace db::query +{ + SMSGetByID::SMSGetByID(unsigned int id) : Query(Query::Type::Read), id(id) + {} + + auto SMSGetByID::debugInfo() const -> std::string + { + return "SMSGetByID"; + } + + SMSGetByIDResult::SMSGetByIDResult(SMSRecord result) : result(std::move(result)) + {} + auto SMSGetByIDResult::getResults() const -> SMSRecord + { + return result; + } + auto SMSGetByIDResult::debugInfo() const -> std::string + { + return "SMSGetByIDResult"; + } + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSGetByID.hpp b/module-db/queries/sms/QuerySMSGetByID.hpp new file mode 100644 index 0000000000000000000000000000000000000000..0e7a6abe645f53251e55acee1da0c3a209279fbb --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByID.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include +#include "Interface/SMSRecord.hpp" + +namespace db::query +{ + /// implements search for SMS by type + class SMSGetByID : public Query + { + public: + SMSGetByID(unsigned int id); + unsigned int id; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class SMSGetByIDResult : public QueryResult + { + SMSRecord result; + + public: + SMSGetByIDResult(SMSRecord result); + [[nodiscard]] auto getResults() const -> SMSRecord; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSGetByText.cpp b/module-db/queries/sms/QuerySMSGetByText.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2553d1a52d294194a41e26e38b7cab04084a9651 --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByText.cpp @@ -0,0 +1,24 @@ +#include "QuerySMSGetByText.hpp" + +namespace db::query +{ + SMSGetByText::SMSGetByText(std::string text) : Query(Query::Type::Read), text(std::move(text)) + {} + + auto SMSGetByText::debugInfo() const -> std::string + { + return "SMSGetByText"; + } + + SMSGetByTextResult::SMSGetByTextResult(std::vector result) : result(std::move(result)) + {} + auto SMSGetByTextResult::getResults() const -> std::vector + { + return result; + } + auto SMSGetByTextResult::debugInfo() const -> std::string + { + return "SMSGetByTextResult"; + } + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSGetByText.hpp b/module-db/queries/sms/QuerySMSGetByText.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d8013448763837c2ee9e1c4a846014659f75b249 --- /dev/null +++ b/module-db/queries/sms/QuerySMSGetByText.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include +#include "Interface/SMSRecord.hpp" + +namespace db::query +{ + /// implements search for SMS by type + class SMSGetByText : public Query + { + public: + SMSGetByText(std::string text); + std::string text; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class SMSGetByTextResult : public QueryResult + { + std::vector result; + + public: + SMSGetByTextResult(std::vector result); + [[nodiscard]] auto getResults() const -> std::vector; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSTemplateGetByID.cpp b/module-db/queries/sms/QuerySMSTemplateGetByID.cpp new file mode 100644 index 0000000000000000000000000000000000000000..773955dd31808864c9d393495342619e2b865fb2 --- /dev/null +++ b/module-db/queries/sms/QuerySMSTemplateGetByID.cpp @@ -0,0 +1,24 @@ +#include "QuerySMSTemplateGetByID.hpp" + +namespace db::query +{ + SMSTemplateGetByID::SMSTemplateGetByID(unsigned int id) : Query(Query::Type::Read), id(id) + {} + + auto SMSTemplateGetByID::debugInfo() const -> std::string + { + return "SMSTemplateGetByID"; + } + + SMSTemplateGetByIDResult::SMSTemplateGetByIDResult(SMSTemplateRecord result) : result(std::move(result)) + {} + auto SMSTemplateGetByIDResult::getResults() const -> SMSTemplateRecord + { + return result; + } + auto SMSTemplateGetByIDResult::debugInfo() const -> std::string + { + return "SMSTemplateGetByIDResult"; + } + +} // namespace db::query diff --git a/module-db/queries/sms/QuerySMSTemplateGetByID.hpp b/module-db/queries/sms/QuerySMSTemplateGetByID.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ca3d8ef7b965ef312c70a6e0e53e58e2455e92b8 --- /dev/null +++ b/module-db/queries/sms/QuerySMSTemplateGetByID.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include +#include "Interface/SMSTemplateRecord.hpp" + +namespace db::query +{ + /// implements search for SMS by type + class SMSTemplateGetByID : public Query + { + public: + SMSTemplateGetByID(unsigned int id); + unsigned int id; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class SMSTemplateGetByIDResult : public QueryResult + { + SMSTemplateRecord result; + + public: + SMSTemplateGetByIDResult(SMSTemplateRecord result); + [[nodiscard]] auto getResults() const -> SMSTemplateRecord; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query diff --git a/module-services/service-db/api/DBServiceAPI.cpp b/module-services/service-db/api/DBServiceAPI.cpp index b41c14f827f44292fbcabce342d864406668ae1f..92bfe76dd58a03f30895db22d55e201a3ab4f56a 100644 --- a/module-services/service-db/api/DBServiceAPI.cpp +++ b/module-services/service-db/api/DBServiceAPI.cpp @@ -363,13 +363,15 @@ std::unique_ptr> DBServiceAPI::ContactGetBySpeeddial( std::unique_ptr> DBServiceAPI::ContactGetByPhoneNumber(sys::Service *serv, UTF8 phoneNumber) { ContactRecord rec; - rec.numbers.push_back(ContactRecord::Number(phoneNumber, phoneNumber)); + utils::PhoneNumber contactNumber(phoneNumber); + auto number = ContactRecord::Number(contactNumber.get(), contactNumber.toE164(), ContactNumberType ::PAGER); + rec.numbers.push_back(number); std::shared_ptr msg = std::make_shared(MessageType::DBContactGetByNumber, rec); auto ret = sys::Bus::SendUnicast(msg, service::name::db, serv, 5000); auto *contactResponse = dynamic_cast(ret.second.get()); - assert(contactResponse); + if ((ret.first == sys::ReturnCodes::Success) && (contactResponse->retCode == true)) { return std::move(contactResponse->records); } diff --git a/module-services/service-desktop/ServiceDesktop.cpp b/module-services/service-desktop/ServiceDesktop.cpp index 5b9d78c807ea5960e42068940764f6eb48d8d744..38fb43781a38f18f097c60ed5fdd327281ef42ae 100644 --- a/module-services/service-desktop/ServiceDesktop.cpp +++ b/module-services/service-desktop/ServiceDesktop.cpp @@ -3,6 +3,8 @@ #include "DesktopMessages.hpp" #include "EndpointHandler.hpp" #include "FactoryReset.hpp" +#include "messages/DBSMSMessage.hpp" +#include "messages/DBSMSTemplateMessage.hpp" ServiceDesktop::ServiceDesktop() : sys::Service(service::name::service_desktop, "", sdesktop::service_stack) { @@ -91,6 +93,14 @@ sys::Message_t ServiceDesktop::DataReceivedHandler(sys::DataMessage *msg, sys::R else if (resp->responseTo >= MessageType::DBContactVerify && resp->responseTo <= MessageType::DBContactBlock) { EndpointHandler::handleContactsMessage(msg, resp); } + else if (resp->responseTo >= MessageType::DBSMSAdd && resp->responseTo <= MessageType::DBSMSTemplateGetCount) { + if (dynamic_cast(resp) != nullptr) { + EndpointHandler::handleMessagesMessage(msg, resp); + } + else if (dynamic_cast(resp) != nullptr) { + EndpointHandler::handleMessageTemplatesMessage(msg, resp); + } + } else { LOG_DEBUG("resp->ResponseTo: %d", static_cast(resp->responseTo)); } diff --git a/module-services/service-desktop/endpoints/CMakeLists.txt b/module-services/service-desktop/endpoints/CMakeLists.txt index f2f77ca84858f4db5090bc6a3ea488a27c6d0b06..4471b4508eaeb3ff49c6f2dd81266a61691776c2 100755 --- a/module-services/service-desktop/endpoints/CMakeLists.txt +++ b/module-services/service-desktop/endpoints/CMakeLists.txt @@ -17,4 +17,5 @@ target_sources(${PROJECT_NAME} "Restore.cpp" "Factory.cpp" "Contacts.cpp" + "Messages.cpp" ) diff --git a/module-services/service-desktop/endpoints/Contacts.cpp b/module-services/service-desktop/endpoints/Contacts.cpp index a113c57f72bfc29a5736417b3abefe9881c59a72..d86db3fdb25701a1d595d495484a223b6c1493e9 100644 --- a/module-services/service-desktop/endpoints/Contacts.cpp +++ b/module-services/service-desktop/endpoints/Contacts.cpp @@ -85,6 +85,7 @@ auto ContactHelper::createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys LOG_ERROR("Empty number, not added!"); return sys::ReturnCodes::Failure; } + DBServiceAPI::ContactAdd(ownerServicePtr, *newRecord); return sys::ReturnCodes::Success; diff --git a/module-services/service-desktop/endpoints/Messages.cpp b/module-services/service-desktop/endpoints/Messages.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2fe3b302245e53c8f0d2756d218e0556d92f210d --- /dev/null +++ b/module-services/service-desktop/endpoints/Messages.cpp @@ -0,0 +1,274 @@ +#include "Messages.hpp" +#include "BaseInterface.hpp" +#include "Common/Query.hpp" +#include "ParserUtils.hpp" +#include "PhoneNumber.hpp" +#include "SMSRecord.hpp" +#include "SMSTemplateRecord.hpp" +#include "Service/Common.hpp" +#include "ThreadRecord.hpp" +#include "api/DBServiceAPI.hpp" +#include "log/log.hpp" +#include "phonenumbers/logger.h" +#include "queries/sms/QuerySMSGetByContactID.hpp" +#include "queries/sms/QuerySMSGetByID.hpp" +#include "queries/sms/QuerySMSGetByText.hpp" +#include "queries/sms/QuerySMSSearch.hpp" +#include "queries/sms/QuerySMSTemplateGetByID.hpp" +#include "queries/sms/QuerySmsThreadMarkAsRead.hpp" +#include "utf8/UTF8.hpp" +#include "json/json11.hpp" +#include + +using namespace ParserStateMachine; + +auto MessageHelper::getLastUUID() -> uint32_t +{ + auto uuid = uuidQueue.front(); + uuidQueue.pop(); + return uuid; +} + +auto MessageHelper::to_json(SMSRecord record) -> json11::Json +{ + + auto recordEntry = json11::Json::object{{json::messages::contactID, static_cast(record.contactID)}, + {json::messages::date, static_cast(record.date)}, + {json::messages::dateSent, static_cast(record.dateSent)}, + {json::messages::id, static_cast(record.ID)}, + {json::messages::messageBody, record.body.c_str()}, + {json::messages::phoneNumber, record.number.getEntered()}, + {json::messages::type, static_cast(record.type)}, + {json::messages::threadID, static_cast(record.threadID)}}; + return recordEntry; +} + +auto MessageHelper::to_json(SMSTemplateRecord record) -> json11::Json +{ + + auto recordEntry = json11::Json::object{{json::messages::id, static_cast(record.ID)}, + {json::messages::templateText, record.text.c_str()}}; + return recordEntry; +} + +auto MessageHelper::to_json(ThreadRecord record) -> json11::Json +{ + + auto recordEntry = + json11::Json::object{{json::messages::contactID, static_cast(record.contactID)}, + {json::messages::date, static_cast(record.date)}, + {json::messages::thread::msgCount, static_cast(record.msgCount)}, + {json::messages::id, static_cast(record.ID)}, + {json::messages::thread::snippet, record.snippet.c_str()}, + {json::messages::isUnread, record.isUnread()}, + {json::messages::type, static_cast(record.type)}, + {json::messages::thread::unreadMsgCount, static_cast(record.unreadMsgCount)}}; + return recordEntry; +} + +auto MessageHelper::from_json(json11::Json msgJson) -> SMSTemplateRecord +{ + SMSTemplateRecord record; + + record.text = UTF8(msgJson[json::messages::templateText].string_value()); + + return record; +} + +auto MessageHelper::requestDataFromDB(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes +{ + uuidQueue.push(uuid); + + if (getJSON[json::messages::msgTemplate].bool_value() == true) { + return requestTemplate(getJSON, uuid); + } + else { + return requestSMS(getJSON, uuid); + } +} + +auto MessageHelper::requestSMS(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes +{ + if (getJSON[json::messages::count].bool_value() == true) // get messages count + { + DBServiceAPI::SMSGetCount(ownerServicePtr); + } + else if (getJSON[json::messages::id].int_value() != 0) { // messages search + + auto query = std::make_unique(getJSON[json::messages::id].int_value()); + DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query)); + } + else if (getJSON[json::messages::contactID].int_value() != 0) { + + auto query = std::make_unique(getJSON[json::messages::contactID].int_value()); + DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query)); + } + else if (getJSON[json::messages::messageBody].string_value().empty() == false) { + auto query = std::make_unique(getJSON[json::messages::messageBody].string_value()); + DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query)); + } + else // get messages + { + DBServiceAPI::SMSGetLimitOffset(ownerServicePtr, 0, getJSON[json::messages::count].int_value()); + } + + return sys::ReturnCodes::Success; +} + +auto MessageHelper::requestTemplate(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes +{ + if (getJSON[json::messages::count].bool_value() == true) // get templates count + { + DBServiceAPI::SMSTemplateGetCount(ownerServicePtr); + } + else if (getJSON[json::messages::id].int_value() != 0) { // templates search + auto query = std::make_unique(getJSON[json::messages::id].int_value()); + DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMSTemplate, std::move(query)); + } + else // get messages + { + DBServiceAPI::SMSTemplateGetLimitOffset(ownerServicePtr, 0, getJSON[json::messages::count].int_value()); + } + + return sys::ReturnCodes::Success; +} + +auto MessageHelper::createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes +{ + uuidQueue.push(uuid); + + if (createJSON[json::messages::msgTemplate].bool_value() == true) { + return createTemplate(createJSON, uuid); + } + else { + return createSMS(createJSON, uuid); + } +} + +auto MessageHelper::createTemplate(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes +{ + SMSTemplateRecord record = from_json(createJSON); + + DBServiceAPI::SMSTemplateAdd(ownerServicePtr, record); + + return sys::ReturnCodes::Success; +} + +auto MessageHelper::createSMS(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes +{ + return sys::ReturnCodes::Success; +} + +auto MessageHelper::deleteDBEntry(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes +{ + uuidQueue.push(uuid); + + if (deleteJSON[json::messages::msgTemplate].bool_value() == true) { + return deleteTemplate(deleteJSON, uuid); + } + else { + return deleteSMS(deleteJSON, uuid); + } +} + +auto MessageHelper::deleteSMS(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes +{ + auto record = std::make_unique(); + record->ID = deleteJSON[json::messages::id].int_value(); + DBServiceAPI::SMSRemove(ownerServicePtr, *record); + + return sys::ReturnCodes::Success; +} + +auto MessageHelper::deleteTemplate(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes +{ + DBServiceAPI::SMSTemplateRemove(ownerServicePtr, deleteJSON[json::messages::id].int_value()); + return sys::ReturnCodes::Success; +} + +auto MessageHelper::updateDBEntry(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes +{ + uuidQueue.push(uuid); + + if (updateJSON[json::messages::msgTemplate].bool_value() == true) { + return updateTemplate(updateJSON, uuid); + } + else { + return updateSMS(updateJSON, uuid); + } +} + +auto MessageHelper::updateSMS(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes +{ + using namespace db::query::smsthread; + + auto query = std::make_unique( + updateJSON[json::messages::threadID].int_value(), + (updateJSON[json::messages::isUnread].bool_value() ? MarkAsRead::Read::False : MarkAsRead::Read::True)); + LOG_DEBUG("Marking SMS thread as %d...", updateJSON[json::messages::isUnread].bool_value()); + + DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMSThread, std::move(query)); + return sys::ReturnCodes::Success; +} + +auto MessageHelper::updateTemplate(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes +{ + SMSTemplateRecord record; + record.ID = updateJSON[json::messages::id].int_value(); + record.text = updateJSON[json::messages::templateText].string_value(); + + DBServiceAPI::SMSTemplateUpdate(ownerServicePtr, record); + return sys::ReturnCodes::Success; +} + +auto MessageHelper::processQueryResult(db::QueryResult *result) -> json11::Json +{ + if (dynamic_cast(result) != nullptr) { + auto SMSresult = dynamic_cast(result); + auto recordJSON = to_json(SMSresult->getResults()); + return recordJSON; + } + + else if (dynamic_cast(result) != nullptr) { + auto SMSresult = dynamic_cast(result); + json11::Json::array SMSarray; + + for (auto record : SMSresult->getResults()) { + + SMSarray.emplace_back(to_json(record)); + } + + return SMSarray; + } + + else if (dynamic_cast(result) != nullptr) { + auto SMSresult = dynamic_cast(result); + json11::Json::array SMSarray; + + for (auto record : SMSresult->getResults()) { + + SMSarray.emplace_back(to_json(record)); + } + + return SMSarray; + } + + else if (dynamic_cast(result) != nullptr) { + auto SMSresult = dynamic_cast(result); + + json11::Json responsePayloadJson = json11::Json::object{ + {json::endpoint, static_cast(Endpoint::messages)}, + {json::status, static_cast(SMSresult->getResult() ? http::Code::OK : http::Code::InternalServerError)}, + {json::uuid, std::to_string(getLastUUID())}, + {json::body, ""}}; + return responsePayloadJson; + } + + else if (dynamic_cast(result) != nullptr) { + auto SMSTemplateResult = dynamic_cast(result); + return to_json(SMSTemplateResult->getResults()); + } + else { + return json11::Json(); + } +} diff --git a/module-services/service-desktop/endpoints/Messages.hpp b/module-services/service-desktop/endpoints/Messages.hpp new file mode 100644 index 0000000000000000000000000000000000000000..6882e681d44474b85d463caf5bd906d0714b2954 --- /dev/null +++ b/module-services/service-desktop/endpoints/Messages.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include "SMSTemplateRecord.hpp" +#include "Service/Service.hpp" +#include "Service/Common.hpp" +#include "DBHelper.hpp" +#include + +namespace ParserStateMachine +{ + + class MessageHelper : DBHelper + { + public: + MessageHelper(sys::Service *_ownerServicePtr) : DBHelper(_ownerServicePtr){}; + + auto createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes override; + auto requestDataFromDB(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes override; + auto updateDBEntry(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes override; + auto deleteDBEntry(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes override; + + auto requestTemplate(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes; + auto requestSMS(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes; + auto createTemplate(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes; + auto createSMS(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes; + auto deleteTemplate(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes; + auto deleteSMS(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes; + auto updateSMS(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes; + auto updateTemplate(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes; + + auto requestMessagesCount(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes; + auto processQueryResult(db::QueryResult *result) -> json11::Json override; + auto getLastUUID() -> uint32_t; + auto to_json(SMSRecord record) -> json11::Json; + auto to_json(ThreadRecord record) -> json11::Json; + auto to_json(SMSTemplateRecord record) -> json11::Json; + auto from_json(json11::Json msgJson) -> SMSTemplateRecord; + + private: + json11::Json receivedJson; + }; + +} // namespace ParserStateMachine diff --git a/module-services/service-desktop/parser/EndpointHandler.cpp b/module-services/service-desktop/parser/EndpointHandler.cpp index 90ae51da522b3c4ab14596298a34ebb32b835355..145bfca3aa2cccf52de2b041a3a821569426f402 100644 --- a/module-services/service-desktop/parser/EndpointHandler.cpp +++ b/module-services/service-desktop/parser/EndpointHandler.cpp @@ -1,15 +1,29 @@ #include "EndpointHandler.hpp" #include "Contacts.hpp" +#include "Messages.hpp" #include "ParserUtils.hpp" +#include "SMSRecord.hpp" #include "Service/Common.hpp" #include "Service/Service.hpp" +#include "log/log.hpp" #include "messages/DBContactMessage.hpp" +#include "messages/DBSMSMessage.hpp" +#include "messages/DBSMSTemplateMessage.hpp" #include "messages/QueryMessage.hpp" #include "queries/phonebook/QueryContactGet.hpp" +#include "queries/sms/QuerySMSGetByID.hpp" +#include "queries/sms/QuerySMSGetByContactID.hpp" +#include "queries/sms/QuerySMSGetByText.hpp" +#include "queries/sms/QuerySMSSearch.hpp" +#include "queries/sms/QuerySMSTemplateGetByID.hpp" +#include "queries/sms/QuerySmsThreadMarkAsRead.hpp" +#include "json/json11.hpp" +#include using namespace ParserStateMachine; std::shared_ptr EndpointHandler::contactHelper; +std::shared_ptr EndpointHandler::messageHelper; std::string EndpointHandler::buildResponseStr(std::size_t responseSize, std::string responsePayloadString) { @@ -22,30 +36,35 @@ std::string EndpointHandler::buildResponseStr(std::size_t responseSize, std::str return responseStr; } -std::string EndpointHandler::createSimpleResponse(sys::ReturnCodes status, int endpoint, uint32_t uuid) +std::string EndpointHandler::createSimpleResponse(sys::ReturnCodes status, + int endpoint, + uint32_t uuid, + json11::Json body) { json11::Json responseJson = json11::Json::object{ {ParserStateMachine::json::endpoint, endpoint}, {ParserStateMachine::json::status, static_cast(status == sys::ReturnCodes::Success ? http::Code::OK : http::Code::InternalServerError)}, {ParserStateMachine::json::uuid, std::to_string(uuid)}, - {ParserStateMachine::json::body, ""}}; + {ParserStateMachine::json::body, body}}; return EndpointHandler::buildResponseStr(responseJson.dump().size(), responseJson.dump()); } -std::string EndpointHandler::createSimpleResponse(bool status, int endpoint, uint32_t uuid) +std::string EndpointHandler::createSimpleResponse(bool status, int endpoint, uint32_t uuid, json11::Json body) { json11::Json responseJson = json11::Json::object{ {ParserStateMachine::json::endpoint, endpoint}, {ParserStateMachine::json::status, static_cast(status ? http::Code::OK : http::Code::InternalServerError)}, {ParserStateMachine::json::uuid, std::to_string(uuid)}, - {ParserStateMachine::json::body, ""}}; + {ParserStateMachine::json::body, body}}; + return EndpointHandler::buildResponseStr(responseJson.dump().size(), responseJson.dump()); } void EndpointHandler::initHelpers(sys::Service *ownerService) { contactHelper = std::make_shared(ownerService); + messageHelper = std::make_shared(ownerService); } sys::ReturnCodes EndpointHandler::handleQueryMessage(sys::DataMessage *msg, sys::ResponseMessage *resp) @@ -58,7 +77,7 @@ sys::ReturnCodes EndpointHandler::handleQueryMessage(sys::DataMessage *msg, sys: LOG_ERROR("Unexpected message."); return sys::ReturnCodes::Failure; } - LOG_DEBUG("respTo: %d", (short)queryResponse->responseTo); + LOG_DEBUG("respTo: %d", static_cast(queryResponse->responseTo)); auto result = queryResponse->getResult(); LOG_DEBUG("result: %s", result->debugInfo().c_str()); @@ -67,13 +86,38 @@ sys::ReturnCodes EndpointHandler::handleQueryMessage(sys::DataMessage *msg, sys: auto responseStr = contactHelper->processQueryResult(result.get()).dump(); MessageHandler::putToSendQueue(EndpointHandler::buildResponseStr(responseStr.size(), responseStr)); } + else if (dynamic_cast(result.get()) != nullptr) { + auto responseStr = messageHelper->processQueryResult(result.get()).dump(); + MessageHandler::putToSendQueue(EndpointHandler::buildResponseStr(responseStr.size(), responseStr)); + } + else if (dynamic_cast(result.get()) != nullptr) { + auto responseBody = messageHelper->processQueryResult(result.get()).dump(); + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), responseBody)); + } + else if (dynamic_cast(result.get()) != nullptr) { + auto responseBody = messageHelper->processQueryResult(result.get()); + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), responseBody)); + } + else if (dynamic_cast(result.get()) != nullptr) { + auto responseBody = messageHelper->processQueryResult(result.get()); + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), responseBody)); + } + else if (dynamic_cast(result.get()) != nullptr) { + LOG_DEBUG("template test"); + auto responseBody = messageHelper->processQueryResult(result.get()); + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), responseBody)); + } return sys::ReturnCodes::Success; } sys::ReturnCodes EndpointHandler::handleContactsMessage(sys::DataMessage *msg, sys::ResponseMessage *resp) { - LOG_DEBUG("resp->ResponseTo: %d", (short)resp->responseTo); + LOG_DEBUG("resp->ResponseTo: %d", static_cast(resp->responseTo)); if (dynamic_cast(resp) != nullptr && resp->responseTo == MessageType::DBContactGetByID) { @@ -100,6 +144,78 @@ sys::ReturnCodes EndpointHandler::handleContactsMessage(sys::DataMessage *msg, s return sys::ReturnCodes::Success; } +sys::ReturnCodes EndpointHandler::handleMessagesMessage(sys::DataMessage *msg, sys::ResponseMessage *resp) +{ + LOG_DEBUG("resp->ResponseTo: %d", static_cast(resp->responseTo)); + + if (resp->responseTo == MessageType::DBSMSGetCount) { + + auto response = dynamic_cast(resp); + LOG_DEBUG("SMS count: %" PRIu32 "", response->count); + json11::Json body = json11::Json::object{{json::messages::count, static_cast(response->count)}}; + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), body)); + } + else if (resp->responseTo == MessageType::DBSMSGetSMSLimitOffset || + resp->responseTo == MessageType::DBSMSGetSMSLimitOffsetByThreadID) { + + auto response = dynamic_cast(resp); + auto records = std::move(response->records); + + json11::Json::array recordsArray; + for (auto record : *records) { + recordsArray.emplace_back(messageHelper->to_json(record)); + } + + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), recordsArray)); + } + else if (resp->responseTo == MessageType::DBSMSRemove) { + + LOG_DEBUG("SMS removed"); + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID())); + } + + return sys::ReturnCodes::Success; +} + +sys::ReturnCodes EndpointHandler::handleMessageTemplatesMessage(sys::DataMessage *msg, sys::ResponseMessage *resp) +{ + LOG_DEBUG("resp->ResponseTo: %d", static_cast(resp->responseTo)); + + if (resp->responseTo == MessageType::DBSMSTemplateGetCount) { + + auto response = dynamic_cast(resp); + LOG_DEBUG("SMS Template count: %" PRIu32 "", response->count); + json11::Json body = json11::Json::object{{json::messages::count, static_cast(response->count)}}; + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), body)); + } + else if (resp->responseTo == MessageType::DBSMSTemplateGetLimitOffset) { + + auto response = dynamic_cast(resp); + auto records = std::move(response->records); + + json11::Json::array recordsArray; + for (auto record : *records) { + recordsArray.emplace_back(messageHelper->to_json(record)); + } + + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID(), recordsArray)); + } + else if (resp->responseTo == MessageType::DBSMSTemplateAdd || + resp->responseTo == MessageType::DBSMSTemplateRemove || + resp->responseTo == MessageType::DBSMSTemplateUpdate) { + + MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse( + resp->retCode, static_cast(Endpoint::messages), messageHelper->getLastUUID())); + } + + return sys::ReturnCodes::Success; +} + sys::ReturnCodes EndpointHandler::contacts( uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService) { @@ -122,3 +238,26 @@ sys::ReturnCodes EndpointHandler::contacts( return sys::ReturnCodes::Success; } + +sys::ReturnCodes EndpointHandler::messages( + uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService) +{ + // process messages request + + switch (static_cast(httpMethod)) { + case http::Method::get: + messageHelper->requestDataFromDB(body, uuid); + break; + case http::Method::post: // update entry + messageHelper->updateDBEntry(body, uuid); + break; + case http::Method::put: + messageHelper->createDBEntry(body, uuid); + break; + case http::Method::del: + messageHelper->deleteDBEntry(body, uuid); + break; + } + + return sys::ReturnCodes::Success; +} diff --git a/module-services/service-desktop/parser/EndpointHandler.hpp b/module-services/service-desktop/parser/EndpointHandler.hpp index 027167ee74dc7532db4f8c7ea170ff7d70a939f0..3b0f92b31938fd0154d6928206a5cd36afeeb573 100644 --- a/module-services/service-desktop/parser/EndpointHandler.hpp +++ b/module-services/service-desktop/parser/EndpointHandler.hpp @@ -5,8 +5,10 @@ #include "ParserUtils.hpp" #include "Service/Common.hpp" #include +#include #include "DBHelper.hpp" #include "Contacts.hpp" +#include "Messages.hpp" #include "queries/phonebook/QueryContactGet.hpp" using namespace ParserStateMachine; @@ -18,9 +20,18 @@ class EndpointHandler static sys::ReturnCodes handleQueryMessage(sys::DataMessage *msg, sys::ResponseMessage *resp); static sys::ReturnCodes handleContactsMessage(sys::DataMessage *msg, sys::ResponseMessage *resp); + static sys::ReturnCodes handleMessagesMessage(sys::DataMessage *msg, sys::ResponseMessage *resp); + static sys::ReturnCodes handleMessageTemplatesMessage(sys::DataMessage *msg, sys::ResponseMessage *resp); + static sys::ReturnCodes decodeMessage(db::query::ContactGetResult *message); - static std::string createSimpleResponse(sys::ReturnCodes status, int endpoint, uint32_t uuid); - static std::string createSimpleResponse(bool status, int endpoint, uint32_t uuid); + static std::string createSimpleResponse(sys::ReturnCodes status, + int endpoint, + uint32_t uuid, + json11::Json body = json11::Json()); + static std::string createSimpleResponse(bool status, + int endpoint, + uint32_t uuid, + json11::Json body = json11::Json()); static std::string buildResponseStr(std::size_t responseSize, std::string responsePayloadString); static sys::ReturnCodes update( @@ -35,7 +46,10 @@ class EndpointHandler uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService); static sys::ReturnCodes contacts( uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService); + static sys::ReturnCodes messages( + uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService); private: static std::shared_ptr contactHelper; + static std::shared_ptr messageHelper; }; diff --git a/module-services/service-desktop/parser/MessageHandler.cpp b/module-services/service-desktop/parser/MessageHandler.cpp index 5313c59c3f88f41b6fb540502d9772341ad39d01..1f37fdd106f56ba907722de13de68606433319e5 100644 --- a/module-services/service-desktop/parser/MessageHandler.cpp +++ b/module-services/service-desktop/parser/MessageHandler.cpp @@ -54,6 +54,11 @@ void MessageHandler::processMessage() case Endpoint::contacts: EndpointHandler::contacts(method, uuid, body, responseStr, OwnerServicePtr); break; + case Endpoint::messages: + EndpointHandler::messages(method, uuid, body, responseStr, OwnerServicePtr); + + break; + default: break; } diff --git a/module-services/service-desktop/parser/ParserUtils.hpp b/module-services/service-desktop/parser/ParserUtils.hpp index ccdcdeabdc4142ba6ffe18c1e13094bb40af78a1..466d3a69d54d05af42bfc49b1e325ffea65d4970 100644 --- a/module-services/service-desktop/parser/ParserUtils.hpp +++ b/module-services/service-desktop/parser/ParserUtils.hpp @@ -15,7 +15,8 @@ namespace ParserStateMachine backup, restore, factory, - contacts + contacts, + messages }; // Message defs and utils @@ -126,6 +127,31 @@ namespace ParserStateMachine } // namespace contacts + namespace messages + { + const inline std::string id = "id"; + const inline std::string count = "count"; + const inline std::string offset = "offset"; + const inline std::string phoneNumber = "phoneNumber"; + const inline std::string messageBody = "messageBody"; + const inline std::string isUnread = "unread"; + const inline std::string contactID = "contactID"; + const inline std::string date = "date"; + const inline std::string dateSent = "dateSent"; + const inline std::string type = "type"; + const inline std::string threadID = "threadID"; + const inline std::string msgTemplate = "template"; + const inline std::string templateText = "text"; + namespace thread + { + const inline std::string msgCount = "msgCount"; + const inline std::string snippet = "snippet"; + const inline std::string unreadMsgCount = "unreadMsgCount"; + + } // namespace thread + + } // namespace messages + } // namespace json } // namespace ParserStateMachine diff --git a/module-services/service-desktop/tests/unittest.cpp b/module-services/service-desktop/tests/unittest.cpp index 04e81eb700d1530a81b3c2e106a930d3f72d2e80..b655e7ed50b100a3a42107b3bdb6a5a6f18dbc16 100644 --- a/module-services/service-desktop/tests/unittest.cpp +++ b/module-services/service-desktop/tests/unittest.cpp @@ -1,13 +1,17 @@ +#include "Common/Common.hpp" #include "ContactRecord.hpp" +#include "MessageType.hpp" #include "ParserUtils.hpp" #include "Service/Common.hpp" #include "UpdatePureOS.hpp" #include "FactoryReset.hpp" #include "ParserStateMachine.hpp" #include "EndpointHandler.hpp" +#include "queries/sms/QuerySMSSearchByType.hpp" #include "service-desktop/ServiceDesktop.hpp" #include "json/json11.hpp" +#include #include #include #include @@ -162,7 +166,7 @@ TEST_CASE("DB Helpers test - json decoding") } } -TEST_CASE("DB Helpers test - json encoding") +TEST_CASE("DB Helpers test - json encoding (contacts)") { auto helper = std::make_unique(nullptr); @@ -188,18 +192,55 @@ TEST_CASE("DB Helpers test - json encoding") REQUIRE(contactJson[json::contacts::numbers][0].dump() == "\"724842187\""); } +TEST_CASE("DB Helpers test - json encoding (messages)") +{ + auto helper = std::make_unique(nullptr); + auto message = std::make_unique(); + + utils::PhoneNumber phoneNumber("111222333"); + auto contactNum = ContactRecord::Number(phoneNumber.get(), phoneNumber.toE164(), ContactNumberType ::PAGER); + + message->body = "test message"; + message->contactID = 1; + message->date = 12345; + message->dateSent = 54321; + message->errorCode = 0; + message->number = contactNum.number; + message->threadID = 1; + message->ID = 10; + message->type = SMSType::DRAFT; + + auto messageJson = helper->to_json(*message); + + REQUIRE(messageJson[json::messages::messageBody] == "test message"); + REQUIRE(messageJson[json::messages::contactID] == 1); + REQUIRE(messageJson[json::messages::date] == 12345); + REQUIRE(messageJson[json::messages::dateSent] == 54321); + REQUIRE(messageJson[json::messages::threadID] == 1); + REQUIRE(messageJson[json::messages::id] == 10); + + auto messageTemplate = std::make_unique(); + + messageTemplate->text = "test template"; + messageTemplate->ID = 1; + + auto messageTemplateJson = helper->to_json(*messageTemplate); + + REQUIRE(messageTemplateJson[json::messages::templateText] == "test template"); + REQUIRE(messageTemplateJson[json::messages::id] == 1); +} + TEST_CASE("Simple response builder test") { auto resp = EndpointHandler::createSimpleResponse(sys::ReturnCodes::Success, static_cast(Endpoint::contacts), 1234); std::string err; - REQUIRE(resp.substr(0, 10) == "#000000058"); + REQUIRE(resp.substr(0, 10) == "#000000060"); resp.erase(0, 10); auto responseJson = json11::Json::parse(resp, err); REQUIRE(err.empty()); REQUIRE(responseJson[json::endpoint] == static_cast(Endpoint::contacts)); - REQUIRE(responseJson[json::body] == ""); REQUIRE(responseJson[json::status] == static_cast(http::Code::OK)); REQUIRE(responseJson[json::uuid].dump() == "\"1234\""); }