13 files changed, 176 insertions(+), 24 deletions(-)

M changelog.md
M module-db/CMakeLists.txt
M module-db/Interface/SMSRecord.cpp
M module-db/Interface/SMSRecord.hpp
M module-db/Tables/SMSTable.cpp
M module-db/Tables/SMSTable.hpp
A module-db/queries/sms/QuerySMSGetByThreadID.cpp
A module-db/queries/sms/QuerySMSGetByThreadID.hpp
M module-services/service-desktop/endpoints/EndpointFactory.hpp
M module-services/service-desktop/endpoints/backup/BackupEndpoint.cpp
M module-services/service-desktop/endpoints/messages/MessageHelper.cpp
M module-services/service-desktop/endpoints/update/UpdateEndpoint.cpp
M module-services/service-desktop/tests/unittest.cpp

@@ 1,5 1,20 @@
 # Mudita PurePhone changelog
 
+## [Current release]
+
+### Added
+
+### Changed
+
+### Fixed
+
+* `[desktopApp]` Fixed endpoint handling.
+
+### Other
+* `[desktopApp]` Added functional tests.
+
+
+
 ## [0.36.1 2020-09-04]
 
 ### Added

@@ 67,6 67,7 @@ set(SOURCES
         queries/sms/QuerySMSGetCount.cpp
         queries/sms/QuerySMSGetByID.cpp
         queries/sms/QuerySMSGetByContactID.cpp
+        queries/sms/QuerySMSGetByThreadID.cpp
         queries/sms/QuerySMSGetByText.cpp
         queries/sms/QuerySMSRemove.cpp
         queries/sms/QuerySMSTemplateAdd.cpp

@@ 14,6 14,7 @@
 
 #include <PhoneNumber.hpp>
 #include <optional>
+#include <module-db/queries/sms/QuerySMSGetByThreadID.hpp>
 
 SMSRecord::SMSRecord(const SMSTableRow &w, const utils::PhoneNumber::View &num)
     : date(w.date), dateSent(w.dateSent), errorCode(w.errorCode), body(w.body), type(w.type), threadID(w.threadID),


@@ 305,6 306,9 @@ std::unique_ptr<db::QueryResult> SMSRecordInterface::runQuery(std::shared_ptr<db
     else if (typeid(*query) == typeid(db::query::SMSGetByContactID)) {
         return getByContactIDQuery(query);
     }
+    else if (typeid(*query) == typeid(db::query::SMSGetByThreadID)) {
+        return getByThreadIDQuery(query);
+    }
     else if (typeid(*query) == typeid(db::query::SMSGetByText)) {
         return getByTextQuery(query);
     }


@@ 440,3 444,25 @@ std::unique_ptr<db::QueryResult> SMSRecordInterface::getQuery(std::shared_ptr<db
     response->setRequestQuery(query);
     return response;
 }
+std::unique_ptr<db::QueryResult> SMSRecordInterface::getByThreadIDQuery(std::shared_ptr<db::Query> query)
+{
+    const auto localQuery = static_cast<const db::query::SMSGetByThreadID *>(query.get());
+    auto smsVector        = smsDB->sms.getByThreadId(localQuery->threadId);
+    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);
+    }
+
+    auto response = std::make_unique<db::query::SMSGetByThreadIDResult>(recordVector);
+    response->setRequestQuery(query);
+    return response;
+}

@@ 71,4 71,5 @@ class SMSRecordInterface : public RecordInterface<SMSRecord, SMSRecordField>
     std::unique_ptr<db::QueryResult> getCountQuery(std::shared_ptr<db::Query> query);
     std::unique_ptr<db::QueryResult> removeQuery(std::shared_ptr<db::Query> query);
     std::unique_ptr<db::QueryResult> getQuery(std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::QueryResult> getByThreadIDQuery(std::shared_ptr<db::Query> query);
 };

@@ 107,6 107,31 @@ std::vector<SMSTableRow> SMSTable::getByContactId(uint32_t contactId)
 
     return ret;
 }
