33 files changed, 873 insertions(+), 614 deletions(-)

M module-db/CMakeLists.txt
M module-db/Common/Query.cpp
M module-db/Common/Query.hpp
M module-db/Interface/ContactRecord.cpp
M module-db/Interface/SMSRecord.cpp
M module-db/Interface/SMSTemplateRecord.cpp
M module-db/Interface/ThreadRecord.cpp
A module-db/queries/phonebook/QueryContactAdd.cpp
A module-db/queries/phonebook/QueryContactAdd.hpp
M module-services/service-db/api/DBServiceAPI.cpp
M module-services/service-desktop/ServiceDesktop.cpp
M module-services/service-desktop/WorkerDesktop.cpp
M module-services/service-desktop/endpoints/CMakeLists.txt
A module-services/service-desktop/endpoints/Context.hpp
M module-services/service-desktop/endpoints/DBHelper.hpp
M module-services/service-desktop/endpoints/DeviceInfo.cpp
A module-services/service-desktop/endpoints/Endpoint.hpp
A module-services/service-desktop/endpoints/EndpointFactory.hpp
D module-services/service-desktop/endpoints/Messages.hpp
R module-services/service-desktop/endpoints/{Contacts => contacts/ContactHelper}.cpp
R module-services/service-desktop/endpoints/{Contacts => contacts/ContactHelper}.hpp
A module-services/service-desktop/endpoints/contacts/ContactsEndpoint.cpp
A module-services/service-desktop/endpoints/contacts/ContactsEndpoint.hpp
R module-services/service-desktop/endpoints/{Messages => messages/MessageHelper}.cpp
A module-services/service-desktop/endpoints/messages/MessageHelper.hpp
A module-services/service-desktop/endpoints/messages/MessagesEndpoint.cpp
A module-services/service-desktop/endpoints/messages/MessagesEndpoint.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-utils/log/debug.hpp
M source/main.cpp

@@ 73,6 73,7 @@ set(SOURCES
         queries/notifications/QueryNotificationsClear.cpp
         queries/notifications/QueryNotificationsGetAll.cpp
         queries/phonebook/QueryContactGet.cpp
+        queries/phonebook/QueryContactAdd.cpp
         queries/calendar/QueryEventsRemove.cpp
         queries/calendar/QueryEventsGet.cpp
         queries/calendar/QueryEventsGetAll.cpp

@@ 1,6 1,5 @@
 #include "Query.hpp"
 #include <stdexcept>
-
 #include <memory>
 #include <utility>
 


@@ 19,6 18,12 @@ void Query::setQueryListener(QueryListener *queryListener) noexcept
     listener = queryListener;
 }
 
+void Query::setQueryListener(std::unique_ptr<EndpointListener> _listener) noexcept
+{
+    endpointListener = std::move(_listener);
+    listener         = dynamic_cast<QueryListener *>(endpointListener.get());
+}
+
 QueryResult::QueryResult(std::shared_ptr<Query> requestQuery) : requestQuery(std::move(requestQuery))
 {}
 

@@ 2,6 2,8 @@
 
 #include <memory>
 #include <string>
+#include <functional>
+#include <log/log.hpp>
 
 namespace db
 {


@@ 13,6 15,31 @@ namespace db
         virtual bool handleQueryResponse(QueryResult *) = 0;
     };
 
+    using QueryCallback = std::function<bool(db::QueryResult *, uint32_t)>;
+
+    class EndpointListener : public db::QueryListener
+    {
+      private:
+        uint32_t uuid;
+
+      public:
+        EndpointListener(QueryCallback _callback, uint32_t uuid) : uuid(uuid), callback(std::move(_callback)){};
+        EndpointListener() : callback(nullptr){};
+        ~EndpointListener() = default;
+        QueryCallback callback;
+        auto handleQueryResponse(db::QueryResult *result) -> bool override
+        {
+            if (callback != nullptr) {
+                LOG_DEBUG("Executing callback...");
+                return callback(result, uuid);
+            }
+            else {
+                LOG_ERROR("callback is nullptr!");
+                return false;
+            }
+        }
+    };
+
     /// virtual query input interface
     class Query
     {


@@ 31,6 58,7 @@ namespace db
 
         QueryListener *getQueryListener() const noexcept;
         void setQueryListener(QueryListener *queryListener) noexcept;
+        void setQueryListener(std::unique_ptr<EndpointListener> listener) noexcept;
 
         const Type type;
 


@@ 38,6 66,7 @@ namespace db
 
       private:
         QueryListener *listener = nullptr;
+        std::unique_ptr<EndpointListener> endpointListener = nullptr;
     };
 
     /// virtual query output (result) interface

@@ 1,4 1,5 @@
 #include "ContactRecord.hpp"
+#include "queries/phonebook/QueryContactAdd.hpp"
 #include <Utils.hpp>
 
 #include <queries/phonebook/QueryContactGet.hpp>


