diff --git a/module-db/Interface/ThreadRecord.cpp b/module-db/Interface/ThreadRecord.cpp index 6bbaae567..e7809b51d 100644 --- a/module-db/Interface/ThreadRecord.cpp +++ b/module-db/Interface/ThreadRecord.cpp @@ -115,6 +115,9 @@ std::unique_ptr> ThreadRecordInterface::GetLimitOffset ThreadRecord ThreadRecordInterface::GetByID(uint32_t id) { auto rec = smsDB->threads.GetByID(id); + if(rec.ID == 0){ + return ThreadRecord{}; + } return ThreadRecord{ .dbID = rec.ID, diff --git a/module-services/service-db/ServiceDB.cpp b/module-services/service-db/ServiceDB.cpp index 4b0f1b30d..f420fc6ea 100644 --- a/module-services/service-db/ServiceDB.cpp +++ b/module-services/service-db/ServiceDB.cpp @@ -61,43 +61,71 @@ sys::Message_t ServiceDB::DataReceivedHandler(sys::DataMessage *msgl) { break; - /* - * SMS records - */ + /* + * SMS records + */ - case MessageType ::DBSMSAdd: - { + case MessageType::DBSMSAdd: { DBSMSMessage *msg = reinterpret_cast(msgl); auto ret = smsRecordInterface->Add(msg->record); responseMsg = std::make_shared(nullptr, ret); } - break; + break; - case MessageType ::DBSMSRemove: - { + case MessageType::DBSMSRemove: { DBSMSMessage *msg = reinterpret_cast(msgl); auto ret = smsRecordInterface->RemoveByID(msg->id); responseMsg = std::make_shared(nullptr, ret); } - break; + break; - case MessageType ::DBSMSUpdate: - { + case MessageType::DBSMSUpdate: { DBSMSMessage *msg = reinterpret_cast(msgl); auto ret = smsRecordInterface->Update(msg->record); responseMsg = std::make_shared(nullptr, ret); } break; - case MessageType ::DBSMSGetSMSLimitOffset: - { + case MessageType::DBSMSGetSMSLimitOffset: { DBSMSMessage *msg = reinterpret_cast(msgl); - auto ret = smsRecordInterface->GetLimitOffset(msg->offset,msg->limit); + auto ret = smsRecordInterface->GetLimitOffset(msg->offset, msg->limit); responseMsg = std::make_shared(std::move(ret), true); } break; + + /** + * Thread records + */ + + case MessageType::DBThreadGet: { + DBThreadMessage *msg = reinterpret_cast(msgl); + + auto ret = threadRecordInterface->GetByID(msg->id); + auto records = std::make_unique>(); + records->push_back(ret); + responseMsg = std::make_shared(std::move(records), ret.dbID == 0 ? false : true); + } + break; + + case MessageType::DBThreadRemove: { + DBThreadMessage *msg = reinterpret_cast(msgl); + + auto ret = threadRecordInterface->RemoveByID(msg->id); + responseMsg = std::make_shared(nullptr, ret); + } + break; + + case MessageType::DBThreadGetLimitOffset: { + DBThreadMessage *msg = reinterpret_cast(msgl); + + auto ret = threadRecordInterface->GetLimitOffset(msg->offset, msg->limit); + responseMsg = std::make_shared(std::move(ret), true); + } + break; + + default: // ignore this message return std::make_shared(); @@ -124,8 +152,8 @@ sys::ReturnCodes ServiceDB::InitHandler() { // Create record interfaces settingsRecordInterface = std::make_unique(settingsDB.get()); contactRecordInterface = std::make_unique(contactsDB.get()); - smsRecordInterface = std::make_unique(smsDB.get(),contactsDB.get()); - threadRecordInterface = std::make_unique(smsDB.get(),contactsDB.get()); + smsRecordInterface = std::make_unique(smsDB.get(), contactsDB.get()); + threadRecordInterface = std::make_unique(smsDB.get(), contactsDB.get()); return sys::ReturnCodes::Success; } diff --git a/module-services/service-db/api/DBServiceAPI.cpp b/module-services/service-db/api/DBServiceAPI.cpp index 0e321b149..518d56970 100644 --- a/module-services/service-db/api/DBServiceAPI.cpp +++ b/module-services/service-db/api/DBServiceAPI.cpp @@ -48,4 +48,104 @@ bool DBServiceAPI::SettingsUpdate(sys::Service* serv,const SettingsRecord &rec) else{ return false; } +} + + +bool DBServiceAPI::SMSAdd(sys::Service *serv, const SMSRecord &rec) { + std::shared_ptr msg = std::make_shared(MessageType::DBSMSAdd,rec); + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBSMSResponseMessage* smsResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (smsResponse->retCode == true)){ + return true; + } + else{ + return false; + } +} + +bool DBServiceAPI::SMSRemove(sys::Service *serv, uint32_t id) { + std::shared_ptr msg = std::make_shared(MessageType::DBSMSAdd); + msg->id = id; + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBSMSResponseMessage* smsResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (smsResponse->retCode == true)){ + return true; + } + else{ + return false; + } +} + +bool DBServiceAPI::SMSUpdate(sys::Service *serv, const SMSRecord &rec) { + std::shared_ptr msg = std::make_shared(MessageType::DBSMSAdd,rec); + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBSMSResponseMessage* smsResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (smsResponse->retCode == true)){ + return true; + } + else{ + return false; + } +} + +std::unique_ptr> DBServiceAPI::SMSGetLimitOffset(sys::Service *serv,uint32_t offset, uint32_t limit) { + std::shared_ptr msg = std::make_shared(MessageType::DBSMSAdd); + msg->offset = offset; + msg->limit = limit; + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBSMSResponseMessage* smsResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (smsResponse->retCode == true)){ + return std::move(smsResponse->records); + } + else{ + return std::make_unique>(); + } +} + +ThreadRecord DBServiceAPI::ThreadGet(sys::Service *serv,uint32_t id) { + std::shared_ptr msg = std::make_shared(MessageType::DBThreadGet); + msg->id = id; + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBThreadResponseMessage* threadResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (threadResponse->retCode == true)){ + return std::move((*threadResponse->records)[0]); + } + else{ + return ThreadRecord{}; + } +} + +bool DBServiceAPI::ThreadRemove(sys::Service *serv, uint32_t id) { + std::shared_ptr msg = std::make_shared(MessageType::DBThreadRemove); + msg->id = id; + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBThreadResponseMessage* threadResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (threadResponse->retCode == true)){ + return true; + } + else{ + return false; + } +} + +std::unique_ptr> DBServiceAPI::ThreadGetLimitOffset(sys::Service *serv, uint32_t offset, + uint32_t limit) { + std::shared_ptr msg = std::make_shared(MessageType::DBThreadGetLimitOffset); + msg->offset = offset; + msg->limit = limit; + + auto ret = sys::Bus::SendUnicast(msg,ServiceDB::serviceName,serv,5000); + DBThreadResponseMessage* threadResponse = reinterpret_cast(ret.second.get()); + if((ret.first == sys::ReturnCodes::Success) && (threadResponse->retCode == true)){ + return std::move(threadResponse->records); + } + else{ + return std::make_unique>(); + } } \ No newline at end of file diff --git a/module-services/service-db/api/DBServiceAPI.hpp b/module-services/service-db/api/DBServiceAPI.hpp index 14c0e2d67..67d258afb 100644 --- a/module-services/service-db/api/DBServiceAPI.hpp +++ b/module-services/service-db/api/DBServiceAPI.hpp @@ -15,6 +15,7 @@ #include "Service/Bus.hpp" #include "Interface/SettingsRecord.hpp" #include "Interface/SMSRecord.hpp" +#include "Interface/ThreadRecord.hpp" class DBServiceAPI { @@ -24,7 +25,12 @@ public: static bool SMSAdd(sys::Service* serv,const SMSRecord& rec); static bool SMSRemove(sys::Service* serv,uint32_t id); - static std::unique_ptr> SMSGetLimitOffset(uint32_t offset,uint32_t limit); + static bool SMSUpdate(sys::Service* serv,const SMSRecord& rec); + static std::unique_ptr> SMSGetLimitOffset(sys::Service *serv,uint32_t offset,uint32_t limit); + + static ThreadRecord ThreadGet(sys::Service* serv,uint32_t id); + static bool ThreadRemove(sys::Service* serv,uint32_t id); + static std::unique_ptr> ThreadGetLimitOffset(sys::Service *serv,uint32_t offset,uint32_t limit); }; diff --git a/module-services/service-db/messages/DBMessage.hpp b/module-services/service-db/messages/DBMessage.hpp index 75a047cc5..a9d02e819 100644 --- a/module-services/service-db/messages/DBMessage.hpp +++ b/module-services/service-db/messages/DBMessage.hpp @@ -17,6 +17,7 @@ #include "MessageType.hpp" #include "Interface/SettingsRecord.hpp" #include "Interface/SMSRecord.hpp" +#include "Interface/ThreadRecord.hpp" class DBMessage: public sys::DataMessage { @@ -25,13 +26,19 @@ public: virtual ~DBMessage() {}; MessageType type; + + uint32_t id; + uint32_t offset; + uint32_t limit; }; class DBResponseMessage: public sys::ResponseMessage { public: - DBResponseMessage() : sys::ResponseMessage() {}; + DBResponseMessage(uint32_t retCode) : sys::ResponseMessage(),retCode(retCode) {}; virtual ~DBResponseMessage() {}; + uint32_t retCode; + }; class DBSettingsMessage : public DBMessage{ @@ -46,11 +53,10 @@ public: class DBSettingsResponseMessage: public DBResponseMessage { public: - DBSettingsResponseMessage(const SettingsRecord& rec,uint32_t retCode=0) : DBResponseMessage(),record(rec),retCode(retCode) {}; + DBSettingsResponseMessage(const SettingsRecord& rec,uint32_t retCode=0) : DBResponseMessage(retCode),record(rec){}; virtual ~DBSettingsResponseMessage() {}; SettingsRecord record; - uint32_t retCode; }; class DBSMSMessage : public DBMessage{ @@ -60,20 +66,33 @@ public: } virtual ~DBSMSMessage() {} - uint32_t id; - uint32_t offset; - uint32_t limit; SMSRecord record; }; class DBSMSResponseMessage: public DBResponseMessage { public: - DBSMSResponseMessage(std::unique_ptr> rec,uint32_t retCode=0) : DBResponseMessage(),records(std::move(rec)),retCode(retCode) {}; + DBSMSResponseMessage(std::unique_ptr> rec,uint32_t retCode=0) : DBResponseMessage(retCode),records(std::move(rec)){}; virtual ~DBSMSResponseMessage() {}; std::unique_ptr> records; - uint32_t retCode; }; +class DBThreadMessage : public DBMessage{ +public: + DBThreadMessage(MessageType messageType,const ThreadRecord& rec = ThreadRecord{}): DBMessage(messageType),record(rec){ + + } + virtual ~DBThreadMessage() {} + + ThreadRecord record; +}; + +class DBThreadResponseMessage: public DBResponseMessage { +public: + DBThreadResponseMessage(std::unique_ptr> rec,uint32_t retCode=0) : DBResponseMessage(retCode),records(std::move(rec)){}; + virtual ~DBThreadResponseMessage() {}; + + std::unique_ptr> records; +}; #endif //PUREPHONE_DBMESSAGE_HPP diff --git a/source/MessageType.hpp b/source/MessageType.hpp index 510e4096f..576862045 100644 --- a/source/MessageType.hpp +++ b/source/MessageType.hpp @@ -32,6 +32,11 @@ enum class MessageType { DBSMSUpdate, // Update specified SMS record DBSMSGetSMSLimitOffset, // Get SMS records by limit,offset + DBThreadGet, // Get thread by ID + DBThreadRemove, // Remove thread by ID + DBThreadGetLimitOffset, // Get Thread record by limit,offset + + //application manager APMSwitch, //request to switch to given application, optionally also to specified window APMSwitchData, //request to switch to given application, optionally also to specified window with provided data.