+std::vector<SMSTableRow> SMSTable::getByThreadId(uint32_t threadId)
+{
+    auto retQuery = db->query("SELECT * FROM sms WHERE thread_id= %u;", threadId);
+
+    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)
 {

@@ 46,6 46,7 @@ class SMSTable : public Table<SMSTableRow, SMSTableFields>
     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::vector<SMSTableRow> getByThreadId(uint32_t threadId);
 
     std::pair<uint32_t, std::vector<SMSTableRow>> getManyByType(SMSType type, uint32_t offset, uint32_t limit);
 

@@ 0,0 1,24 @@
+#include "QuerySMSGetByThreadID.hpp"
+
+namespace db::query
+{
+    SMSGetByThreadID::SMSGetByThreadID(unsigned int threadId) : Query(Query::Type::Read), threadId(threadId)
+    {}
+
+    auto SMSGetByThreadID::debugInfo() const -> std::string
+    {
+        return "SMSGetByThreadID";
+    }
+
+    SMSGetByThreadIDResult::SMSGetByThreadIDResult(std::vector<SMSRecord> result) : result(std::move(result))
+    {}
+    auto SMSGetByThreadIDResult::getResults() const -> std::vector<SMSRecord>
+    {
+        return result;
+    }
+    auto SMSGetByThreadIDResult::debugInfo() const -> std::string
+    {
+        return "SMSGetByThreadIDResult";
+    }
+
+} // 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
+{
+
+    class SMSGetByThreadID : public Query
+    {
+      public:
+        SMSGetByThreadID(unsigned int id);
+        unsigned int threadId;
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+    };
+
+    class SMSGetByThreadIDResult : public QueryResult
+    {
+        std::vector<SMSRecord> result;
+
+      public:
+        SMSGetByThreadIDResult(std::vector<SMSRecord> result);
+        [[nodiscard]] auto getResults() const -> std::vector<SMSRecord>;
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+    };
+
+} // namespace db::query

@@ 8,6 8,7 @@
 #include "deviceInfo/DeviceInfoEndpoint.hpp"
 #include "update/UpdateEndpoint.hpp"
 #include "restore/RestoreEndpoint.hpp"
+#include "factoryReset/FactoryResetEndpoint.hpp"
 
 using namespace parserFSM;
 


@@ 30,6 31,8 @@ class EndpointFactory
             return std::make_unique<ContactsEndpoint>(ownerServicePtr);
         case EndpointType::messages:
             return std::make_unique<MessagesEndpoint>(ownerServicePtr);
+        case EndpointType::factory:
+            return std::make_unique<FactoryResetEndpoint>(ownerServicePtr);
         default:
             return nullptr;
         }

