28 files changed, 938 insertions(+), 19 deletions(-)

M .vscode/settings.json
M module-apps/application-calendar/models/NewEditEventModel.cpp
M module-apps/application-calendar/windows/CalendarMainWindow.cpp
M module-db/CMakeLists.txt
M module-db/Interface/SMSRecord.cpp
M module-db/Interface/SMSTemplateRecord.cpp
M module-db/Interface/SMSTemplateRecord.hpp
M module-db/Tables/SMSTable.cpp
M module-db/Tables/SMSTable.hpp
A module-db/queries/sms/QuerySMSGetByContactID.cpp
A module-db/queries/sms/QuerySMSGetByContactID.hpp
A module-db/queries/sms/QuerySMSGetByID.cpp
A module-db/queries/sms/QuerySMSGetByID.hpp
A module-db/queries/sms/QuerySMSGetByText.cpp
A module-db/queries/sms/QuerySMSGetByText.hpp
A module-db/queries/sms/QuerySMSTemplateGetByID.cpp
A module-db/queries/sms/QuerySMSTemplateGetByID.hpp
M module-services/service-db/api/DBServiceAPI.cpp
M module-services/service-desktop/ServiceDesktop.cpp
M module-services/service-desktop/endpoints/CMakeLists.txt
M module-services/service-desktop/endpoints/Contacts.cpp
A module-services/service-desktop/endpoints/Messages.cpp
A module-services/service-desktop/endpoints/Messages.hpp
M module-services/service-desktop/parser/EndpointHandler.cpp
M module-services/service-desktop/parser/EndpointHandler.hpp
M module-services/service-desktop/parser/MessageHandler.cpp
M module-services/service-desktop/parser/ParserUtils.hpp
M module-services/service-desktop/tests/unittest.cpp

@@ 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

@@ 105,7 105,7 @@ void NewEditEventModel::loadDataWithoutTimeItem()
 
 void NewEditEventModel::reloadDataWithTimeItem()
 {
-    auto app = application;
+    [[maybe_unused]] auto app = application;
     assert(app != nullptr);
 
     internalData.clear();

@@ 217,7 217,7 @@ namespace gui
         AppWindow::buildInterface();
 
         LOG_DEBUG("Start build interface for calendar main window");
-        auto app = dynamic_cast<app::ApplicationCalendar *>(application);
+        [[maybe_unused]] auto app = dynamic_cast<app::ApplicationCalendar *>(application);
         assert(app != nullptr);
 
         setTitle(utils::localize.get("app_calendar_title_main"));

@@ 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

@@ 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 <log/log.hpp>
 


@@ 288,9 293,61 @@ SMSRecord SMSRecordInterface::GetByID(uint32_t id)
 
 std::unique_ptr<db::QueryResult> SMSRecordInterface::runQuery(std::shared_ptr<db::Query> query)
 {
-    if (const auto local_query = dynamic_cast<const db::query::SMSSearchByType *>(query.get())) {
-        return runQueryImpl(local_query);
+    if (const auto localQuery = dynamic_cast<const db::query::SMSSearchByType *>(query.get())) {
+        return runQueryImpl(localQuery);
     }
+    else if (const auto localQuery = dynamic_cast<const db::query::SMSGetByID *>(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<db::query::SMSGetByIDResult>(record);
+    }
+    else if (const auto localQuery = dynamic_cast<const db::query::SMSGetByContactID *>(query.get())) {
+        auto smsVector = smsDB->sms.getByContactId(localQuery->contactId);
+        std::vector<SMSRecord> 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<db::query::SMSGetByContactIDResult>(recordVector);
+    }
+    else if (const auto localQuery = dynamic_cast<const db::query::SMSGetByText *>(query.get())) {
+        auto smsVector = smsDB->sms.getByText(localQuery->text);
+        std::vector<SMSRecord> 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<db::query::SMSGetByContactIDResult>(recordVector);
+    }
+
     return nullptr;
 }
 

@@ 1,4 1,5 @@
 #include "SMSTemplateRecord.hpp"
+#include "queries/sms/QuerySMSTemplateGetByID.hpp"
 
 #include <log/log.hpp>
 


@@ 73,3 74,15 @@ SMSTemplateRecord SMSTemplateRecordInterface::GetByID(uint32_t id)
 
     return SMSTemplateRecord{templ};
 }
+
+std::unique_ptr<db::QueryResult> SMSTemplateRecordInterface::runQuery(std::shared_ptr<db::Query> query)
+{
+    if (const auto local_query = dynamic_cast<const db::query::SMSTemplateGetByID *>(query.get())) {
+
+        auto smsTemplate = smsDB->templates.getById(local_query->id);
+        return std::make_unique<db::query::SMSTemplateGetByIDResult>(std::move(smsTemplate));
+    }
+    else {
+        return std::make_unique<db::query::SMSTemplateGetByIDResult>(SMSTemplateRecord());
+    }
+}

@@ 42,6 42,8 @@ class SMSTemplateRecordInterface : public RecordInterface<SMSTemplateRecord, SMS
                                                                           SMSTemplateRecordField field,
                                                                           const char *str) override final;
 
+    std::unique_ptr<db::QueryResult> runQuery(std::shared_ptr<db::Query> query) override;
+
   private:
     SmsDB *smsDB = nullptr;
 };

