From d2fcc3020066150b09fa13ccefa8c15d1d0f8cf9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Jo=C5=84ski?= Date: Wed, 11 Aug 2021 17:53:53 +0200 Subject: [PATCH] [BH-743] Add AlarmEvents Add AlarmEvents to database --- image/user/db/events_001.sql | 9 + module-db/CMakeLists.txt | 10 + module-db/Databases/EventsDB.cpp | 2 +- module-db/Databases/EventsDB.hpp | 3 + module-db/Interface/AlarmEventRecord.cpp | 175 ++++++++++ module-db/Interface/AlarmEventRecord.hpp | 69 +++- module-db/Interface/BaseInterface.hpp | 3 + module-db/Tables/AlarmEventsTable.cpp | 300 ++++++++++++++++++ module-db/Tables/AlarmEventsTable.hpp | 77 +++++ module-db/Tables/EventsTable.hpp | 6 +- .../alarm_events/QueryAlarmEventsAdd.cpp | 33 ++ .../alarm_events/QueryAlarmEventsAdd.hpp | 34 ++ .../alarm_events/QueryAlarmEventsEdit.cpp | 33 ++ .../alarm_events/QueryAlarmEventsEdit.hpp | 35 ++ .../alarm_events/QueryAlarmEventsGet.cpp | 28 ++ .../alarm_events/QueryAlarmEventsGet.hpp | 35 ++ .../QueryAlarmEventsGetBetweenDates.cpp | 31 ++ .../QueryAlarmEventsGetBetweenDates.hpp | 37 +++ .../QueryAlarmEventsGetLimited.cpp | 30 ++ .../QueryAlarmEventsGetLimited.hpp | 35 ++ .../alarm_events/QueryAlarmEventsGetNext.cpp | 31 ++ .../alarm_events/QueryAlarmEventsGetNext.hpp | 36 +++ ...eryAlarmEventsGetRecurringBetweenDates.cpp | 32 ++ ...eryAlarmEventsGetRecurringBetweenDates.hpp | 37 +++ .../alarm_events/QueryAlarmEventsRemove.cpp | 28 ++ .../alarm_events/QueryAlarmEventsRemove.hpp | 32 ++ module-services/service-db/ServiceDB.cpp | 3 + module-services/service-db/ServiceDB.hpp | 3 + 28 files changed, 1181 insertions(+), 6 deletions(-) create mode 100644 module-db/Interface/AlarmEventRecord.cpp create mode 100644 module-db/Tables/AlarmEventsTable.cpp create mode 100644 module-db/Tables/AlarmEventsTable.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsAdd.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsAdd.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsEdit.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsEdit.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGet.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGet.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetLimited.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetLimited.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetNext.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetNext.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsRemove.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsRemove.hpp diff --git a/image/user/db/events_001.sql b/image/user/db/events_001.sql index d9065c4d44e4c00971e3bd98029391ae336d4c77..8bbfc631e1b77801afb8f8fb1c3a8379b88c0cf2 100644 --- a/image/user/db/events_001.sql +++ b/image/user/db/events_001.sql @@ -11,3 +11,12 @@ CREATE TABLE IF NOT EXISTS events( rrule TEXT DEFAULT '' ); +CREATE TABLE IF NOT EXISTS alarm_events( + _id INTEGER PRIMARY KEY, + event_id INTEGER, + music_tone TEXT, + enabled BOOLEAN, + snooze_duration INTEGER, + FOREIGN KEY (event_id) REFERENCES events (_id) ON DELETE CASCADE +); + diff --git a/module-db/CMakeLists.txt b/module-db/CMakeLists.txt index ac245f338d15fc8500c4b9b6d64108c3298a660f..8401e64782f6fb5c607b3eea6a26c39f1b8477e3 100644 --- a/module-db/CMakeLists.txt +++ b/module-db/CMakeLists.txt @@ -26,6 +26,7 @@ set(SOURCES Databases/CountryCodesDB.cpp Databases/NotificationsDB.cpp + Tables/AlarmEventsTable.cpp Tables/Table.cpp Tables/SMSTable.cpp Tables/ThreadsTable.cpp @@ -43,6 +44,7 @@ set(SOURCES Tables/SMSTemplateTable.cpp Tables/NotificationsTable.cpp + Interface/AlarmEventRecord.cpp Interface/EventRecord.cpp Interface/Record.cpp Interface/SMSRecord.cpp @@ -55,6 +57,14 @@ set(SOURCES Interface/NotificationsRecord.cpp queries/RecordQuery.cpp + queries/alarm_events/QueryAlarmEventsAdd.cpp + queries/alarm_events/QueryAlarmEventsEdit.cpp + queries/alarm_events/QueryAlarmEventsGet.cpp + queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp + queries/alarm_events/QueryAlarmEventsGetLimited.cpp + queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp + queries/alarm_events/QueryAlarmEventsGetNext.cpp + queries/alarm_events/QueryAlarmEventsRemove.cpp queries/messages/sms/QuerySMSSearchByType.cpp queries/messages/sms/QuerySMSGet.cpp queries/messages/sms/QuerySMSGetCount.cpp diff --git a/module-db/Databases/EventsDB.cpp b/module-db/Databases/EventsDB.cpp index 16a84aad623c0efe6cf139f25db62cf2bcf0136b..de31509d3aea658ed42d4a6f82240b7bfef90924 100644 --- a/module-db/Databases/EventsDB.cpp +++ b/module-db/Databases/EventsDB.cpp @@ -3,5 +3,5 @@ #include "EventsDB.hpp" -EventsDB::EventsDB(const char *name) : Database(name) +EventsDB::EventsDB(const char *name) : Database(name), alarmEvents(this) {} diff --git a/module-db/Databases/EventsDB.hpp b/module-db/Databases/EventsDB.hpp index 8b30d298f40e7e540d717c4fe3ba82fe9b7a41d0..b9ed2b4ae4cc9245878895ea851fe7748b8a88dc 100644 --- a/module-db/Databases/EventsDB.hpp +++ b/module-db/Databases/EventsDB.hpp @@ -4,9 +4,12 @@ #pragma once #include +#include class EventsDB : public Database { public: explicit EventsDB(const char *name); + + AlarmEventsTable alarmEvents; }; diff --git a/module-db/Interface/AlarmEventRecord.cpp b/module-db/Interface/AlarmEventRecord.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ade480a37120821c8c1b4fe8c92580ee2c17ab89 --- /dev/null +++ b/module-db/Interface/AlarmEventRecord.cpp @@ -0,0 +1,175 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "AlarmEventRecord.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +std::vector generateRecordsVector(const std::vector &tableRowVector); + +AlarmEventRecord::AlarmEventRecord(uint32_t id, + const UTF8 &name, + TimePoint startDate, + uint32_t duration, + bool isAllDay, + const std::string &rruleText, + const std::string &musicTone, + bool enabled, + uint32_t snoozeDuration) + : EventRecord{id, name, startDate, duration, isAllDay, rruleText}, musicTone{musicTone}, enabled{enabled}, + snoozeDuration{snoozeDuration} {}; + +AlarmEventRecord::AlarmEventRecord(const AlarmEventsTableRow &aeRow) + : EventRecord{aeRow.ID, aeRow.name, aeRow.startDate, aeRow.duration, aeRow.isAllDay, aeRow.rruleText}, + musicTone{aeRow.musicTone}, enabled{aeRow.enabled}, snoozeDuration{aeRow.snoozeDuration} {}; + +auto AlarmEventRecord::isValid() const -> bool +{ + return (startDate != TIME_POINT_INVALID && ID != 0); +} + +AlarmEventRecordInterface::AlarmEventRecordInterface(EventsDB *eventsDB) : eventsDB(eventsDB) +{} + +AlarmEventRecordInterface::~AlarmEventRecordInterface() +{} + +std::unique_ptr AlarmEventRecordInterface::runQuery(std::shared_ptr query) +{ + if (typeid(*query) == typeid(db::query::alarmEvents::Add)) { + return runQueryImplAdd(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::Edit)) { + return runQueryImplEdit(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::Get)) { + return runQueryImplGet(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::GetLimited)) { + return runQueryImplGetLimited(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::GetBetweenDates)) { + return runQueryImplGetBetweenDates(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::GetNext)) { + return runQueryImplGetNext(std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::GetRecurringBetweenDates)) { + return runQueryImplGetRecurringBetweenDates( + std::static_pointer_cast(query)); + } + if (typeid(*query) == typeid(db::query::alarmEvents::Remove)) { + return runQueryImplRemove(std::static_pointer_cast(query)); + } + return nullptr; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplAdd( + std::shared_ptr query) +{ + const auto result = eventsDB->alarmEvents.add(AlarmEventsTableRow(query->getRecord())); + + auto response = std::make_unique(result); + response->setRequestQuery(query); + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplEdit( + std::shared_ptr query) +{ + const auto result = eventsDB->alarmEvents.update(AlarmEventsTableRow(query->getRecord())); + + auto response = std::make_unique(result); + response->setRequestQuery(query); + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplGet( + std::shared_ptr query) +{ + const auto record = eventsDB->alarmEvents.getById(query->id); + + auto response = std::make_unique(AlarmEventRecord(record)); + response->setRequestQuery(query); + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplGetBetweenDates( + std::shared_ptr query) +{ + const auto alarmEventsRows = + eventsDB->alarmEvents.getBetweenDates(query->start, query->end, query->offset, query->limit); + const auto recordVector = generateRecordsVector(alarmEventsRows); + + auto response = std::make_unique(recordVector); + response->setRequestQuery(query); + + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplGetLimited( + std::shared_ptr query) +{ + const auto alarmEventsRows = eventsDB->alarmEvents.getLimitOffset(query->offset, query->limit); + const auto recordVector = generateRecordsVector(alarmEventsRows); + + auto response = std::make_unique(recordVector); + response->setRequestQuery(query); + + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplGetNext( + std::shared_ptr query) +{ + const auto alarmEventsRows = eventsDB->alarmEvents.getNext(query->start, query->offset, query->limit); + const auto recordVector = generateRecordsVector(alarmEventsRows); + + auto response = std::make_unique(recordVector); + response->setRequestQuery(query); + + return response; +} + +std::unique_ptr AlarmEventRecordInterface:: + runQueryImplGetRecurringBetweenDates(std::shared_ptr query) +{ + const auto alarmEventsRows = + eventsDB->alarmEvents.getRecurringBetweenDates(query->start, query->end, query->offset, query->limit); + const auto recordVector = generateRecordsVector(alarmEventsRows); + + auto response = std::make_unique(recordVector); + response->setRequestQuery(query); + + return response; +} + +std::unique_ptr AlarmEventRecordInterface::runQueryImplRemove( + std::shared_ptr query) +{ + const bool ret = eventsDB->alarmEvents.removeById(query->id); + auto response = std::make_unique(ret); + response->setRequestQuery(query); + return response; +} + +std::vector generateRecordsVector(const std::vector &tableRowVector) +{ + std::vector recordVector; + + recordVector.reserve(tableRowVector.size()); + for (const auto &row : tableRowVector) { + recordVector.emplace_back(row); + } + return recordVector; +} diff --git a/module-db/Interface/AlarmEventRecord.hpp b/module-db/Interface/AlarmEventRecord.hpp index d05721d19f4cd936e11640807d78485425efa92b..a3ab4b53b70a42ed86eac83053cd4d12f9fbcde5 100644 --- a/module-db/Interface/AlarmEventRecord.hpp +++ b/module-db/Interface/AlarmEventRecord.hpp @@ -4,11 +4,76 @@ #pragma once #include "EventRecord.hpp" +#include -#include +#include + +namespace db::query::alarmEvents +{ + class Add; + class AddResult; + class Edit; + class EditResult; + class Get; + class GetBetweenDates; + class GetBetweenDatesResult; + class GetLimited; + class GetLimitedResult; + class GetNext; + class GetNextResult; + class GetRecurringBetweenDates; + class GetRecurringBetweenDatesResult; + class GetResult; + class Remove; + class RemoveResult; +} // namespace db::query::alarmEvents struct AlarmEventRecord : public EventRecord { - std::string musicTone{""}; + std::string musicTone; bool enabled{false}; + uint32_t snoozeDuration{0}; + + AlarmEventRecord(uint32_t id, + const UTF8 &name, + TimePoint startDate, + uint32_t duration, + bool isAllDay, + const std::string &rruleText, + const std::string &musicTone, + bool enabled, + uint32_t snoozeDuration); + + AlarmEventRecord(const AlarmEventsTableRow &aeRow); + + auto isValid() const -> bool; +}; + +class AlarmEventRecordInterface : public db::Interface +{ + public: + explicit AlarmEventRecordInterface(EventsDB *eventsDB); + ~AlarmEventRecordInterface(); + + std::unique_ptr runQuery(std::shared_ptr query) override; + + private: + EventsDB *eventsDB; + + std::unique_ptr runQueryImplAdd( + std::shared_ptr query); + std::unique_ptr runQueryImplEdit( + std::shared_ptr query); + std::unique_ptr runQueryImplGet( + std::shared_ptr query); + std::unique_ptr runQueryImplGetBetweenDates( + std::shared_ptr query); + std::unique_ptr runQueryImplGetLimited( + std::shared_ptr query); + std::unique_ptr runQueryImplGetNext( + std::shared_ptr query); + std::unique_ptr runQueryImplGetRecurringBetweenDates( + std::shared_ptr query); + std::unique_ptr runQueryImplRemove( + std::shared_ptr query); }; diff --git a/module-db/Interface/BaseInterface.hpp b/module-db/Interface/BaseInterface.hpp index 6554790435faa638df94613caf1f2fc15f73b574..8a11dc601082be8e706958afbda5bb3599cc0599 100644 --- a/module-db/Interface/BaseInterface.hpp +++ b/module-db/Interface/BaseInterface.hpp @@ -18,6 +18,7 @@ namespace db enum class Name { + AlarmEvents, SMS, SMSThread, SMSTemplate, @@ -35,6 +36,8 @@ namespace db constexpr const char *c_str(enum db::Interface::Name db) { switch (db) { + case db::Interface::Name::AlarmEvents: + return "AlarmEvents"; case db::Interface::Name::SMS: return "SMS"; case db::Interface::Name::SMSThread: diff --git a/module-db/Tables/AlarmEventsTable.cpp b/module-db/Tables/AlarmEventsTable.cpp new file mode 100644 index 0000000000000000000000000000000000000000..418694a09185ce80297d0802601d27c898cc701d --- /dev/null +++ b/module-db/Tables/AlarmEventsTable.cpp @@ -0,0 +1,300 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "AlarmEventsTable.hpp" + +#include + +std::vector retQueryUnpack(std::unique_ptr retQuery); + +AlarmEventsTableRow::AlarmEventsTableRow(uint32_t id, + const UTF8 &name, + TimePoint startDate, + TimePoint endDate, + uint32_t duration, + bool isAllDay, + const std::string &rruleText, + const std::string &musicTone, + bool enabled, + uint32_t snoozeDuration) + : EventsTableRow{id, name, startDate, endDate, duration, isAllDay, rruleText}, musicTone{musicTone}, + enabled{enabled}, snoozeDuration{snoozeDuration} +{} + +AlarmEventsTableRow::AlarmEventsTableRow(const AlarmEventRecord &rec) + : AlarmEventsTableRow{rec.ID, + rec.name, + rec.startDate, + rec.endDate, + rec.duration, + rec.isAllDay, + rec.rruleText, + rec.musicTone, + rec.enabled, + rec.snoozeDuration} +{} + +AlarmEventsTableRow::AlarmEventsTableRow(const QueryResult &result) + : EventsTableRow{result[0].getUInt32(), + result[1].getString().c_str(), + TimePointFromString(result[2].getString().c_str()), + TimePointFromString(result[3].getString().c_str()), + result[4].getUInt32(), + result[5].getBool(), + result[6].getString().c_str()}, + musicTone{result[9].getString()}, enabled{result[10].getBool()}, snoozeDuration{result[11].getUInt32()} +{} + +auto AlarmEventsTableRow::isValid() const -> bool +{ + return (startDate != TIME_POINT_INVALID && ID != 0); +} + +AlarmEventsTable::AlarmEventsTable(Database *db) : Table(db) +{} + +bool AlarmEventsTable::create() +{ + return true; +} + +bool AlarmEventsTable::add(AlarmEventsTableRow entry) +{ + auto ret = db->execute("BEGIN TRANSACTION;" + "INSERT or ignore INTO events ( name, start_date, end_date, duration, is_all_day, rrule)" + "VALUES ('%q', '%q', '%q', %lu, %d, '%q');", + entry.name.c_str(), + TimePointToString(entry.startDate).c_str(), + TimePointToString(entry.endDate).c_str(), + entry.duration, + entry.isAllDay, + entry.rruleText.c_str()); + if (!ret) { + return false; + } + auto eventId = db->getLastInsertRowId(); + if (eventId == 0) { + return false; + } + return db->execute("INSERT or ignore INTO alarm_events ( event_id, music_tone, enabled, snooze_duration)" + "VALUES ('%lu', '%q', '%d', %lu);" + "COMMIT;", + eventId, + entry.musicTone.c_str(), + entry.enabled, + entry.snoozeDuration); +} + +bool AlarmEventsTable::removeById(uint32_t id) +{ + return db->execute("DELETE FROM events " + "WHERE events._id = (SELECT event_id FROM alarm_events WHERE _id=%lu);", + id); +} + +bool AlarmEventsTable::removeByField(AlarmEventsTableFields field, const char *str) +{ + const auto &fieldName = getFieldName(field); + + if (fieldName.empty()) { + return false; + } + + return db->execute("DELETE e " + "FROM events e " + "INNER JOIN alarm_events ae " + " ON e._id = ae.event_id " + "WHERE %q = '%q';", + fieldName.c_str(), + str); +} + +bool AlarmEventsTable::update(AlarmEventsTableRow entry) +{ + return db->execute( + "BEGIN TRANSACTION; " + "UPDATE events SET name = '%q', start_date = '%q', end_date = '%q', duration = %d, is_all_day = %d, " + "rrule = '%q' WHERE _id= (SELECT event_id FROM alarm_events WHERE _id=%lu); " + "UPDATE alarm_events SET music_tone = '%q', enabled = '%d', snooze_duration = '%d' " + "WHERE _id=%lu; " + "COMMIT;", + entry.name.c_str(), + TimePointToString(entry.startDate).c_str(), + TimePointToString(entry.endDate).c_str(), + entry.duration, + entry.isAllDay, + entry.rruleText.c_str(), + entry.ID, + entry.musicTone.c_str(), + entry.enabled, + entry.snoozeDuration, + entry.ID); +} + +AlarmEventsTableRow AlarmEventsTable::getById(uint32_t id) +{ + auto retQuery = db->query("SELECT * " + "FROM events as e, alarm_events as ae " + "WHERE e._id=ae.event_id AND e._id = %u", + id); + + if ((retQuery == nullptr) || (retQuery->getRowCount() == 0)) { + return AlarmEventsTableRow(); + } + + return AlarmEventsTableRow(*retQuery); +} + +std::vector AlarmEventsTable::getLimitOffset(uint32_t offset, uint32_t limit) +{ + auto retQuery = db->query("SELECT * FROM events e " + "JOIN alarm_events ae ON ae.event_id = e._id " + "LIMIT %lu OFFSET %lu ", + limit, + offset); + + return retQueryUnpack(std::move(retQuery)); +} + +std::vector AlarmEventsTable::getLimitOffsetByField(uint32_t offset, + uint32_t limit, + AlarmEventsTableFields field, + const char *str) +{ + std::unique_ptr retQuery = nullptr; + const auto &fieldName = getFieldName(field); + + if (fieldName.empty()) { + return {}; + } + + retQuery = db->query("SELECT * FROM events e " + "JOIN alarm_events ae ON ae.event_id = e._id " + "WHERE %q = '%q' " + "ORDER BY start_date LIMIT %lu OFFSET %lu;", + fieldName.c_str(), + str, + limit, + offset); + + return retQueryUnpack(std::move(retQuery)); +} + +std::vector AlarmEventsTable::getBetweenDates(TimePoint startDate, + TimePoint endDate, + uint32_t offset, + uint32_t limit) +{ + auto retQuery = db->query("SELECT * FROM events e " + "JOIN alarm_events ae ON ae.event_id = e._id " + "WHERE start_date BETWEEN '%q' and '%q'" + "ORDER BY start_date LIMIT %lu OFFSET %lu;", + TimePointToString(startDate).c_str(), + TimePointToString(endDate).c_str(), + limit, + offset); + + return retQueryUnpack(std::move(retQuery)); +} + +std::vector AlarmEventsTable::getRecurringBetweenDates(TimePoint startDate, + TimePoint endDate, + uint32_t offset, + uint32_t limit) +{ + auto retQuery = db->query("SELECT * FROM events e " + "JOIN alarm_events ae ON ae.event_id = e._id " + "WHERE start_date BETWEEN '%q' and '%q' " + "OR (start_date <= '%q' AND end_date >= '%q') " + "AND rrule <> '' " + "ORDER BY start_date LIMIT %lu OFFSET %lu;", + TimePointToString(startDate).c_str(), + TimePointToString(endDate).c_str(), + TimePointToString(startDate).c_str(), + TimePointToString(startDate).c_str(), + limit, + offset); + + return retQueryUnpack(std::move(retQuery)); +} + +std::vector AlarmEventsTable::getNext(TimePoint start, uint32_t offset, uint32_t limit) +{ + auto retQuery = db->query("SELECT * FROM events e " + "JOIN alarm_events ae ON ae.event_id = e._id " + "WHERE start_date = " + " (" + " SELECT MIN(e.start_date) FROM events as e " + " WHERE e.start_date > '%q'" + " ) " + "LIMIT %lu OFFSET %lu;", + TimePointToString(start).c_str(), + limit, + offset); + + return retQueryUnpack(std::move(retQuery)); +} + +uint32_t AlarmEventsTable::count() +{ + auto queryRet = db->query("SELECT COUNT(*) FROM alarm_events;"); + if (!queryRet || queryRet->getRowCount() == 0) { + return 0; + } + + return (*queryRet)[0].getUInt32(); +} + +uint32_t AlarmEventsTable::countByFieldId(const char *field, uint32_t id) +{ + auto queryRet = db->query("SELECT COUNT(*) FROM alarm_events " + "JOIN events ON alarm_events.event_id = events._id " + "WHERE %q=%lu;", + field, + id); + if ((queryRet == nullptr) || (queryRet->getRowCount() == 0)) { + return 0; + } + + return (*queryRet)[0].getUInt32(); +} + +std::string AlarmEventsTable::getFieldName(AlarmEventsTableFields field) +{ + switch (field) { + case AlarmEventsTableFields::Name: + return "name"; + case AlarmEventsTableFields::StartDate: + return "start_date"; + case AlarmEventsTableFields::EndDate: + return "end_date"; + case AlarmEventsTableFields::Duration: + return "duration"; + case AlarmEventsTableFields::IsAllDay: + return "is_all_day"; + case AlarmEventsTableFields::Rrule: + return "rrule"; + case AlarmEventsTableFields::MusicTone: + return "music_tone"; + case AlarmEventsTableFields::Enabled: + return "enabled"; + case AlarmEventsTableFields::SnoozeDuration: + return "snooze_duration"; + default: + return ""; + } +} + +std::vector retQueryUnpack(std::unique_ptr retQuery) +{ + if ((retQuery == nullptr) || (retQuery->getRowCount() == 0)) { + return {}; + } + + std::vector outVector; + + do { + outVector.push_back(AlarmEventsTableRow(*retQuery)); + } while (retQuery->nextRow()); + return outVector; +} diff --git a/module-db/Tables/AlarmEventsTable.hpp b/module-db/Tables/AlarmEventsTable.hpp new file mode 100644 index 0000000000000000000000000000000000000000..f13f162f233e254a512c88f4dde7124f59351c51 --- /dev/null +++ b/module-db/Tables/AlarmEventsTable.hpp @@ -0,0 +1,77 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "EventsTable.hpp" + +#include +#include + +#include + +struct AlarmEventRecord; + +struct AlarmEventsTableRow : public EventsTableRow +{ + std::string musicTone{""}; + bool enabled{false}; + uint32_t snoozeDuration{0}; + + AlarmEventsTableRow() = default; + AlarmEventsTableRow(uint32_t id, + const UTF8 &name, + TimePoint startDate, + TimePoint endDate, + uint32_t duration, + bool isAllDay, + const std::string &rrule, + const std::string &musicTone, + bool enabled, + uint32_t snoozeDuration); + explicit AlarmEventsTableRow(const AlarmEventRecord &rec); + explicit AlarmEventsTableRow(const QueryResult &result); + + auto isValid() const -> bool; +}; + +enum class AlarmEventsTableFields +{ + Name, + StartDate, + EndDate, + Duration, + IsAllDay, + Rrule, + MusicTone, + Enabled, + SnoozeDuration, +}; + +class AlarmEventsTable : public Table +{ + public: + explicit AlarmEventsTable(Database *db); + virtual ~AlarmEventsTable() = default; + + auto create() -> bool override; + auto add(AlarmEventsTableRow entry) -> bool override; + auto removeById(uint32_t id) -> bool override; + auto removeByField(AlarmEventsTableFields field, const char *str) -> bool override; + auto update(AlarmEventsTableRow entry) -> bool override; + auto getById(uint32_t id) -> AlarmEventsTableRow override; + auto getLimitOffset(uint32_t offset, uint32_t limit) -> std::vector override; + auto getLimitOffsetByField(uint32_t offset, uint32_t limit, AlarmEventsTableFields field, const char *str) + -> std::vector override; + auto getBetweenDates(TimePoint startDate, TimePoint endDate, uint32_t offset, uint32_t limit) + -> std::vector; + auto getRecurringBetweenDates(TimePoint startDate, TimePoint endDate, uint32_t offset, uint32_t limit) + -> std::vector; + auto getNext(TimePoint start, uint32_t offset, uint32_t limit) -> std::vector; + + auto count() -> uint32_t override; + auto countByFieldId(const char *field, uint32_t id) -> uint32_t override; + + private: + auto getFieldName(AlarmEventsTableFields field) -> std::string; +}; diff --git a/module-db/Tables/EventsTable.hpp b/module-db/Tables/EventsTable.hpp index 233832e897aa0078e5bbf851912b6804a5209577..5f3fdf7af0bb6164035bf4dfc14a29f2f717d553 100644 --- a/module-db/Tables/EventsTable.hpp +++ b/module-db/Tables/EventsTable.hpp @@ -22,7 +22,7 @@ struct EventsTableRow : public Record TimePoint endDate{TIME_POINT_INVALID}; uint32_t duration{0}; bool isAllDay{false}; - std::string rrule{""}; + std::string rruleText{""}; EventsTableRow() = default; EventsTableRow(uint32_t id, @@ -31,7 +31,7 @@ struct EventsTableRow : public Record TimePoint endDate, uint32_t duration, bool isAllDay, - std::string rrule) + std::string rruleText) : Record{id}, name{name}, startDate{startDate}, endDate{endDate}, duration{duration}, isAllDay{isAllDay}, - rrule{rrule} {}; + rruleText{rruleText} {}; }; diff --git a/module-db/queries/alarm_events/QueryAlarmEventsAdd.cpp b/module-db/queries/alarm_events/QueryAlarmEventsAdd.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4652936afcf81354e7e61a22af6dea7bb9786fa3 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsAdd.cpp @@ -0,0 +1,33 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsAdd.hpp" + +namespace db::query::alarmEvents +{ + Add::Add(const AlarmEventRecord &record) : Query(Query::Type::Create), record(record) + {} + + auto Add::getRecord() const -> AlarmEventRecord + { + return record; + } + + auto Add::debugInfo() const -> std::string + { + return std::string{"Add"}; + } + + AddResult::AddResult(bool ret) : ret(ret) + {} + + auto AddResult::succeed() const -> bool + { + return ret; + } + + auto AddResult::debugInfo() const -> std::string + { + return std::string{"AddResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsAdd.hpp b/module-db/queries/alarm_events/QueryAlarmEventsAdd.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d6901185659de32317e169c64afa0ca204848955 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsAdd.hpp @@ -0,0 +1,34 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "Interface/AlarmEventRecord.hpp" + +#include + +#include + +namespace db::query::alarmEvents +{ + class Add : public Query + { + const AlarmEventRecord record; + + public: + explicit Add(const AlarmEventRecord &record); + [[nodiscard]] auto getRecord() const -> AlarmEventRecord; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class AddResult : public QueryResult + { + const bool ret = true; + + public: + explicit AddResult(bool ret); + [[nodiscard]] auto succeed() const -> bool; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsEdit.cpp b/module-db/queries/alarm_events/QueryAlarmEventsEdit.cpp new file mode 100644 index 0000000000000000000000000000000000000000..311a6d1db2452ac847125eb1f9554a15651dc79f --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsEdit.cpp @@ -0,0 +1,33 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsEdit.hpp" + +namespace db::query::alarmEvents +{ + Edit::Edit(const AlarmEventRecord &record) : Query(Query::Type::Update), record(record) + {} + + auto Edit::getRecord() const -> AlarmEventRecord + { + return record; + } + + auto Edit::debugInfo() const -> std::string + { + return std::string{"Edit"}; + } + + EditResult::EditResult(bool ret) : ret(ret) + {} + + auto EditResult::succeed() const -> bool + { + return ret; + } + + auto EditResult::debugInfo() const -> std::string + { + return std::string{"EditResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsEdit.hpp b/module-db/queries/alarm_events/QueryAlarmEventsEdit.hpp new file mode 100644 index 0000000000000000000000000000000000000000..4321a749b9303eb9480adaac0cfec4ba4a88f521 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsEdit.hpp @@ -0,0 +1,35 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "Interface/AlarmEventRecord.hpp" + +#include + +#include + +namespace db::query::alarmEvents +{ + class Edit : public Query + { + const AlarmEventRecord record; + + public: + explicit Edit(const AlarmEventRecord &record); + + [[nodiscard]] auto getRecord() const -> AlarmEventRecord; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class EditResult : public QueryResult + { + const bool ret = true; + + public: + explicit EditResult(bool ret); + [[nodiscard]] auto succeed() const -> bool; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGet.cpp b/module-db/queries/alarm_events/QueryAlarmEventsGet.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f9c7feafdab0c8f665a5279e4877576d3bcd64ff --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGet.cpp @@ -0,0 +1,28 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsGet.hpp" + +namespace db::query::alarmEvents +{ + Get::Get(uint32_t id) : Query(Query::Type::Read), id(id) + {} + + auto Get::debugInfo() const -> std::string + { + return std::string{"Get"}; + } + + GetResult::GetResult(const AlarmEventRecord &record) : record(record) + {} + + auto GetResult::getResult() const -> AlarmEventRecord + { + return record; + } + + auto GetResult::debugInfo() const -> std::string + { + return std::string{"GetResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGet.hpp b/module-db/queries/alarm_events/QueryAlarmEventsGet.hpp new file mode 100644 index 0000000000000000000000000000000000000000..559669dd0790adb589d84b83da0f9aa2f8795f16 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGet.hpp @@ -0,0 +1,35 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include + +#include + +#include + +namespace db::query::alarmEvents +{ + class Get : public Query + { + public: + const uint32_t id; + + explicit Get(uint32_t id); + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + + class GetResult : public QueryResult + { + const AlarmEventRecord record; + + public: + explicit GetResult(const AlarmEventRecord &record); + [[nodiscard]] auto getResult() const -> AlarmEventRecord; + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp b/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp new file mode 100644 index 0000000000000000000000000000000000000000..99329f820ad62a1f46cbb1f58eb3a094013de6f0 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp @@ -0,0 +1,31 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsGetBetweenDates.hpp" + +#include + +namespace db::query::alarmEvents +{ + GetBetweenDates::GetBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit) + : Query(Query::Type::Read), start(start), end(end), offset(offset), limit(limit) + {} + + auto GetBetweenDates::debugInfo() const -> std::string + { + return std::string{"GetBetweenDates"}; + } + + GetBetweenDatesResult::GetBetweenDatesResult(std::vector records) : records(std::move(records)) + {} + + auto GetBetweenDatesResult::getResult() const -> std::vector + { + return records; + } + + auto GetBetweenDatesResult::debugInfo() const -> std::string + { + return std::string{"GetBetweenDatesResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.hpp b/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.hpp new file mode 100644 index 0000000000000000000000000000000000000000..fe43f839ecbceeff88d812a547e740dbe08c1f73 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.hpp @@ -0,0 +1,37 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include + +#include + +#include + +namespace db::query::alarmEvents +{ + class GetBetweenDates : public Query + { + public: + GetBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const TimePoint start = TIME_POINT_INVALID; + const TimePoint end = TIME_POINT_INVALID; + const uint32_t offset = 0; + const uint32_t limit = 0; + }; + + class GetBetweenDatesResult : public QueryResult + { + const std::vector records; + + public: + explicit GetBetweenDatesResult(std::vector records); + [[nodiscard]] auto getResult() const -> std::vector; + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.cpp b/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7918cc7cd6a9c2f82a04d72ba1da13b1f26c9045 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.cpp @@ -0,0 +1,30 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsGetLimited.hpp" + +#include + +namespace db::query::alarmEvents +{ + GetLimited::GetLimited(uint32_t offset, uint32_t limit) : Query(Query::Type::Read), offset(offset), limit(limit) + {} + + auto GetLimited::debugInfo() const -> std::string + { + return std::string{"GetLimited"}; + } + + GetLimitedResult::GetLimitedResult(std::vector records) : records(std::move(records)) + {} + + auto GetLimitedResult::getResult() const -> std::vector + { + return records; + } + + auto GetLimitedResult::debugInfo() const -> std::string + { + return std::string{"GetLimitedResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.hpp b/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.hpp new file mode 100644 index 0000000000000000000000000000000000000000..7a3bacfbf26fb834175b3eaea60960d95a2e91a9 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetLimited.hpp @@ -0,0 +1,35 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "module-db/Interface/AlarmEventRecord.hpp" + +#include + +#include + +namespace db::query::alarmEvents +{ + class GetLimited : public Query + { + public: + GetLimited(uint32_t offset, uint32_t limit); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const uint32_t offset = 0; + const uint32_t limit = 0; + }; + + class GetLimitedResult : public QueryResult + { + const std::vector records; + + public: + explicit GetLimitedResult(std::vector records); + [[nodiscard]] auto getResult() const -> std::vector; + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetNext.cpp b/module-db/queries/alarm_events/QueryAlarmEventsGetNext.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c076724802a3009ea4e05177058e63f42a071a4c --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetNext.cpp @@ -0,0 +1,31 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsGetNext.hpp" + +#include + +namespace db::query::alarmEvents +{ + GetNext::GetNext(TimePoint start, uint32_t offset, uint32_t limit) + : Query(Query::Type::Read), start(start), offset(offset), limit(limit) + {} + + auto GetNext::debugInfo() const -> std::string + { + return std::string{"GetNext"}; + } + + GetNextResult::GetNextResult(std::vector records) : records(std::move(records)) + {} + + auto GetNextResult::getResult() const -> std::vector + { + return records; + } + + auto GetNextResult::debugInfo() const -> std::string + { + return std::string{"GetNextResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetNext.hpp b/module-db/queries/alarm_events/QueryAlarmEventsGetNext.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ae6f098238a84937e34c966202c2b9064e1c74c7 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetNext.hpp @@ -0,0 +1,36 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "module-db/Interface/AlarmEventRecord.hpp" + +#include + +#include + +namespace db::query::alarmEvents +{ + class GetNext : public Query + { + public: + GetNext(TimePoint start, uint32_t offset, uint32_t limit); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const TimePoint start = TIME_POINT_INVALID; + const uint32_t offset = 0; + const uint32_t limit = 0; + }; + + class GetNextResult : public QueryResult + { + const std::vector records; + + public: + explicit GetNextResult(std::vector records); + [[nodiscard]] auto getResult() const -> std::vector; + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp b/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp new file mode 100644 index 0000000000000000000000000000000000000000..539f58c6a8164d8bd269eae4960f8b7b409039d4 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp @@ -0,0 +1,32 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsGetRecurringBetweenDates.hpp" + +#include + +namespace db::query::alarmEvents +{ + GetRecurringBetweenDates::GetRecurringBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit) + : Query(Query::Type::Read), start(start), end(end), offset(offset), limit(limit) + {} + + auto GetRecurringBetweenDates::debugInfo() const -> std::string + { + return std::string{"GetRecurringBetweenDates"}; + } + + GetRecurringBetweenDatesResult::GetRecurringBetweenDatesResult(std::vector records) + : records(std::move(records)) + {} + + auto GetRecurringBetweenDatesResult::getResult() const -> std::vector + { + return records; + } + + auto GetRecurringBetweenDatesResult::debugInfo() const -> std::string + { + return std::string{"GetRecurringBetweenDatesResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp b/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp new file mode 100644 index 0000000000000000000000000000000000000000..c94c503990b2420ec9b5cbff34f195502318f7ec --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp @@ -0,0 +1,37 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "module-db/Interface/AlarmEventRecord.hpp" + +#include + +#include + +namespace db::query::alarmEvents +{ + class GetRecurringBetweenDates : public Query + { + public: + GetRecurringBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const TimePoint start = TIME_POINT_INVALID; + const TimePoint end = TIME_POINT_INVALID; + const uint32_t offset = 0; + const uint32_t limit = 0; + }; + + class GetRecurringBetweenDatesResult : public QueryResult + { + const std::vector records; + + public: + explicit GetRecurringBetweenDatesResult(std::vector records); + [[nodiscard]] auto getResult() const -> std::vector; + + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsRemove.cpp b/module-db/queries/alarm_events/QueryAlarmEventsRemove.cpp new file mode 100644 index 0000000000000000000000000000000000000000..40815a967b681b2e998cba497fc1620b77bcc989 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsRemove.cpp @@ -0,0 +1,28 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsRemove.hpp" + +namespace db::query::alarmEvents +{ + Remove::Remove(const uint32_t id) : Query(Query::Type::Delete), id(id) + {} + + auto Remove::debugInfo() const -> std::string + { + return std::string{"Remove"}; + } + + RemoveResult::RemoveResult(const bool ret) : ret(ret) + {} + + auto RemoveResult::succeed() const -> bool + { + return ret; + } + + auto RemoveResult::debugInfo() const -> std::string + { + return std::string{"RemoveResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsRemove.hpp b/module-db/queries/alarm_events/QueryAlarmEventsRemove.hpp new file mode 100644 index 0000000000000000000000000000000000000000..41351775cfe901227f5b7c2d3e812519fe9b449a --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsRemove.hpp @@ -0,0 +1,32 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include + +#include + +namespace db::query::alarmEvents +{ + + class Remove : public Query + { + public: + explicit Remove(const uint32_t id); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const uint32_t id; + }; + + class RemoveResult : public QueryResult + { + const bool ret = true; + + public: + explicit RemoveResult(const bool ret); + [[nodiscard]] auto succeed() const -> bool; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-services/service-db/ServiceDB.cpp b/module-services/service-db/ServiceDB.cpp index 3505f4fa00e4479bc81a9b9db68f2e7d05db640d..c2ff87afbd6c2a7bff10b86055129ed82ceabe6b 100644 --- a/module-services/service-db/ServiceDB.cpp +++ b/module-services/service-db/ServiceDB.cpp @@ -68,6 +68,8 @@ ServiceDB::~ServiceDB() db::Interface *ServiceDB::getInterface(db::Interface::Name interface) { switch (interface) { + case db::Interface::Name::AlarmEvents: + return alarmEventRecordInterface.get(); case db::Interface::Name::SMS: return smsRecordInterface.get(); case db::Interface::Name::SMSThread: @@ -252,6 +254,7 @@ sys::ReturnCodes ServiceDB::InitHandler() quotesDB = std::make_unique((purefs::dir::getUserDiskPath() / "quotes.db").c_str()); // Create record interfaces + alarmEventRecordInterface = std::make_unique(eventsDB.get()); contactRecordInterface = std::make_unique(contactsDB.get()); smsRecordInterface = std::make_unique(smsDB.get(), contactsDB.get()); threadRecordInterface = std::make_unique(smsDB.get(), contactsDB.get()); diff --git a/module-services/service-db/ServiceDB.hpp b/module-services/service-db/ServiceDB.hpp index 96854159fb11b45b6a33b1c0876639e607d9b609..f4b85f1ba16338a064f10de18f7ecc94dd87a4cd 100644 --- a/module-services/service-db/ServiceDB.hpp +++ b/module-services/service-db/ServiceDB.hpp @@ -12,6 +12,7 @@ #include "service-fileindexer/Constants.hpp" #include +#include #include #include #include @@ -30,6 +31,7 @@ #include class AlarmsDB; +class AlarmEventRecordInterface; class AlarmsRecordInterface; class CalllogDB; class CalllogRecordInterface; @@ -66,6 +68,7 @@ class ServiceDB : public sys::Service std::unique_ptr notificationsDB; std::unique_ptr quotesDB; + std::unique_ptr alarmEventRecordInterface; std::unique_ptr smsRecordInterface; std::unique_ptr threadRecordInterface; std::unique_ptr smsTemplateRecordInterface;