@@ 8,10 8,10 @@ static bool backupReady = false;
 auto BackupEndpoint::handle(Context &context) -> void
 {
     switch (context.getMethod()) {
-    case http::Method::get:
+    case http::Method::post:
         upload(context);
         break;
-    case http::Method::post:
+    case http::Method::get:
         request(context);
         break;
     case http::Method::put:


@@ 25,8 25,10 @@ auto BackupEndpoint::handle(Context &context) -> void
 auto BackupEndpoint::request(Context &context) -> sys::ReturnCodes
 {
     json11::Json responseBodyJson;
-
-    if (context.getBody()[json::backupRequest] == true) {
+    if (context.getBody()[json::backupReady] == true) {
+        context.setResponseBody(json11::Json::object({{json::backupReady, backupReady}}));
+    }
+    else if (context.getBody()[json::backupRequest] == true) {
         auto msg = std::make_shared<sdesktop::BackupMessage>();
         sys::Bus::SendUnicast(msg, service::name::service_desktop, ownerServicePtr);
         backupReady = true;


@@ 44,12 46,7 @@ auto BackupEndpoint::request(Context &context) -> sys::ReturnCodes
 
 auto BackupEndpoint::upload(Context &context) -> sys::ReturnCodes
 {
-    json11::Json responseBodyJson;
-
-    if (context.getBody()[json::backupReady] == true) {
-        responseBodyJson = json11::Json::object({{json::backupReady, backupReady}});
-    }
-    else if (context.getBody()[json::backupUpload] == true) {
+    if (context.getBody()[json::backupUpload] == true) {
         if (vfs.fileExists(purefs::dir::os_backup.c_str())) {
             context.setResponseBody(json11::Json::object({{json::backupUpload, true}}));
         }

@@ 9,6 9,7 @@
 #include "api/DBServiceAPI.hpp"
 #include "queries/sms/QuerySMSGet.hpp"
 #include "queries/sms/QuerySMSGetByContactID.hpp"
+#include "queries/sms/QuerySMSGetByThreadID.hpp"
 #include "queries/sms/QuerySMSGetByID.hpp"
 #include "queries/sms/QuerySMSGetByText.hpp"
 #include "queries/sms/QuerySMSGetCount.hpp"


@@ 157,6 158,33 @@ auto MessageHelper::requestSMS(Context &context) -> sys::ReturnCodes
         query->setQueryListener(std::move(listener));
         DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query));
     }
+    else if (context.getBody()[json::messages::threadID].int_value() != 0) {
+
+        auto query =
+            std::make_unique<db::query::SMSGetByThreadID>(context.getBody()[json::messages::threadID].int_value());
+
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, Context context) {
+                if (auto SMSResult = dynamic_cast<db::query::SMSGetByThreadIDResult *>(result)) {
+
+                    json11::Json::array SMSarray;
+                    for (auto record : SMSResult->getResults()) {
+                        SMSarray.emplace_back(MessageHelper::to_json(record));
+                    }
+
+                    context.setResponseBody(SMSarray);
+                    MessageHandler::putToSendQueue(context.createSimpleResponse());
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context);
+
+        query->setQueryListener(std::move(listener));
+        DBServiceAPI::GetQuery(ownerServicePtr, db::Interface::Name::SMS, std::move(query));
+    }
     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());

@@ 20,15 20,22 @@ auto UpdateEndpoint::handle(Context &context) -> void
 auto UpdateEndpoint::run(Context &context) -> sys::ReturnCodes
 {
     std::string fileName = context.getBody()["fileName"].string_value();
-
-    context.setResponseBody(json11::Json::object({{parserFSM::json::updateReady, true}}));
-
-    MessageHandler::putToSendQueue(context.createSimpleResponse());
-
-    auto msg = std::make_shared<sdesktop::UpdateOsMessage>(fileName, context.getUuid());
-    sys::Bus::SendUnicast(msg, service::name::service_desktop, ownerServicePtr);
-
-    return sys::ReturnCodes::Success;
+    auto path            = purefs::dir::os_updates / fileName;
+    auto fileExists      = vfs.fileExists(path.c_str());
+    if (fileExists) {
+        context.setResponseBody(json11::Json::object({{parserFSM::json::updateReady, true}}));
+
+        auto msg = std::make_shared<sdesktop::UpdateOsMessage>(fileName, context.getUuid());
+        sys::Bus::SendUnicast(msg, service::name::service_desktop, ownerServicePtr);
+        MessageHandler::putToSendQueue(context.createSimpleResponse());
+        return sys::ReturnCodes::Success;
+    }
+    else {
+        context.setResponseBody(json11::Json::object({{parserFSM::json::updateReady, false}}));
+        context.setResponseStatus(http::Code::InternalServerError);
+        MessageHandler::putToSendQueue(context.createSimpleResponse());
+        return sys::ReturnCodes::Failure;
+    }
 }
 
 auto UpdateEndpoint::getUpdates(Context &context) -> sys::ReturnCodes

@@ 1,23 1,18 @@
 #include "Common/Common.hpp"
 #include "ContactRecord.hpp"
-#include "Endpoint.hpp"
-#include "MessageType.hpp"
 #include "ParserUtils.hpp"
-#include "Service/Common.hpp"
 #include "module-services/service-desktop/endpoints/update/UpdatePureOS.hpp"
 #include "module-services/service-desktop/endpoints/factoryReset/FactoryReset.hpp"
 #include "ParserFSM.hpp"
 #include "contacts/ContactHelper.hpp"
 #include "messages/MessageHelper.hpp"
 #include "queries/sms/QuerySMSSearchByType.hpp"
-#include "service-desktop/ServiceDesktop.hpp"
 #include "EndpointFactory.hpp"
 #include "contacts/ContactsEndpoint.hpp"
 #include "json/json11.hpp"
 #include <memory>
 #include <vfs.hpp>
 #include <catch2/catch.hpp>
-#include <iostream>
 
 class vfs vfs;