@@ 141,12 142,13 @@ std::unique_ptr<db::QueryResult> ContactRecordInterface::runQuery(std::shared_pt
     auto textFilter = dynamic_cast<const db::query::TextFilter *>(query.get());
     assert(query != nullptr);
     bool searchByNumber = false;
-    if (textFilter->isFilterPresent() && utils::is_number(textFilter->getFilterData())) {
+    if (textFilter != nullptr && textFilter->isFilterPresent() && utils::is_number(textFilter->getFilterData())) {
         searchByNumber = true;
         LOG_INFO("Filtering by number: %s", textFilter->getFilterData().c_str());
     }
 
     if (typeid(*query) == typeid(db::query::ContactGet)) {
+
         auto readQuery = static_cast<const db::query::ContactGet *>(query.get());
         LOG_DEBUG("Contact read query, filter: \"%s\", offset=%lu, limit=%lu",
                   readQuery->getFilterData().c_str(),


@@ 205,6 207,13 @@ std::unique_ptr<db::QueryResult> ContactRecordInterface::runQuery(std::shared_pt
         response->setRequestQuery(query);
         return response;
     }
+    else if (typeid(*query) == typeid(db::query::ContactAdd)) {
+        auto addQuery = static_cast<const db::query::ContactAdd *>(query.get());
+        auto ret      = ContactRecordInterface::Add(addQuery->rec);
+        auto response = std::make_unique<db::query::ContactAddResult>(ret);
+        response->setRequestQuery(query);
+        return response;
+    }
     else {
         LOG_ERROR("Unexpected query type.");
         return nullptr;

@@ 308,8 308,9 @@ std::unique_ptr<db::QueryResult> SMSRecordInterface::runQuery(std::shared_ptr<db
         record.threadID  = sms.threadID;
         record.type      = sms.type;
         record.ID        = sms.ID;
-
-        return std::make_unique<db::query::SMSGetByIDResult>(record);
+        auto response    = std::make_unique<db::query::SMSGetByIDResult>(record);
+        response->setRequestQuery(query);
+        return response;
     }
     else if (const auto localQuery = dynamic_cast<const db::query::SMSGetByContactID *>(query.get())) {
         auto smsVector = smsDB->sms.getByContactId(localQuery->contactId);


@@ 327,7 328,9 @@ std::unique_ptr<db::QueryResult> SMSRecordInterface::runQuery(std::shared_ptr<db
             recordVector.emplace_back(record);
         }
 
-        return std::make_unique<db::query::SMSGetByContactIDResult>(recordVector);
+        auto response = std::make_unique<db::query::SMSGetByContactIDResult>(recordVector);
+        response->setRequestQuery(query);
+        return response;
     }
     else if (const auto localQuery = dynamic_cast<const db::query::SMSGetByText *>(query.get())) {
         auto smsVector = smsDB->sms.getByText(localQuery->text);


@@ 345,7 348,9 @@ std::unique_ptr<db::QueryResult> SMSRecordInterface::runQuery(std::shared_ptr<db
             recordVector.emplace_back(record);
         }
 
-        return std::make_unique<db::query::SMSGetByContactIDResult>(recordVector);
+        auto response = std::make_unique<db::query::SMSGetByTextResult>(recordVector);
+        response->setRequestQuery(query);
+        return response;
     }
 
     return nullptr;

@@ 80,9 80,13 @@ std::unique_ptr<db::QueryResult> SMSTemplateRecordInterface::runQuery(std::share
     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));
+        auto response    = std::make_unique<db::query::SMSTemplateGetByIDResult>(std::move(smsTemplate));
+        response->setRequestQuery(query);
+        return response;
     }
     else {
-        return std::make_unique<db::query::SMSTemplateGetByIDResult>(SMSTemplateRecord());
+        auto response = std::make_unique<db::query::SMSTemplateGetByIDResult>(SMSTemplateRecord());
+        response->setRequestQuery(query);
+        return response;
     }
 }

@@ 138,7 138,9 @@ std::unique_ptr<db::QueryResult> ThreadRecordInterface::runQuery(std::shared_ptr
     }
 
     if (const auto local_query = dynamic_cast<const db::query::smsthread::MarkAsRead *>(query.get())) {
-        return runQueryImpl(local_query);
+        auto response = runQueryImpl(local_query);
+        response->setRequestQuery(query);
+        return response;
     }
     return nullptr;
 }

@@ 0,0 1,22 @@
+#include "QueryContactAdd.hpp"
+#include "ContactRecord.hpp"
+
+#include <string>
+
+using namespace db::query;
+
+ContactAdd::ContactAdd(const ContactRecord &rec) : Query(Query::Type::Read), rec(std::move(rec))
+{}
+
+ContactAddResult::ContactAddResult(bool result) : result(result)
+{}
+
+[[nodiscard]] auto ContactAdd::debugInfo() const -> std::string
+{
+    return "ContactAdd";
+}
+
+[[nodiscard]] auto ContactAddResult::debugInfo() const -> std::string
+{
+    return "ContactAddResult";
+}

@@ 0,0 1,35 @@
+#pragma once
+
+#include "Common/Query.hpp"
+#include <queries/RecordQuery.hpp>
+#include <queries/Filter.hpp>
+#include <Interface/ContactRecord.hpp>
+
+#include <string>
+
+namespace db::query
+{
+
+    class ContactAdd : public Query
+    {
+      public:
+        ContactAdd(const ContactRecord &rec);
+        ContactRecord rec;
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+    };
+
+    class ContactAddResult : public QueryResult
+    {
+      public:
+        ContactAddResult(bool result);
+        auto getResult() -> bool
+        {
+            return result;
+        }
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+
+      private:
+        bool result;
+    };
+
+}; // namespace db::query

@@ 363,8 363,7 @@ std::unique_ptr<std::vector<ContactRecord>> DBServiceAPI::ContactGetBySpeeddial(
 std::unique_ptr<std::vector<ContactRecord>> DBServiceAPI::ContactGetByPhoneNumber(sys::Service *serv, UTF8 phoneNumber)
 {
     ContactRecord rec;
-    utils::PhoneNumber contactNumber(phoneNumber);
-    auto number = ContactRecord::Number(contactNumber.get(), contactNumber.toE164(), ContactNumberType ::PAGER);
+    auto number = ContactRecord::Number(utils::PhoneNumber(phoneNumber).getView(), ContactNumberType ::PAGER);
     rec.numbers.push_back(number);
 
     std::shared_ptr<DBContactMessage> msg = std::make_shared<DBContactMessage>(MessageType::DBContactGetByNumber, rec);

@@ 3,6 3,7 @@
 #include "DesktopMessages.hpp"
 #include "EndpointHandler.hpp"
 #include "FactoryReset.hpp"
+#include "log/log.hpp"
 #include "messages/DBSMSMessage.hpp"
 #include "messages/DBSMSTemplateMessage.hpp"
 


@@ 88,22 89,16 @@ sys::Message_t ServiceDesktop::DataReceivedHandler(sys::DataMessage *msg, sys::R
 {
     if (resp != nullptr) {
         if (resp->responseTo == MessageType::DBQuery) {
-            EndpointHandler::handleQueryMessage(msg, resp);
-        }
-        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);
+            if (auto queryResponse = dynamic_cast<db::QueryResponse *>(resp)) {
+                auto result = queryResponse->getResult();
+
+                LOG_DEBUG("Result: %s", result->debugInfo().c_str());
+                if (result->hasListener()) {
+                    LOG_DEBUG("Handling result...");
+                    result->handle();
+                }
             }
         }
-        else {
-            LOG_DEBUG("resp->ResponseTo: %d", static_cast<short>(resp->responseTo));
-        }
     }
 
     return std::make_shared<sys::ResponseMessage>();

@@ 45,7 45,6 @@ bool WorkerDesktop::init(std::list<sys::WorkerQueueInfo> queues)
     }
 
     ParserStateMachine::MessageHandler::sendQueue = Worker::getQueueByName(WorkerDesktop::SEND_QUEUE_BUFFER_NAME);
-    EndpointHandler::initHelpers(ownerService);
 
     return true;
 }

@@ 3,6 3,8 @@ target_include_directories(${PROJECT_NAME}
 		"${CMAKE_CURRENT_LIST_DIR}"
 		"${CMAKE_CURRENT_LIST_DIR}/.."
 		"${CMAKE_CURRENT_LIST_DIR}/../messages"
+		"${CMAKE_CURRENT_LIST_DIR}/messages"
+		"${CMAKE_CURRENT_LIST_DIR}/contacts"
 )
 target_include_directories(${CMAKE_PROJECT_NAME}
     PUBLIC


@@ 12,10 14,13 @@ target_include_directories(${CMAKE_PROJECT_NAME}
 target_sources(${PROJECT_NAME}
 	PRIVATE
 		"DeviceInfo.cpp"
-		"Update.cpp"
-		"Backup.cpp"
-		"Restore.cpp"
-		"Factory.cpp"
-		"Contacts.cpp"
-		"Messages.cpp"
+		/*"Update.cpp"*/
+		/*"Backup.cpp"*/
+		/*"Restore.cpp"*/
+		/*"Factory.cpp"*/
+		"contacts/ContactHelper.cpp"
+		"contacts/ContactsEndpoint.cpp"
+		"messages/MessageHelper.cpp"
+		"messages/MessagesEndpoint.cpp"
+
 )

@@ 0,0 1,61 @@
+#pragma once
+#include "ParserUtils.hpp"
+#include "json/json11.hpp"
+
+namespace ParserStateMachine
+{
+
+    namespace json
+    {
+        const inline std::string method   = "method";
+        const inline std::string endpoint = "endpoint";
+        const inline std::string uuid     = "uuid";
+        const inline std::string status   = "status";
+        const inline std::string body     = "body";
+    } // namespace json
+
+    class Context
+    {
+      private:
+        json11::Json body;
+        EndpointType endpoint;
+        uint32_t uuid;
+        http::Method method;
+        auto validate() -> void
+        {
+            if (body.is_object() == false) {
+                body = json11::Json();
+            }
+            if (static_cast<int>(endpoint) > lastEndpoint) {
+                endpoint = EndpointType::invalid;
+            }
+        }
+
+      public:
+        Context(json11::Json &js)
+        {
+            body     = js[json::body];
+            endpoint = static_cast<EndpointType>(js[json::endpoint].int_value());
+            uuid     = js[json::uuid].int_value();
+            method   = static_cast<http::Method>(js[json::method].int_value());
+            validate();
+        }
+        auto getBody() -> json11::Json
+        {
+            return body;
+        }
+        auto getEndpoint() -> EndpointType
+        {
+            return endpoint;
+        }
+        auto getUuid() -> uint32_t
+        {
+            return uuid;
+        }
+        auto getMethod() -> http::Method
+        {
+            return method;
+        }
+    };
+
+} // namespace ParserStateMachine

@@ 1,10 1,13 @@
 #pragma once
 
+#include "Common/Query.hpp"
+#include "Context.hpp"
 #include "ParserStateMachine.hpp"
 #include "messages/QueryMessage.hpp"
 #include "queries/sms/QuerySMSSearch.hpp"
 #include <Service/Common.hpp>
 #include <Service/Service.hpp>
+#include "Endpoint.hpp"
 
 namespace ParserStateMachine
 {


@@ 12,14 15,13 @@ namespace ParserStateMachine
     class DBHelper
     {
       public:
-        virtual auto createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes  = 0;
-        virtual auto requestDataFromDB(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes = 0;
-        virtual auto updateDBEntry(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes  = 0;
-        virtual auto deleteDBEntry(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes  = 0;
+        virtual auto createDBEntry(Context &context) -> sys::ReturnCodes     = 0;
+        virtual auto requestDataFromDB(Context &context) -> sys::ReturnCodes = 0;
+        virtual auto updateDBEntry(Context &context) -> sys::ReturnCodes     = 0;
+        virtual auto deleteDBEntry(Context &context) -> sys::ReturnCodes     = 0;
 
-        virtual auto processQueryResult(db::QueryResult *result) -> json11::Json = 0;
         DBHelper(sys::Service *_ownerServicePtr) : ownerServicePtr(_ownerServicePtr){};
-
+        // virtual ~DBHelper() = default;
       protected:
         sys::Service *ownerServicePtr = nullptr;
         std::queue<uint32_t> uuidQueue;

@@ 1,4 1,5 @@
 #include "EndpointHandler.hpp"
+#include "Endpoint.hpp"
 #include <source/version.hpp>
 #include <vfs.hpp>
 #include <common_data/EventStore.hpp>


@@ 6,45 7,47 @@
 #include <service-desktop/ServiceDesktop.hpp>
 #include <string>
 
+using namespace ParserStateMachine;
+
 time_t FreeRTOS_time(time_t *pxTime)
 {
     return utils::time::Time().getTime();
 }
 
-sys::ReturnCodes EndpointHandler::deviceInfo(
-    uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService)
-{
-    if (httpMethod == static_cast<uint8_t>(ParserStateMachine::http::Method::get)) {
-        vfs::FilesystemStats fsStats = vfs.getFilesystemStats();
+// sys::ReturnCodes EndpointHandler::deviceInfo(
+//     uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService)
+// {
+//     if (httpMethod == static_cast<uint8_t>(ParserStateMachine::http::Method::get)) {
+//         vfs::FilesystemStats fsStats = vfs.getFilesystemStats();
 
-        json11::Json responseBodyJson = json11::Json::object(
-            {{ParserStateMachine::json::batteryLevel, std::to_string(Store::Battery::get().level)},
-             {ParserStateMachine::json::batteryState, std::to_string(static_cast<int>(Store::Battery::get().state))},
-             {ParserStateMachine::json::selectedSim, std::to_string(static_cast<int>(Store::GSM::get()->selected))},
-             {ParserStateMachine::json::trayState, std::to_string(static_cast<int>(Store::GSM::get()->tray))},
-             {ParserStateMachine::json::signalStrength,
-              std::to_string(static_cast<int>(Store::GSM::get()->getSignalStrength().rssiBar))},
-             {ParserStateMachine::json::fsTotal, std::to_string(fsStats.totalMbytes)},
-             {ParserStateMachine::json::fsFree, std::to_string(fsStats.freeMbytes)},
-             {ParserStateMachine::json::fsFreePercent, std::to_string(fsStats.freePercent)},
-             {ParserStateMachine::json::gitRevision, (std::string)(GIT_REV)},
-             {ParserStateMachine::json::gitTag, (std::string)GIT_TAG},
-             {ParserStateMachine::json::gitBranch, (std::string)GIT_BRANCH},
-             {ParserStateMachine::json::currentRTCTime,
-              std::to_string(static_cast<uint32_t>(utils::time::Time().getTime()))}});
+//         json11::Json responseBodyJson = json11::Json::object(
+//             {{json::batteryLevel, std::to_string(Store::Battery::get().level)},
+//              {json::batteryState, std::to_string(static_cast<int>(Store::Battery::get().state))},
+//              {json::selectedSim, std::to_string(static_cast<int>(Store::GSM::get()->selected))},
+//              {json::trayState, std::to_string(static_cast<int>(Store::GSM::get()->tray))},
+//              {json::signalStrength,
+//               std::to_string(static_cast<int>(Store::GSM::get()->getSignalStrength().rssiBar))},
+//              {json::fsTotal, std::to_string(fsStats.totalMbytes)},
+//              {json::fsFree, std::to_string(fsStats.freeMbytes)},
+//              {json::fsFreePercent, std::to_string(fsStats.freePercent)},
+//              {json::gitRevision, (std::string)(GIT_REV)},
+//              {json::gitTag, (std::string)GIT_TAG},
+//              {json::gitBranch, (std::string)GIT_BRANCH},
+//              {json::currentRTCTime,
+//               std::to_string(static_cast<uint32_t>(utils::time::Time().getTime()))}});
 
-        json11::Json responsePayloadJson = json11::Json::object(
-            {{ParserStateMachine::json::endpoint, static_cast<int>(ParserStateMachine::Endpoint::deviceInfo)},
-             {ParserStateMachine::json::status, static_cast<int>(ParserStateMachine::http::Code::OK)},
-             {ParserStateMachine::json::uuid, std::to_string(uuid)},
-             {ParserStateMachine::json::body, responseBodyJson}});
+//         json11::Json responsePayloadJson = json11::Json::object(
+//             {{json::endpoint, static_cast<int>(EndpointType::deviceInfo)},
+//              {json::status, static_cast<int>(http::Code::OK)},
+//              {json::uuid, std::to_string(uuid)},
+//              {json::body, responseBodyJson}});
 
-        responseStr = EndpointHandler::buildResponseStr(responsePayloadJson.dump().size(), responsePayloadJson.dump());
+//         responseStr = Endpoint::buildResponseStr(responsePayloadJson.dump().size(), responsePayloadJson.dump());
 
-        return sys::ReturnCodes::Success;
-    }
-    else {
-        LOG_ERROR("Incorrect method");
-        return sys::ReturnCodes::Failure;
-    }
-}
+//         return sys::ReturnCodes::Success;
+//     }
+//     else {
+//         LOG_ERROR("Incorrect method");
+//         return sys::ReturnCodes::Failure;
+//     }
+// }

@@ 0,0 1,63 @@
+#pragma once
+#include "ParserUtils.hpp"
+#include "json/json11.hpp"
+#include "Common/Query.hpp"
+#include "Context.hpp"
+#include "Service/Service.hpp"
+#include <string>
+
+namespace ParserStateMachine
+{
+
+    class Endpoint
+    {
+
+      public:
+        Endpoint(sys::Service *_ownerServicePtr) : ownerServicePtr(_ownerServicePtr){};
+        virtual ~Endpoint()                                  = default;
+        virtual auto handle(Context &context) -> std::string = 0;
+        auto c_str() -> const char *
+        {
+            return debugName.c_str();
+        }
+
+        static auto buildResponseStr(std::size_t responseSize, std::string responsePayloadString) -> std::string
+        {
+            std::string responsePayloadSizeStr = std::to_string(responseSize);
+            while (responsePayloadSizeStr.length() < message::size_length) {
+                responsePayloadSizeStr.insert(0, 1, '0');
+            }
+
+            std::string responseStr = message::endpointChar + responsePayloadSizeStr + responsePayloadString;
+            return responseStr;
+        }
+
+        static auto createSimpleResponse(sys::ReturnCodes status, int endpoint, uint32_t uuid, json11::Json body)
+            -> std::string
+        {
+            json11::Json responseJson = json11::Json::object{
+                {json::endpoint, endpoint},
+                {json::status,
+                 static_cast<int>(status == sys::ReturnCodes::Success ? http::Code::OK
+                                                                      : http::Code::InternalServerError)},
+                {json::uuid, std::to_string(uuid)},
+                {json::body, body}};
+            return Endpoint::buildResponseStr(responseJson.dump().size(), responseJson.dump());
+        }
+
+        static auto createSimpleResponse(bool status, int endpoint, uint32_t uuid, json11::Json body) -> std::string
+        {
+            json11::Json responseJson = json11::Json::object{
+                {json::endpoint, endpoint},
+                {json::status, static_cast<int>(status ? http::Code::OK : http::Code::InternalServerError)},
+                {json::uuid, std::to_string(uuid)},
+                {json::body, body}};
+
+            return Endpoint::buildResponseStr(responseJson.dump().size(), responseJson.dump());
+        }
+      protected:
+        std::string debugName;
+        sys::Service *ownerServicePtr;
+    };
+
+} // namespace ParserStateMachine

@@ 0,0 1,33 @@
+#pragma once
+
+#include "Endpoint.hpp"
+#include "Service/Service.hpp"
+#include "contacts/ContactsEndpoint.hpp"
+#include "messages/MessagesEndpoint.hpp"
+
+using namespace ParserStateMachine;
+
+class EndpointFactory
+{
+  public:
+    static auto create(Context &context, sys::Service *ownerServicePtr) -> std::unique_ptr<Endpoint>
+    {
+        LOG_DEBUG("Creating endpoint: %d", static_cast<int>(context.getEndpoint()));
+        switch (context.getEndpoint()) {
+        // case EndpointType::deviceInfo:
+        //     return std::make_unique(EndpointDeviceInfo());
+        // case EndpointType::update:
+        //     return std::make_unique(EndpointUpdate());
+        // case EndpointType::backup:
+        //     return std::make_unique(EndpointBackup());
+        // case EndpointType::restore:
+        //     return std::make_unique(EndpointRestore());
+        case EndpointType::contacts:
+            return std::make_unique<ContactsEndpoint>(ownerServicePtr);
+        case EndpointType::messages:
+            return std::make_unique<MessagesEndpoint>(ownerServicePtr);
+        default:
+            return nullptr;
+        }
+    }
+};

@@ 1,43 0,0 @@
-#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,18 1,13 @@
-#include "Contacts.hpp"
-#include "Common/Query.hpp"
 #include "ContactRecord.hpp"
+#include "ContactHelper.hpp"
+#include "Common/Query.hpp"
 #include "ParserUtils.hpp"
-#include "PhoneNumber.hpp"
-#include "Service/Common.hpp"
 #include "api/DBServiceAPI.hpp"
 #include "application-phonebook/models/NewContactModel.hpp"
 #include "log/log.hpp"
 #include "json/json11.hpp"
-#include <memory>
 #include <queries/phonebook/QueryContactGet.hpp>
-#include <service-desktop/parser/EndpointHandler.hpp>
-#include <string>
-#include <type_traits>
+#include <queries/phonebook/QueryContactAdd.hpp>
 
 using namespace ParserStateMachine;
 


@@ 41,66 36,106 @@ auto ContactHelper::to_json(ContactRecord record) -> json11::Json
     return recordEntry;
 }
 
-auto ContactHelper::from_json(json11::Json contactJSON) -> std::shared_ptr<ContactRecord>
+auto ContactHelper::from_json(json11::Json contactJSON) -> ContactRecord
 {
-    auto newRecord             = std::make_shared<ContactRecord>();
-    newRecord->primaryName     = UTF8(contactJSON[json::contacts::primaryName].string_value());
-    newRecord->alternativeName = UTF8(contactJSON[json::contacts::alternativeName].string_value());
-    newRecord->address         = UTF8(contactJSON[json::contacts::address].string_value());
+    auto newRecord            = ContactRecord();
+    newRecord.primaryName     = UTF8(contactJSON[json::contacts::primaryName].string_value());
+    newRecord.alternativeName = UTF8(contactJSON[json::contacts::alternativeName].string_value());
+    newRecord.address         = UTF8(contactJSON[json::contacts::address].string_value());
 
-    newRecord->contactType = ContactType ::USER;
+    newRecord.contactType = ContactType ::USER;
 
     for (auto num : contactJSON[json::contacts::numbers].array_items()) {
         utils::PhoneNumber phoneNumber(num.string_value());
-        auto contactNum = ContactRecord::Number(phoneNumber.get(), phoneNumber.toE164(), ContactNumberType ::PAGER);
-        newRecord->numbers.push_back(contactNum);
+        auto contactNum = ContactRecord::Number(phoneNumber.get(), phoneNumber.toE164(), ContactNumberType ::CELL);
+        newRecord.numbers.push_back(contactNum);
     }
 
-    newRecord->addToBlocked(contactJSON[json::contacts::isBlocked].bool_value());
-    newRecord->addToFavourites(contactJSON[json::contacts::isFavourite].bool_value());
+    newRecord.addToBlocked(contactJSON[json::contacts::isBlocked].bool_value());
+    newRecord.addToFavourites(contactJSON[json::contacts::isFavourite].bool_value());
     return newRecord;
 }
 
-auto ContactHelper::requestDataFromDB(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes
+auto ContactHelper::requestDataFromDB(Context &context) -> sys::ReturnCodes
 {
-    auto limit = getJSON[json::contacts::count].int_value();
-    DBServiceAPI::GetQuery(
-        ownerServicePtr, db::Interface::Name::Contact, std::make_unique<db::query::ContactGet>(0, limit, ""));
+    uuidQueue.push(context.getUuid());
+    auto limit = context.getBody()[json::contacts::count].int_value();
+    auto query = std::make_unique<db::query::ContactGet>(0, limit, "");
+
+    auto listener = std::make_unique<db::EndpointListener>(
+        [](db::QueryResult *result, uint32_t uuid) {
+            if (auto contactResult = dynamic_cast<db::query::ContactGetResult *>(result)) {
+
+                auto recordsPtr = std::make_unique<std::vector<ContactRecord>>(contactResult->getRecords());
+                json11::Json::array contactsArray;
+
+                for (auto record : *recordsPtr.get()) {
+                    contactsArray.emplace_back(ContactHelper::to_json(record));
+                }
 
-    uuidQueue.push(uuid);
+                MessageHandler::putToSendQueue(Endpoint::createSimpleResponse(
+                    true, static_cast<int>(EndpointType::contacts), uuid, contactsArray));
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+        context.getUuid());
+
+    query->setQueryListener(std::move(listener));
+
+    DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::Contact, std::move(query));
 
     return sys::ReturnCodes::Success;
 }
 
-auto ContactHelper::createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes
+auto ContactHelper::createDBEntry(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
     LOG_DEBUG("Creating %s %s ...",
-              createJSON[json::contacts::primaryName].string_value().c_str(),
-              createJSON[json::contacts::alternativeName].string_value().c_str());
+              context.getBody()[json::contacts::primaryName].string_value().c_str(),
+              context.getBody()[json::contacts::alternativeName].string_value().c_str());
 
-    auto newRecord = from_json(createJSON);
-    if (newRecord->numbers.empty()) {
+    auto newRecord = from_json(context.getBody());
+    if (newRecord.numbers.empty()) {
         LOG_ERROR("Empty number, not added!");
         return sys::ReturnCodes::Failure;
     }
 
-    DBServiceAPI::ContactAdd(ownerServicePtr, *newRecord);
+    auto query = std::make_unique<db::query::ContactAdd>(newRecord);
+
+    auto listener = std::make_unique<db::EndpointListener>(
+        [](db::QueryResult *result, uint32_t uuid) {
+            if (auto contactResult = dynamic_cast<db::query::ContactAddResult *>(result)) {
+                MessageHandler::putToSendQueue(Endpoint::createSimpleResponse(
+                    contactResult->getResult(), static_cast<int>(EndpointType::messages), uuid, json11::Json()));
+
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+        context.getUuid());
+
+    query->setQueryListener(std::move(listener));
 
+    DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::Contact, std::move(query));
     return sys::ReturnCodes::Success;
 }
 
-auto ContactHelper::requestContactByID(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes
+auto ContactHelper::requestContactByID(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
-    receivedJson    = getJSON;
-    auto id         = getJSON[json::contacts::id].int_value();
+    uuidQueue.push(context.getUuid());
+    receivedJson    = context.getBody();
+    auto id         = receivedJson[json::contacts::id].int_value();
     auto contactRec = DBServiceAPI::ContactGetByID(ownerServicePtr, id);
     return sys::ReturnCodes::Success;
 }
 
-auto ContactHelper::updateDBEntry(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes
+auto ContactHelper::updateDBEntry(Context &context) -> sys::ReturnCodes
 {
     return sys::ReturnCodes::Success;
 }


@@ 136,36 171,12 @@ auto ContactHelper::updateContact(ContactRecord contact) -> sys::ReturnCodes
 
     return ret ? sys::ReturnCodes::Success : sys::ReturnCodes::Failure;
 }
-auto ContactHelper::deleteDBEntry(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes
+auto ContactHelper::deleteDBEntry(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
-    auto id = deleteJSON[json::contacts::id].int_value();
+    auto id = context.getBody()[json::contacts::id].int_value();
     DBServiceAPI::ContactRemove(ownerServicePtr, id);
     return sys::ReturnCodes::Success;
 }
-auto ContactHelper::processQueryResult(db::QueryResult *result) -> json11::Json
-{
-
-    auto message = dynamic_cast<db::query::ContactGetResult *>(result);
-    assert(message != nullptr);
-
-    auto recordsPtr = std::make_unique<std::vector<ContactRecord>>(message->getRecords());
-    auto records    = recordsPtr.get();
-
-    json11::Json::array contactsArray;
-
-    for (auto record : *records) {
 
-        contactsArray.emplace_back(to_json(record));
-    }
-
-    json11::Json responsePayloadJson = json11::Json::object{
-        {ParserStateMachine::json::endpoint, static_cast<int>(ParserStateMachine::Endpoint::contacts)},
-        {ParserStateMachine::json::status, static_cast<int>(ParserStateMachine::http::Code::OK)},
-        {ParserStateMachine::json::uuid, std::to_string(getLastUUID())},
-        {ParserStateMachine::json::body, contactsArray}};
-
-    LOG_DEBUG("%s", responsePayloadJson.dump().c_str());
-    return responsePayloadJson;
-}

@@ 1,5 1,7 @@
 #pragma once
 
+#include "Common/Query.hpp"
+#include "Context.hpp"
 #include "Service/Service.hpp"
 #include "Service/Common.hpp"
 #include "DBHelper.hpp"


@@ 10,25 12,37 @@
 namespace ParserStateMachine
 {
 
-    class ContactHelper : DBHelper
+    class ContactHelper : public DBHelper
     {
       public:
         ContactHelper(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 createDBEntry(Context &context) -> sys::ReturnCodes override;
+        auto requestDataFromDB(Context &context) -> sys::ReturnCodes override;
+        auto updateDBEntry(Context &context) -> sys::ReturnCodes override;
+        auto deleteDBEntry(Context &context) -> sys::ReturnCodes override;
 
-        auto requestContactByID(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes;
+        auto requestContactByID(Context &context) -> sys::ReturnCodes;
         auto updateContact(ContactRecord contact) -> sys::ReturnCodes;
-        auto processQueryResult(db::QueryResult *result) -> json11::Json override;
+        auto processQueryResult(db::QueryResult *result) -> json11::Json;
         auto getLastUUID() -> uint32_t;
-        auto to_json(ContactRecord record) -> json11::Json;
-        auto from_json(json11::Json contactJSON) -> std::shared_ptr<ContactRecord>;
+        static auto to_json(ContactRecord record) -> json11::Json;
+        static auto from_json(json11::Json contactJSON) -> ContactRecord;
 
       private:
         json11::Json receivedJson;
     };
 
+    namespace json::contacts
+    {
+        const inline std::string count           = "count";
+        const inline std::string primaryName     = "priName";
+        const inline std::string alternativeName = "altName";
+        const inline std::string address         = "address";
+        const inline std::string id              = "id";
+        const inline std::string numbers         = "numbers";
+        const inline std::string isBlocked       = "blocked";
+        const inline std::string isFavourite     = "favourite";
+
+    } // namespace json::contacts
 } // namespace ParserStateMachine

@@ 0,0 1,27 @@
+#include "ContactsEndpoint.hpp"
+#include "queries/phonebook/QueryContactGet.hpp"
+#include <memory>
+#include <string>
+
+using namespace ParserStateMachine;
+
+auto ContactsEndpoint::handle(Context &context) -> std::string
+{
+
+    switch (context.getMethod()) {
+    case http::Method::get:
+        helper->requestDataFromDB(context);
+        break;
+    case http::Method::post: // update entry
+        helper->requestContactByID(context);
+        break;
+    case http::Method::put:
+        helper->createDBEntry(context);
+        break;
+    case http::Method::del:
+        helper->deleteDBEntry(context);
+        break;
+    }
+
+    return std::string();
+}

@@ 0,0 1,21 @@
+#pragma once
+
+#include "Endpoint.hpp"
+#include "Service/Service.hpp"
+#include "ContactHelper.hpp"
+
+using namespace ParserStateMachine;
+
+class ContactsEndpoint : public Endpoint
+{
+  private:
+    std::unique_ptr<ContactHelper> helper;
+
+  public:
+    ContactsEndpoint(sys::Service *_ownerServicePtr) : Endpoint(_ownerServicePtr)
+    {
+        debugName = "ContactsEndpoint";
+        helper    = std::make_unique<ContactHelper>(ownerServicePtr);
+    }
+    auto handle(Context &context) -> std::string override;
+};

@@ 1,5 1,4 @@
-#include "Messages.hpp"
-#include "BaseInterface.hpp"
+#include "MessageHelper.hpp"
 #include "Common/Query.hpp"
 #include "ParserUtils.hpp"
 #include "PhoneNumber.hpp"


@@ 8,8 7,6 @@
 #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"


@@ 19,16 16,10 @@
 #include "utf8/UTF8.hpp"
 #include "json/json11.hpp"
 #include <memory>
+#include <string>
 
 using namespace ParserStateMachine;
 
-auto MessageHelper::getLastUUID() -> uint32_t
-{
-    auto uuid = uuidQueue.front();
-    uuidQueue.pop();
-    return uuid;
-}
-
 auto MessageHelper::to_json(SMSRecord record) -> json11::Json
 {
 


@@ 75,200 66,240 @@ auto MessageHelper::from_json(json11::Json msgJson) -> SMSTemplateRecord
     return record;
 }
 
-auto MessageHelper::requestDataFromDB(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::requestDataFromDB(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
-    if (getJSON[json::messages::msgTemplate].bool_value() == true) {
-        return requestTemplate(getJSON, uuid);
+    if (context.getBody()[json::messages::msgTemplate].bool_value() == true) {
+        return requestTemplate(context);
     }
     else {
-        return requestSMS(getJSON, uuid);
+        return requestSMS(context);
     }
 }
 
-auto MessageHelper::requestSMS(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::requestSMS(Context &context) -> sys::ReturnCodes
 {
-    if (getJSON[json::messages::count].bool_value() == true) // get messages count
+    if (context.getBody()[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());
+    else if (context.getBody()[json::messages::id].int_value() != 0) { // messages search
+
+        auto query = std::make_unique<db::query::SMSGetByID>(context.getBody()[json::messages::id].int_value());
+
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, uint32_t uuid) {
+                if (auto SMSResult = dynamic_cast<db::query::SMSGetByIDResult *>(result)) {
+                    auto body = MessageHelper::to_json(SMSResult->getResults());
+                    MessageHandler::putToSendQueue(
+                        Endpoint::createSimpleResponse(true, static_cast<int>(EndpointType::messages), uuid, body));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context.getUuid());
+
+        query->setQueryListener(std::move(listener));
         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());
+    else if (context.getBody()[json::messages::contactID].int_value() != 0) {
+
+        auto query =
+            std::make_unique<db::query::SMSGetByContactID>(context.getBody()[json::messages::contactID].int_value());
+
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, uint32_t uuid) {
+                if (auto SMSResult = dynamic_cast<db::query::SMSGetByContactIDResult *>(result)) {
+
+                    json11::Json::array SMSarray;
+                    for (auto record : SMSResult->getResults()) {
+                        SMSarray.emplace_back(to_json(record));
+                    }
+
+                    MessageHandler::putToSendQueue(
+                        Endpoint::createSimpleResponse(true, static_cast<int>(EndpointType::messages), uuid, SMSarray));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context.getUuid());
+
+        query->setQueryListener(std::move(listener));
         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());
+    else if (context.getBody()[json::messages::messageBody].string_value().empty() == false) {
+        auto query =
+            std::make_unique<db::query::SMSGetByText>(context.getBody()[json::messages::messageBody].string_value());
+
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, uint32_t uuid) {
+                if (auto SMSResult = dynamic_cast<db::query::SMSGetByTextResult *>(result)) {
+
+                    json11::Json::array SMSarray;
+                    for (auto record : SMSResult->getResults()) {
+                        SMSarray.emplace_back(to_json(record));
+                    }
+
+                    MessageHandler::putToSendQueue(
+                        Endpoint::createSimpleResponse(true, static_cast<int>(EndpointType::messages), uuid, SMSarray));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context.getUuid());
+
+        query->setQueryListener(std::move(listener));
         DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query));
     }
     else // get messages
     {
-        DBServiceAPI::SMSGetLimitOffset(ownerServicePtr, 0, getJSON[json::messages::count].int_value());
+        DBServiceAPI::SMSGetLimitOffset(ownerServicePtr, 0, context.getBody()[json::messages::count].int_value());
     }
 
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::requestTemplate(json11::Json getJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::requestTemplate(Context &context) -> sys::ReturnCodes
 {
-    if (getJSON[json::messages::count].bool_value() == true) // get templates count
+    if (context.getBody()[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());
+    else if (context.getBody()[json::messages::id].int_value() != 0) { // templates search
+        auto query = std::make_unique<db::query::SMSTemplateGetByID>(context.getBody()[json::messages::id].int_value());
+
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, uint32_t uuid) {
+                if (auto SMSTemplateResult = dynamic_cast<db::query::SMSTemplateGetByIDResult *>(result)) {
+                    auto body = MessageHelper::to_json(SMSTemplateResult->getResults());
+                    MessageHandler::putToSendQueue(
+                        Endpoint::createSimpleResponse(true, static_cast<int>(EndpointType::messages), uuid, body));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context.getUuid());
+
+        query->setQueryListener(std::move(listener));
         DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMSTemplate, std::move(query));
     }
     else // get messages
     {
-        DBServiceAPI::SMSTemplateGetLimitOffset(ownerServicePtr, 0, getJSON[json::messages::count].int_value());
+        DBServiceAPI::SMSTemplateGetLimitOffset(
+            ownerServicePtr, 0, context.getBody()[json::messages::count].int_value());
     }
 
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::createDBEntry(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::createDBEntry(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
-    if (createJSON[json::messages::msgTemplate].bool_value() == true) {
-        return createTemplate(createJSON, uuid);
+    if (context.getBody()[json::messages::msgTemplate].bool_value() == true) {
+        return createTemplate(context);
     }
     else {
-        return createSMS(createJSON, uuid);
+        return createSMS(context);
     }
 }
 
-auto MessageHelper::createTemplate(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::createTemplate(Context &context) -> sys::ReturnCodes
 {
-    SMSTemplateRecord record = from_json(createJSON);
+    SMSTemplateRecord record = from_json(context.getBody());
 
     DBServiceAPI::SMSTemplateAdd(ownerServicePtr, record);
 
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::createSMS(json11::Json createJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::createSMS(Context &context) -> sys::ReturnCodes
 {
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::deleteDBEntry(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::deleteDBEntry(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
-    if (deleteJSON[json::messages::msgTemplate].bool_value() == true) {
-        return deleteTemplate(deleteJSON, uuid);
+    if (context.getBody()[json::messages::msgTemplate].bool_value() == true) {
+        return deleteTemplate(context);
     }
     else {
-        return deleteSMS(deleteJSON, uuid);
+        return deleteSMS(context);
     }
 }
 
-auto MessageHelper::deleteSMS(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::deleteSMS(Context &context) -> sys::ReturnCodes
 {
     auto record = std::make_unique<SMSRecord>();
-    record->ID  = deleteJSON[json::messages::id].int_value();
+    record->ID  = context.getBody()[json::messages::id].int_value();
     DBServiceAPI::SMSRemove(ownerServicePtr, *record);
 
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::deleteTemplate(json11::Json deleteJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::deleteTemplate(Context &context) -> sys::ReturnCodes
 {
-    DBServiceAPI::SMSTemplateRemove(ownerServicePtr, deleteJSON[json::messages::id].int_value());
+    DBServiceAPI::SMSTemplateRemove(ownerServicePtr, context.getBody()[json::messages::id].int_value());
     return sys::ReturnCodes::Success;
 }
 
-auto MessageHelper::updateDBEntry(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::updateDBEntry(Context &context) -> sys::ReturnCodes
 {
-    uuidQueue.push(uuid);
+    uuidQueue.push(context.getUuid());
 
-    if (updateJSON[json::messages::msgTemplate].bool_value() == true) {
-        return updateTemplate(updateJSON, uuid);
+    if (context.getBody()[json::messages::msgTemplate].bool_value() == true) {
+        return updateTemplate(context);
     }
     else {
-        return updateSMS(updateJSON, uuid);
+        return updateSMS(context);
     }
 }
 
-auto MessageHelper::updateSMS(json11::Json updateJSON, uint32_t uuid) -> sys::ReturnCodes
+auto MessageHelper::updateSMS(Context &context) -> 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());
+        context.getBody()[json::messages::threadID].int_value(),
+        (context.getBody()[json::messages::isUnread].bool_value() ? MarkAsRead::Read::False : MarkAsRead::Read::True));
+
+    auto listener = std::make_unique<db::EndpointListener>(
+        [=](db::QueryResult *result, uint32_t uuid) {
+            if (auto SMSResult = dynamic_cast<db::query::smsthread::MarkAsReadResult *>(result)) {
+                MessageHandler::putToSendQueue(Endpoint::createSimpleResponse(
+                    SMSResult->getResult(), static_cast<int>(EndpointType::messages), uuid, json11::Json()));
+
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+        context.getUuid());
+
+    query->setQueryListener(std::move(listener));
 
     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
+auto MessageHelper::updateTemplate(Context &context) -> sys::ReturnCodes
 {
     SMSTemplateRecord record;
-    record.ID   = updateJSON[json::messages::id].int_value();
-    record.text = updateJSON[json::messages::templateText].string_value();
+    record.ID   = context.getBody()[json::messages::id].int_value();
+    record.text = context.getBody()[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,70 @@
+#pragma once
+
+#include "Common/Query.hpp"
+#include "SMSTemplateRecord.hpp"
+#include "Service/Service.hpp"
+#include "Service/Common.hpp"
+#include "DBHelper.hpp"
+#include <memory>
+#include <service-db/api/DBServiceAPI.hpp>
+#include "Endpoint.hpp"
+
+namespace ParserStateMachine
+{
+
+    class MessageHelper final : public DBHelper
+    {
+      public:
+        MessageHelper(sys::Service *_ownerServicePtr) : DBHelper(_ownerServicePtr){};
+
+        auto createDBEntry(Context &context) -> sys::ReturnCodes override;
+        auto requestDataFromDB(Context &context) -> sys::ReturnCodes override;
+        auto updateDBEntry(Context &context) -> sys::ReturnCodes override;
+        auto deleteDBEntry(Context &context) -> sys::ReturnCodes override;
+
+        auto createTemplate(Context &context) -> sys::ReturnCodes;
+        auto requestTemplate(Context &context) -> sys::ReturnCodes;
+        auto updateTemplate(Context &context) -> sys::ReturnCodes;
+        auto deleteTemplate(Context &context) -> sys::ReturnCodes;
+
+        auto createSMS(Context &context) -> sys::ReturnCodes;
+        auto requestSMS(Context &context) -> sys::ReturnCodes;
+        auto updateSMS(Context &context) -> sys::ReturnCodes;
+        auto deleteSMS(Context &context) -> sys::ReturnCodes;
+
+        auto requestMessagesCount(Context &context) -> sys::ReturnCodes;
+
+        static auto to_json(SMSRecord record) -> json11::Json;
+        static auto to_json(ThreadRecord record) -> json11::Json;
+        static auto to_json(SMSTemplateRecord record) -> json11::Json;
+        static auto from_json(json11::Json msgJson) -> SMSTemplateRecord;
+
+      private:
+        json11::Json receivedJson;
+    };
+
+    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 ParserStateMachine

@@ 0,0 1,30 @@
+
+#include "MessagesEndpoint.hpp"
+#include "queries/sms/QuerySMSGetByID.hpp"
+#include "queries/sms/QuerySMSGetByContactID.hpp"
+#include "queries/sms/QuerySMSGetByText.hpp"
+#include "queries/sms/QuerySMSTemplateGetByID.hpp"
+#include <memory>
+#include <string>
+
+using namespace ParserStateMachine;
+
+auto MessagesEndpoint::handle(Context &context) -> std::string
+{
+
+    switch (context.getMethod()) {
+    case http::Method::get:
+        helper->requestDataFromDB(context);
+        break;
+    case http::Method::post: // update entry
+        helper->updateDBEntry(context);
+        break;
+    case http::Method::put:
+        helper->createDBEntry(context);
+        break;
+    case http::Method::del:
+        helper->deleteDBEntry(context);
+        break;
+    }
+    return std::string();
+}

@@ 0,0 1,21 @@
+#pragma once
+
+#include "Endpoint.hpp"
+#include "Service/Service.hpp"
+#include "MessageHelper.hpp"
+
+using namespace ParserStateMachine;
+
+class MessagesEndpoint : public Endpoint
+{
+  private:
+    std::shared_ptr<MessageHelper> helper;
+
+  public:
+    MessagesEndpoint(sys::Service *_ownerServicePtr) : Endpoint(_ownerServicePtr)
+    {
+        debugName = "MessagesEndpoint";
+        helper    = std::make_shared<MessageHelper>(ownerServicePtr);
+    }
+    auto handle(Context &context) -> std::string override;
+};

@@ 1,6 1,4 @@
 #include "EndpointHandler.hpp"
-#include "Contacts.hpp"
-#include "Messages.hpp"
 #include "ParserUtils.hpp"
 #include "SMSRecord.hpp"
 #include "Service/Common.hpp"


@@ 9,6 7,7 @@
 #include "messages/DBContactMessage.hpp"
 #include "messages/DBSMSMessage.hpp"
 #include "messages/DBSMSTemplateMessage.hpp"
+#include "messages/MessageHelper.hpp"
 #include "messages/QueryMessage.hpp"
 #include "queries/phonebook/QueryContactGet.hpp"
 #include "queries/sms/QuerySMSGetByID.hpp"


@@ 22,242 21,103 @@
 
 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)
-{
-    std::string responsePayloadSizeStr = std::to_string(responseSize);
-    while (responsePayloadSizeStr.length() < message::size_length) {
-        responsePayloadSizeStr.insert(0, 1, '0');
-    }
-
-    std::string responseStr = message::endpointChar + responsePayloadSizeStr + responsePayloadString;
-    return responseStr;
-}
-
-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, body}};
-    return EndpointHandler::buildResponseStr(responseJson.dump().size(), responseJson.dump());
-}
-
-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, 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)
-{
-    LOG_DEBUG("received data from DB");
-    LOG_DEBUG("sender: %s", resp->sender.c_str());
-
-    auto queryResponse = dynamic_cast<db::QueryResponse *>(resp);
-    if (queryResponse == nullptr) {
-        LOG_ERROR("Unexpected message.");
-        return sys::ReturnCodes::Failure;
-    }
-    LOG_DEBUG("respTo: %d", static_cast<short>(queryResponse->responseTo));
-
-    auto result = queryResponse->getResult();
-    LOG_DEBUG("result: %s", result->debugInfo().c_str());
-
-    if (dynamic_cast<db::query::ContactGetResult *>(result.get()) != nullptr) {
-        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", static_cast<short>(resp->responseTo));
-
-    if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
-        resp->responseTo == MessageType::DBContactGetByID) {
-
-        auto status = contactHelper->updateContact(dynamic_cast<DBContactResponseMessage *>(resp)->records->front());
-        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
-            status, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
-    }
-    else if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
-             resp->responseTo == MessageType::DBContactAdd) {
-
-        LOG_DEBUG("Contact added! ret: %d", (resp->retCode == sys::ReturnCodes::Success ? 1 : 0));
-        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
-            resp->retCode, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
-    }
-    else if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
-             resp->responseTo == MessageType::DBContactRemove) {
-
-        LOG_DEBUG("Contact removed! ret: %d", (resp->retCode == sys::ReturnCodes::Success ? 1 : 0));
-        MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
-            resp->retCode, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
-    }
-
-    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)
-{
-    // process contact request
-
-    switch (static_cast<http::Method>(httpMethod)) {
-    case http::Method::get:
-        contactHelper->requestDataFromDB(body, uuid);
-        break;
-    case http::Method::post: // update entry
-        contactHelper->requestContactByID(body, uuid);
-        break;
-    case http::Method::put:
-        contactHelper->createDBEntry(body, uuid);
-        break;
-    case http::Method::del:
-        contactHelper->deleteDBEntry(body, uuid);
-        break;
-    }
-
-    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;
-}
+// sys::ReturnCodes EndpointHandler::handleContactsMessage(sys::DataMessage *msg, sys::ResponseMessage *resp)
+// {
+//     LOG_DEBUG("resp->ResponseTo: %d", static_cast<short>(resp->responseTo));
+
+//     if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
+//         resp->responseTo == MessageType::DBContactGetByID) {
+
+//         auto status = contactHelper->updateContact(dynamic_cast<DBContactResponseMessage *>(resp)->records->front());
+//         MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+//             status, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
+//     }
+//     else if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
+//              resp->responseTo == MessageType::DBContactAdd) {
+
+//         LOG_DEBUG("Contact added! ret: %d", (resp->retCode == sys::ReturnCodes::Success ? 1 : 0));
+//         MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+//             resp->retCode, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
+//     }
+//     else if (dynamic_cast<DBContactResponseMessage *>(resp) != nullptr &&
+//              resp->responseTo == MessageType::DBContactRemove) {
+
+//         LOG_DEBUG("Contact removed! ret: %d", (resp->retCode == sys::ReturnCodes::Success ? 1 : 0));
+//         MessageHandler::putToSendQueue(EndpointHandler::createSimpleResponse(
+//             resp->retCode, static_cast<int>(Endpoint::contacts), contactHelper->getLastUUID()));
+//     }
+
+//     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;
+// }

@@ 7,8 7,6 @@
 #include <service-desktop/ServiceDesktop.hpp>
 #include <string>
 #include "DBHelper.hpp"
-#include "Contacts.hpp"
-#include "Messages.hpp"
 #include "queries/phonebook/QueryContactGet.hpp"
 
 using namespace ParserStateMachine;


@@ 24,16 22,7 @@ class EndpointHandler
     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,
-                                            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(
         uint8_t httpMethod, uint32_t uuid, json11::Json &body, std::string &responseStr, sys::Service *ownerService);
     static sys::ReturnCodes deviceInfo(


@@ 50,6 39,4 @@ class EndpointHandler
         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;
 };

@@ 1,8 1,9 @@
 #include "MessageHandler.hpp"
-#include "Contacts.hpp"
-#include "EndpointHandler.hpp"
+#include "Context.hpp"
+#include "EndpointFactory.hpp"
 #include "log/log.hpp"
 #include "ParserUtils.hpp"
+#include <memory>
 
 using namespace ParserStateMachine;
 


@@ 20,47 21,21 @@ MessageHandler::MessageHandler(std::string &message, sys::Service *OwnerService)
 
 void MessageHandler::processMessage()
 {
-    auto body          = messageJson[json::body];
-    int endpoint       = messageJson[json::endpoint].number_value();
-    unsigned long uuid = messageJson[json::uuid].number_value();
-    int method         = messageJson[json::method].number_value();
+    Context context(messageJson);
 
-    LOG_DEBUG(
-        "[MsgHandler]\nmethod: %d\nendpoint: %d\nuuid: %lu\nbody: %s\n", method, endpoint, uuid, body.dump().c_str());
+    LOG_DEBUG("[MsgHandler]\nmethod: %d\nendpoint: %d\nuuid: %" PRIu32 "\nbody: %s\n",
+              static_cast<int>(context.getMethod()),
+              static_cast<int>(context.getEndpoint()),
+              context.getUuid(),
+              context.getBody().dump().c_str());
 
-    std::string responseStr;
+    auto handler = EndpointFactory::create(context, OwnerServicePtr);
 
-    switch (static_cast<Endpoint>(endpoint)) {
-    case Endpoint::deviceInfo:
-        EndpointHandler::deviceInfo(method, uuid, body, responseStr, OwnerServicePtr);
-        LOG_DEBUG("[ENDPOINT] DeviceInfo: %s", responseStr.c_str());
-        putToSendQueue(responseStr);
-        break;
-    case Endpoint::update:
-        EndpointHandler::update(method, uuid, body, responseStr, OwnerServicePtr);
-        LOG_DEBUG("[ENDPOINT] Update: %s", responseStr.c_str());
-        putToSendQueue(responseStr);
-        break;
-    case Endpoint::backup:
-        EndpointHandler::backup(method, uuid, body, responseStr, OwnerServicePtr);
-        LOG_DEBUG("[ENDPOINT] Backup: %s", responseStr.c_str());
-        putToSendQueue(responseStr);
-        break;
-    case Endpoint::restore:
-        EndpointHandler::restore(method, uuid, body, responseStr, OwnerServicePtr);
-        LOG_DEBUG("[ENDPOINT] Restore: %s", responseStr.c_str());
-        putToSendQueue(responseStr);
-        break;
-    case Endpoint::contacts:
-        EndpointHandler::contacts(method, uuid, body, responseStr, OwnerServicePtr);
-        break;
-    case Endpoint::messages:
-        EndpointHandler::messages(method, uuid, body, responseStr, OwnerServicePtr);
-
-        break;
-
-    default:
-        break;
+    if (handler != nullptr) {
+        handler->handle(context);
+    }
+    else {
+        LOG_ERROR("No way to handle!");
     }
 }
 

@@ 8,8 8,9 @@ namespace ParserStateMachine
 {
 
     // Endpoint type definition
-    enum class Endpoint
+    enum class EndpointType
     {
+        invalid    = 0,
         deviceInfo = 1,
         update,
         backup,


@@ 19,6 20,7 @@ namespace ParserStateMachine
         messages
     };
 
+    constexpr int lastEndpoint = static_cast<int>(EndpointType::messages);
     // Message defs and utils
     namespace message
     {


@@ 88,12 90,6 @@ namespace ParserStateMachine
 
     namespace json
     {
-        const inline std::string method   = "method";
-        const inline std::string endpoint = "endpoint";
-        const inline std::string uuid     = "uuid";
-        const inline std::string status   = "status";
-        const inline std::string body     = "body";
-
         const inline std::string batteryLevel   = "batteryLevel";
         const inline std::string batteryState   = "batteryState";
         const inline std::string selectedSim    = "selectedSim";


@@ 114,19 110,6 @@ namespace ParserStateMachine
         const inline std::string restoreRequest = "restoreRequest";
         const inline std::string factoryRequest = "factoryRequest";
 
-        namespace contacts
-        {
-            const inline std::string count           = "count";
-            const inline std::string primaryName     = "priName";
-            const inline std::string alternativeName = "altName";
-            const inline std::string address         = "address";
-            const inline std::string id              = "id";
-            const inline std::string numbers         = "numbers";
-            const inline std::string isBlocked       = "blocked";
-            const inline std::string isFavourite     = "favourite";
-
-        } // namespace contacts
-
         namespace messages
         {
             const inline std::string id           = "id";

@@ 4,7 4,7 @@
 #define DEBUG_SCOPED_TIMINGS         1 /// show timings in measured functions
 #define _RT1051_UART_DEBUG           0 /// show full modem uart communication
 #define DEBUG_MODEM_OUTPUT_RESPONSE  1 /// show full modem output
-#define DEBUG_SERVICE_MESSAGES       0 /// show messages prior to handling in service
+#define DEBUG_SERVICE_MESSAGES       1 /// show messages prior to handling in service
 #define DEBUG_DB_MODEL_DATA          0 /// show messages prior to handling in service
 #define DEBUG_FONT                   0 /// show Font debug messages
 #define DEBUG_GUI_TEXT               0 /// show basic debug messages for gui::Text - warning this can be hard on cpu

@@ 185,7 185,7 @@ int main()
         ret |= sys::SystemManager::CreateService(std::make_shared<ServiceAudio>(), sysmgr.get());
 
         // Service Desktop disabled on master - pulling read on usb driver
-        // ret |= sys::SystemManager::CreateService(std::make_shared<ServiceDesktop>(), sysmgr.get());
+        ret |= sys::SystemManager::CreateService(std::make_shared<ServiceDesktop>(), sysmgr.get());
 
         // vector with launchers to applications
         std::vector<std::unique_ptr<app::ApplicationLauncher>> applications;