@@ 82,6 82,59 @@ SMSTableRow SMSTable::getById(uint32_t id)
     };
 }
 
+std::vector<SMSTableRow> 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<SMSTableRow>();
+    }
+
+    std::vector<SMSTableRow> 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<SMSType>((*retQuery)[7].getUInt32()), // type
+        });
+    } while (retQuery->nextRow());
+
+    return ret;
+}
+
+std::vector<SMSTableRow> 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<SMSTableRow>();
+    }
+
+    std::vector<SMSTableRow> 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<SMSType>((*retQuery)[7].getUInt32()), // type
+        });
+    } while (retQuery->nextRow());
+
+    return ret;
+}
+
 std::vector<SMSTableRow> 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);

@@ 44,6 44,8 @@ class SMSTable : public Table<SMSTableRow, SMSTableFields>
 
     uint32_t count() override final;
     uint32_t countByFieldId(const char *field, uint32_t id) override final;
+    std::vector<SMSTableRow> getByContactId(uint32_t contactId);
+    std::vector<SMSTableRow> getByText(std::string text);
 
     std::pair<uint32_t, std::vector<SMSTableRow>> getManyByType(SMSType type, uint32_t offset, uint32_t limit);
 

@@ 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<SMSRecord> result) : result(std::move(result))
+    {}
+    auto SMSGetByContactIDResult::getResults() const -> std::vector<SMSRecord>
+    {
+        return result;
+    }
+    auto SMSGetByContactIDResult::debugInfo() const -> std::string
+    {
+        return "SMSGetByContactIDResult";
+    }
+
+} // namespace db::query

@@ 0,0 1,29 @@
+#pragma once
+
+#include <Tables/ThreadsTable.hpp>
+#include <Common/Query.hpp>
+#include <string>
+#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<SMSRecord> result;
+
+      public:
+        SMSGetByContactIDResult(std::vector<SMSRecord> result);
+        [[nodiscard]] auto getResults() const -> std::vector<SMSRecord>;
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+    };
+
+} // namespace db::query

@@ 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

@@ 0,0 1,29 @@
+#pragma once
+
+#include <Tables/ThreadsTable.hpp>
+#include <Common/Query.hpp>
+#include <string>
+#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

@@ 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<SMSRecord> result) : result(std::move(result))
+    {}
+    auto SMSGetByTextResult::getResults() const -> std::vector<SMSRecord>
+    {
+        return result;
+    }
+    auto SMSGetByTextResult::debugInfo() const -> std::string
+    {
+        return "SMSGetByTextResult";
+    }
+
+} // namespace db::query

@@ 0,0 1,29 @@
+#pragma once
+
+#include <Tables/ThreadsTable.hpp>
+#include <Common/Query.hpp>
+#include <string>
+#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<SMSRecord> result;
+
+      public:
+        SMSGetByTextResult(std::vector<SMSRecord> result);
+        [[nodiscard]] auto getResults() const -> std::vector<SMSRecord>;
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+    };
+
+} // namespace db::query

@@ 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

@@ 0,0 1,29 @@
+#pragma once
+
+#include <Tables/ThreadsTable.hpp>
+#include <Common/Query.hpp>
+#include <string>
+#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

@@ 363,13 363,15 @@ std::unique_ptr<std::vector<ContactRecord>> DBServiceAPI::ContactGetBySpeeddial(
 std::unique_ptr<std::vector<ContactRecord>> 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<DBContactMessage> msg = std::make_shared<DBContactMessage>(MessageType::DBContactGetByNumber, rec);
 
     auto ret              = sys::Bus::SendUnicast(msg, service::name::db, serv, 5000);
     auto *contactResponse = dynamic_cast<DBContactResponseMessage *>(ret.second.get());
-    assert(contactResponse);
+
     if ((ret.first == sys::ReturnCodes::Success) && (contactResponse->retCode == true)) {
         return std::move(contactResponse->records);
     }

@@ 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<DBSMSResponseMessage *>(resp) != nullptr) {
+                EndpointHandler::handleMessagesMessage(msg, resp);
+            }
+            else if (dynamic_cast<DBSMSTemplateResponseMessage *>(resp) != nullptr) {
+                EndpointHandler::handleMessageTemplatesMessage(msg, resp);
+            }
+        }
         else {
             LOG_DEBUG("resp->ResponseTo: %d", static_cast<short>(resp->responseTo));
         }

@@ 17,4 17,5 @@ target_sources(${PROJECT_NAME}
 		"Restore.cpp"
 		"Factory.cpp"
 		"Contacts.cpp"
+		"Messages.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;

@@ 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 <memory>
+
+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<int>(record.contactID)},
+                                            {json::messages::date, static_cast<int>(record.date)},
+                                            {json::messages::dateSent, static_cast<int>(record.dateSent)},
+                                            {json::messages::id, static_cast<int>(record.ID)},
+                                            {json::messages::messageBody, record.body.c_str()},
+                                            {json::messages::phoneNumber, record.number.getEntered()},
+                                            {json::messages::type, static_cast<int>(record.type)},
+                                            {json::messages::threadID, static_cast<int>(record.threadID)}};
+    return recordEntry;
+}
+
+auto MessageHelper::to_json(SMSTemplateRecord record) -> json11::Json
+{
+
+    auto recordEntry = json11::Json::object{{json::messages::id, static_cast<int>(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<int>(record.contactID)},
+                             {json::messages::date, static_cast<int>(record.date)},
+                             {json::messages::thread::msgCount, static_cast<int>(record.msgCount)},
+                             {json::messages::id, static_cast<int>(record.ID)},
+                             {json::messages::thread::snippet, record.snippet.c_str()},
+                             {json::messages::isUnread, record.isUnread()},
+                             {json::messages::type, static_cast<int>(record.type)},
+                             {json::messages::thread::unreadMsgCount, static_cast<int>(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<db::query::SMSGetByID>(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<db::query::SMSGetByContactID>(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<db::query::SMSGetByText>(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<db::query::SMSTemplateGetByID>(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<SMSRecord>();
+    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<db::query::smsthread::MarkAsRead>(
+        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<db::query::SMSGetByIDResult *>(result) != nullptr) {
+        auto SMSresult  = dynamic_cast<db::query::SMSGetByIDResult *>(result);
+        auto recordJSON = to_json(SMSresult->getResults());
+        return recordJSON;
+    }
+
+    else if (dynamic_cast<db::query::SMSGetByContactIDResult *>(result) != nullptr) {
+        auto SMSresult = dynamic_cast<db::query::SMSGetByContactIDResult *>(result);
+        json11::Json::array SMSarray;
+
+        for (auto record : SMSresult->getResults()) {
+
+            SMSarray.emplace_back(to_json(record));
+        }
+
+        return SMSarray;
+    }
+
+    else if (dynamic_cast<db::query::SMSGetByTextResult *>(result) != nullptr) {
+        auto SMSresult = dynamic_cast<db::query::SMSGetByTextResult *>(result);
+        json11::Json::array SMSarray;
+
+        for (auto record : SMSresult->getResults()) {
+
+            SMSarray.emplace_back(to_json(record));
+        }
+
+        return SMSarray;
+    }
+
+    else if (dynamic_cast<db::query::smsthread::MarkAsReadResult *>(result) != nullptr) {
+        auto SMSresult = dynamic_cast<db::query::smsthread::MarkAsReadResult *>(result);
+
+        json11::Json responsePayloadJson = json11::Json::object{
+            {json::endpoint, static_cast<int>(Endpoint::messages)},
+            {json::status, static_cast<int>(SMSresult->getResult() ? http::Code::OK : http::Code::InternalServerError)},
+            {json::uuid, std::to_string(getLastUUID())},
+            {json::body, ""}};
+        return responsePayloadJson;
+    }
+
+    else if (dynamic_cast<db::query::SMSTemplateGetByIDResult *>(result) != nullptr) {
+        auto SMSTemplateResult = dynamic_cast<db::query::SMSTemplateGetByIDResult *>(result);
+        return to_json(SMSTemplateResult->getResults());
+    }
+    else {
+        return json11::Json();
+    }
+}

@@ 0,0 1,43 @@
+#pragma once
+
+#include "SMSTemplateRecord.hpp"
+#include "Service/Service.hpp"
+#include "Service/Common.hpp"
+#include "DBHelper.hpp"
+#include <service-db/api/DBServiceAPI.hpp>
+
+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

@@ 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 <string>
 
 using namespace ParserStateMachine;
 
 std::shared_ptr<ContactHelper> EndpointHandler::contactHelper;
+std::shared_ptr<MessageHelper> 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<int>(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<int>(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<ContactHelper>(ownerService);
+    messageHelper = std::make_shared<MessageHelper>(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<short>(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<db::query::smsthread::MarkAsReadResult *>(result.get()) != nullptr) {
+        auto responseStr = messageHelper->processQueryResult(result.get()).dump();
+        MessageHandler::putToSendQueue(EndpointHandler::buildResponseStr(responseStr.size(), responseStr));
+    }
+    else if (dynamic_cast<db::query::SMSGetByIDResult *>(result.get()) != nullptr) {
+        auto responseBody = messageHelper->processQueryResult(result.get()).dump();
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(Endpoint::messages), messageHelper->getLastUUID(), responseBody));
+    }
+    else if (dynamic_cast<db::query::SMSGetByContactIDResult *>(result.get()) != nullptr) {
+        auto responseBody = messageHelper->processQueryResult(result.get());
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(Endpoint::messages), messageHelper->getLastUUID(), responseBody));
+    }
+    else if (dynamic_cast<db::query::SMSGetByTextResult *>(result.get()) != nullptr) {
+        auto responseBody = messageHelper->processQueryResult(result.get());
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(Endpoint::messages), messageHelper->getLastUUID(), responseBody));
+    }
+    else if (dynamic_cast<db::query::SMSTemplateGetByIDResult *>(result.get()) != nullptr) {
+        LOG_DEBUG("template test");
+        auto responseBody = messageHelper->processQueryResult(result.get());
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(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<short>(resp->responseTo));
 
     if (dynamic_cast<DBContactResponseMessage *>(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<short>(resp->responseTo));
+
+    if (resp->responseTo == MessageType::DBSMSGetCount) {
+
+        auto response = dynamic_cast<DBSMSResponseMessage *>(resp);
+        LOG_DEBUG("SMS count: %" PRIu32 "", response->count);
+        json11::Json body = json11::Json::object{{json::messages::count, static_cast<int>(response->count)}};
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(Endpoint::messages), messageHelper->getLastUUID(), body));
+    }
+    else if (resp->responseTo == MessageType::DBSMSGetSMSLimitOffset ||
+             resp->responseTo == MessageType::DBSMSGetSMSLimitOffsetByThreadID) {
+
+        auto response = dynamic_cast<DBSMSResponseMessage *>(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<int>(Endpoint::messages), messageHelper->getLastUUID(), recordsArray));
+    }
+    else if (resp->responseTo == MessageType::DBSMSRemove) {
+
+        LOG_DEBUG("SMS removed");
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(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<short>(resp->responseTo));
+
+    if (resp->responseTo == MessageType::DBSMSTemplateGetCount) {
+
+        auto response = dynamic_cast<DBSMSTemplateResponseMessage *>(resp);
+        LOG_DEBUG("SMS Template count: %" PRIu32 "", response->count);
+        json11::Json body = json11::Json::object{{json::messages::count, static_cast<int>(response->count)}};
+        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+            resp->retCode, static_cast<int>(Endpoint::messages), messageHelper->getLastUUID(), body));
+    }
+    else if (resp->responseTo == MessageType::DBSMSTemplateGetLimitOffset) {
+
+        auto response = dynamic_cast<DBSMSTemplateResponseMessage *>(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<int>(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<int>(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<http::Method>(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;
+}

@@ 5,8 5,10 @@
 #include "ParserUtils.hpp"
 #include "Service/Common.hpp"
 #include <service-desktop/ServiceDesktop.hpp>
+#include <string>
 #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> contactHelper;
+    static std::shared_ptr<MessageHelper> messageHelper;
 };

@@ 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;
     }

@@ 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

@@ 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 <memory>
 #include <vfs.hpp>
 #include <catch2/catch.hpp>
 #include <iostream>


@@ 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<ContactHelper>(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<MessageHelper>(nullptr);
+    auto message = std::make_unique<SMSRecord>();
+
+    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<SMSTemplateRecord>();
+
+    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<int>(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<int>(Endpoint::contacts));
-    REQUIRE(responseJson[json::body] == "");
     REQUIRE(responseJson[json::status] == static_cast<int>(http::Code::OK));
     REQUIRE(responseJson[json::uuid].dump() == "\"1234\"");
 }