From 7e26f5e014af9224a85f6be4019330146183c8ed Mon Sep 17 00:00:00 2001 From: Przemyslaw Brudny Date: Mon, 27 Sep 2021 21:34:10 +0200 Subject: [PATCH] [EGD-7670] Alarm toggle off all alarms Added toggle all alarms handling with tests. --- .../models/AlarmsRepository.cpp | 4 +- module-db/CMakeLists.txt | 1 + module-db/Interface/AlarmEventRecord.cpp | 13 +++++ module-db/Interface/AlarmEventRecord.hpp | 4 ++ module-db/Tables/AlarmEventsTable.cpp | 7 +++ module-db/Tables/AlarmEventsTable.hpp | 1 + .../QueryAlarmEventsToggleAll.cpp | 28 +++++++++ .../QueryAlarmEventsToggleAll.hpp | 32 ++++++++++ module-db/tests/AlarmEventRecord_tests.cpp | 58 +++++++++++++++++++ .../service-time/AlarmEventsDBRepository.cpp | 7 +++ .../service-time/AlarmEventsDBRepository.hpp | 1 + .../service-time/AlarmMessageHandler.cpp | 9 +++ .../service-time/AlarmMessageHandler.hpp | 1 + .../service-time/AlarmOperations.cpp | 11 ++++ .../service-time/AlarmOperations.hpp | 15 +++-- .../service-time/AlarmRepository.hpp | 7 +++ module-services/service-time/ServiceTime.cpp | 3 + .../include/service-time/AlarmMessage.hpp | 14 +++++ .../tests/tests-AlarmOperations.cpp | 48 +++++++++++++++ 19 files changed, 257 insertions(+), 7 deletions(-) create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsToggleAll.cpp create mode 100644 module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp diff --git a/module-apps/application-alarm-clock/models/AlarmsRepository.cpp b/module-apps/application-alarm-clock/models/AlarmsRepository.cpp index 34f76c7679ed030d4ed1c691a9f1fc1acc79cdff..8f9bc9864a7c38eb5c85758fbe1485392e0604dd 100644 --- a/module-apps/application-alarm-clock/models/AlarmsRepository.cpp +++ b/module-apps/application-alarm-clock/models/AlarmsRepository.cpp @@ -72,5 +72,7 @@ namespace app::alarmClock } void AlarmsDBRepository::turnOffAll(const AbstractAlarmsRepository::OnResultCallback &callback) - {} + { + GetQuery(callback, false); + } } // namespace app::alarmClock diff --git a/module-db/CMakeLists.txt b/module-db/CMakeLists.txt index a17375b948a3ef62d5c958545b5282bdc2c6c899..df79d1efff6b672e2a20c846f9346f1baf3ee379 100644 --- a/module-db/CMakeLists.txt +++ b/module-db/CMakeLists.txt @@ -64,6 +64,7 @@ set(SOURCES queries/alarm_events/QueryAlarmEventsGetNext.cpp queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.cpp queries/alarm_events/QueryAlarmEventsRemove.cpp + queries/alarm_events/QueryAlarmEventsToggleAll.cpp queries/calllog/QueryCalllogGet.cpp queries/calllog/QueryCalllogGetByContactID.cpp queries/calllog/QueryCalllogGetCount.cpp diff --git a/module-db/Interface/AlarmEventRecord.cpp b/module-db/Interface/AlarmEventRecord.cpp index b0958b3e9625265589d69437fc0ab953722bb101..9d9eee742428c0c22379a69b7816ffaa71f0d399 100644 --- a/module-db/Interface/AlarmEventRecord.cpp +++ b/module-db/Interface/AlarmEventRecord.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include @@ -71,6 +72,9 @@ std::unique_ptr AlarmEventRecordInterface::runQuery(std::shared if (typeid(*query) == typeid(db::query::alarmEvents::Remove)) { return runQueryImplRemove(std::static_pointer_cast(query)); } + if (typeid(*query) == typeid(db::query::alarmEvents::ToggleAll)) { + return runQueryImplRemove(std::static_pointer_cast(query)); + } return nullptr; } @@ -163,6 +167,15 @@ std::unique_ptr AlarmEventRecordInterface: return response; } +std::unique_ptr AlarmEventRecordInterface::runQueryImplRemove( + std::shared_ptr query) +{ + const bool ret = eventsDB->alarmEvents.toggleAll(query->toggle); + auto response = std::make_unique(ret); + response->setRequestQuery(query); + return response; +} + std::vector generateRecordsVector(const std::vector &tableRowVector) { std::vector recordVector; diff --git a/module-db/Interface/AlarmEventRecord.hpp b/module-db/Interface/AlarmEventRecord.hpp index 11a95668d3b407a4be41e89e82768613666a81bc..7fd00f38ecf6c055e4f9c7095194db45a3ead85a 100644 --- a/module-db/Interface/AlarmEventRecord.hpp +++ b/module-db/Interface/AlarmEventRecord.hpp @@ -26,6 +26,8 @@ namespace db::query::alarmEvents class GetResult; class Remove; class RemoveResult; + class ToggleAll; + class ToggleAllResult; } // namespace db::query::alarmEvents struct AlarmEventRecord : public EventRecord @@ -78,4 +80,6 @@ class AlarmEventRecordInterface : public db::Interface std::shared_ptr query); std::unique_ptr runQueryImplRemove( std::shared_ptr query); + std::unique_ptr runQueryImplRemove( + std::shared_ptr query); }; diff --git a/module-db/Tables/AlarmEventsTable.cpp b/module-db/Tables/AlarmEventsTable.cpp index 34f98158a38bde2bc3307c89f00aa46993d2a312..8f1fbb963ee11993f28428cecbd8b68be8880855 100644 --- a/module-db/Tables/AlarmEventsTable.cpp +++ b/module-db/Tables/AlarmEventsTable.cpp @@ -220,6 +220,13 @@ std::vector AlarmEventsTable::getNext(TimePoint start, uint return retQueryUnpack(std::move(retQuery)); } +auto AlarmEventsTable::toggleAll(bool toggle) -> bool +{ + auto ret = db->execute("UPDATE alarm_events SET enabled = '%d';", static_cast(toggle)); + + return ret; +} + uint32_t AlarmEventsTable::count() { auto queryRet = db->query("SELECT COUNT(*) FROM alarm_events;"); diff --git a/module-db/Tables/AlarmEventsTable.hpp b/module-db/Tables/AlarmEventsTable.hpp index 5a5b7bebc8ebf8c807aca379039d85f43725d84c..e62186322477fa3165a2beb16228a6f45296c432 100644 --- a/module-db/Tables/AlarmEventsTable.hpp +++ b/module-db/Tables/AlarmEventsTable.hpp @@ -67,6 +67,7 @@ class AlarmEventsTable : public Table std::vector; auto getNext(TimePoint start, uint32_t offset, uint32_t limit) -> std::vector; + auto toggleAll(bool toggle) -> bool; auto count() -> uint32_t override; auto countByFieldId(const char *field, uint32_t id) -> uint32_t override; diff --git a/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.cpp b/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.cpp new file mode 100644 index 0000000000000000000000000000000000000000..17469ec062b3ff4ca1f6501d498ecd917376cff6 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.cpp @@ -0,0 +1,28 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "QueryAlarmEventsToggleAll.hpp" + +namespace db::query::alarmEvents +{ + ToggleAll::ToggleAll(const bool toggle) : Query(Query::Type::Update), toggle(toggle) + {} + + auto ToggleAll::debugInfo() const -> std::string + { + return std::string{"ToggleAllResult"}; + } + + ToggleAllResult::ToggleAllResult(const bool ret) : ret(ret) + {} + + auto ToggleAllResult::getResult() const -> bool + { + return ret; + } + + auto ToggleAllResult::debugInfo() const -> std::string + { + return std::string{"ToggleAllResult"}; + } +} // namespace db::query::alarmEvents diff --git a/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp b/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ff4bbba21b428b1e0f395469269971a701350e57 --- /dev/null +++ b/module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp @@ -0,0 +1,32 @@ +// 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 + +#include + +namespace db::query::alarmEvents +{ + + class ToggleAll : public Query + { + public: + explicit ToggleAll(bool toggle); + [[nodiscard]] auto debugInfo() const -> std::string override; + + const bool toggle; + }; + + class ToggleAllResult : public QueryResult + { + const bool ret = true; + + public: + explicit ToggleAllResult(bool ret); + [[nodiscard]] auto getResult() const -> bool; + [[nodiscard]] auto debugInfo() const -> std::string override; + }; + +} // namespace db::query::alarmEvents diff --git a/module-db/tests/AlarmEventRecord_tests.cpp b/module-db/tests/AlarmEventRecord_tests.cpp index 562205cb9e67e815daea46df7ffe4ffcd226f2f2..e8f25e0e17750d68d2be21ad229c298d61318d88 100644 --- a/module-db/tests/AlarmEventRecord_tests.cpp +++ b/module-db/tests/AlarmEventRecord_tests.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -139,6 +140,15 @@ TEST_CASE("AlarmEventRecord tests") return alarmsRec; }; + auto toggleAll = [&](const bool toggle) { + auto query = std::make_shared(toggle); + auto ret = alarmEventRecordInterface.runQuery(query); + auto result = dynamic_cast(ret.get()); + REQUIRE(result != nullptr); + auto alarmsRec = result->getResult(); + return alarmsRec; + }; + SECTION("Add remove add") { auto retAlarmEvents = getLimitedQuery(0, 10); @@ -551,5 +561,53 @@ TEST_CASE("AlarmEventRecord tests") REQUIRE(alarms.size() == 2); } + SECTION("ToggleAll Alarms") + { + addQuery(testName1, + testEventStart, + testDuration, + testIsAllDay, + testEmptyRRuleText, + testMusicTone, + true, + testSnoozeDuration); + addQuery(testName2, + testEventStart, + testDuration, + testIsAllDay, + testEmptyRRuleText, + testMusicTone, + false, + testSnoozeDuration); + addQuery(testName3, + testEventStart, + testDuration, + testIsAllDay, + testEmptyRRuleText, + testMusicTone, + true, + testSnoozeDuration); + + auto retAlarmEvents = getLimitedQuery(0, 3); + REQUIRE(retAlarmEvents.size() == 3); + REQUIRE(retAlarmEvents[0].enabled); + REQUIRE(!retAlarmEvents[1].enabled); + REQUIRE(retAlarmEvents[2].enabled); + + toggleAll(false); + retAlarmEvents = getLimitedQuery(0, 3); + REQUIRE(retAlarmEvents.size() == 3); + REQUIRE(!retAlarmEvents[0].enabled); + REQUIRE(!retAlarmEvents[1].enabled); + REQUIRE(!retAlarmEvents[2].enabled); + + toggleAll(true); + retAlarmEvents = getLimitedQuery(0, 3); + REQUIRE(retAlarmEvents.size() == 3); + REQUIRE(retAlarmEvents[0].enabled); + REQUIRE(retAlarmEvents[1].enabled); + REQUIRE(retAlarmEvents[2].enabled); + } + Database::deinitialize(); } diff --git a/module-services/service-time/AlarmEventsDBRepository.cpp b/module-services/service-time/AlarmEventsDBRepository.cpp index 8e04c48a76063d763aa26a3036f4e326f3db6e18..31ffb728dd27bc96447250c82c7c32eb610ef6e3 100644 --- a/module-services/service-time/AlarmEventsDBRepository.cpp +++ b/module-services/service-time/AlarmEventsDBRepository.cpp @@ -12,6 +12,7 @@ #include #include #include +#include namespace alarms { @@ -90,6 +91,12 @@ namespace alarms OnGetAlarmEventsRecurringInRange>(callback, start, end, offset, limit); } + auto AlarmEventsDBRepository::toggleAll(bool toggle, const OnToggleAll &callback) -> void + { + sendQueryWithCallback( + callback, toggle); + } + template void AlarmEventsDBRepository::sendQueryWithCallback(const callbackT &callback, Types... queryArgs) { diff --git a/module-services/service-time/AlarmEventsDBRepository.hpp b/module-services/service-time/AlarmEventsDBRepository.hpp index 81db2de4013b7153eb1fae35fb17f1ac81ce2015..54f9460312e28b2caf447e342816ac7799b1bf17 100644 --- a/module-services/service-time/AlarmEventsDBRepository.hpp +++ b/module-services/service-time/AlarmEventsDBRepository.hpp @@ -38,6 +38,7 @@ namespace alarms std::uint32_t offset, std::uint32_t limit, const OnGetAlarmEventsRecurringInRange &callback) -> void override; + auto toggleAll(bool toggle, const OnToggleAll &callback) -> void override; private: template diff --git a/module-services/service-time/AlarmMessageHandler.cpp b/module-services/service-time/AlarmMessageHandler.cpp index 305562348f3e7b04239bfa6a0788116bce536a9b..32baadbe4bf3d2b2c87802bc8e6068acd61ccf46 100644 --- a/module-services/service-time/AlarmMessageHandler.cpp +++ b/module-services/service-time/AlarmMessageHandler.cpp @@ -52,6 +52,15 @@ namespace alarms }); } + auto AlarmMessageHandler::handleToggleAll(AlarmToggleAllRequestMessage *request) + -> std::shared_ptr + { + return handleWithCallback( + request, [&](AlarmToggleAllRequestMessage *request, IAlarmOperations::OnToggleAllProcessed callback) { + alarmOperations->toggleAll(request->toggle, callback); + }); + } + auto AlarmMessageHandler::handleGetAlarmsInRange(AlarmsGetInRangeRequestMessage *request) -> std::shared_ptr { diff --git a/module-services/service-time/AlarmMessageHandler.hpp b/module-services/service-time/AlarmMessageHandler.hpp index 3e7cc8f50567ca9b96af1612bdeecfd70f8b7251..d584916f35841917f4a26734615b6e1b53e4eace 100644 --- a/module-services/service-time/AlarmMessageHandler.hpp +++ b/module-services/service-time/AlarmMessageHandler.hpp @@ -40,6 +40,7 @@ namespace alarms auto handleAddSnoozedAlarmCountChangeCallback(AlarmOperationsCommon::OnSnoozedAlarmsCountChange callback) -> void; auto handleAddActiveAlarmCountChangeCallback(AlarmOperationsCommon::OnActiveAlarmCountChange callback) -> void; + auto handleToggleAll(AlarmToggleAllRequestMessage *request) -> std::shared_ptr; private: stm::ServiceTime *service = nullptr; diff --git a/module-services/service-time/AlarmOperations.cpp b/module-services/service-time/AlarmOperations.cpp index 8f55399bf73ebf2d68a8880dce74a3815eb3eef1..3a0af33f67cba69472a972752d51d192eaf45838 100644 --- a/module-services/service-time/AlarmOperations.cpp +++ b/module-services/service-time/AlarmOperations.cpp @@ -338,6 +338,17 @@ namespace alarms handleActiveAlarmsCountChange(); } + void AlarmOperationsCommon::toggleAll(bool toggle, OnToggleAll callback) + { + OnToggleAll repoCallback = [&, callback](bool success) mutable { + updateEventsCache(getCurrentTime()); + + callback(success); + }; + + alarmEventsRepo->toggleAll(toggle, repoCallback); + } + auto AlarmOperationsCommon::addSnoozedAlarmsCountChangeCallback(OnSnoozedAlarmsCountChange callback) -> void { onSnoozedAlarmsCountChangeCallback = callback; diff --git a/module-services/service-time/AlarmOperations.hpp b/module-services/service-time/AlarmOperations.hpp index ebc3a1e0deedafc21cca561eaddc15acebfc87a7..35abd3aed0bdc8876f76e14540ef600ce3330f51 100644 --- a/module-services/service-time/AlarmOperations.hpp +++ b/module-services/service-time/AlarmOperations.hpp @@ -26,8 +26,9 @@ namespace alarms using OnGetNextSingleProcessed = std::function)>; using OnSnoozeRingingAlarm = std::function; using OnTurnOffRingingAlarm = std::function; - using OnSnoozedAlarmsCountChange = std::function; - using OnActiveAlarmCountChange = std::function; + using OnSnoozedAlarmsCountChange = std::function; + using OnActiveAlarmCountChange = std::function; + using OnToggleAllProcessed = std::function; virtual ~IAlarmOperations() noexcept = default; @@ -52,10 +53,11 @@ namespace alarms OnSnoozeRingingAlarm callback) = 0; virtual void minuteUpdated(TimePoint now) = 0; virtual void addAlarmExecutionHandler(const alarms::AlarmType type, - const std::shared_ptr handler) = 0; - virtual void stopAllSnoozedAlarms() = 0; - virtual void addSnoozedAlarmsCountChangeCallback(OnSnoozedAlarmsCountChange) = 0; - virtual void addActiveAlarmCountChangeCallback(OnActiveAlarmCountChange) = 0; + const std::shared_ptr handler) = 0; + virtual void stopAllSnoozedAlarms() = 0; + virtual void addSnoozedAlarmsCountChangeCallback(OnSnoozedAlarmsCountChange) = 0; + virtual void addActiveAlarmCountChangeCallback(OnActiveAlarmCountChange) = 0; + virtual void toggleAll(bool toggle, OnToggleAll callback) = 0; }; class IAlarmOperationsFactory @@ -98,6 +100,7 @@ namespace alarms void stopAllSnoozedAlarms() override; void addSnoozedAlarmsCountChangeCallback(OnSnoozedAlarmsCountChange callback) override; void addActiveAlarmCountChangeCallback(OnActiveAlarmCountChange callback) override; + void toggleAll(bool toggle, OnToggleAll callback) override; protected: std::unique_ptr alarmEventsRepo; diff --git a/module-services/service-time/AlarmRepository.hpp b/module-services/service-time/AlarmRepository.hpp index a8645fa7095380a5fed955a4a6c92a454b3eec8e..e625cc93bf010b8db28cc0629faf3fbcb66f7d68 100644 --- a/module-services/service-time/AlarmRepository.hpp +++ b/module-services/service-time/AlarmRepository.hpp @@ -27,6 +27,7 @@ namespace alarms using OnRemoveAlarmEventCallback = std::function; using OnGetNextCallback = std::function)>; using OnGetAlarmEventsRecurringInRange = std::function)>; + using OnToggleAll = std::function; class AbstractAlarmEventsRepository { @@ -108,5 +109,11 @@ namespace alarms std::uint32_t offset, std::uint32_t limit, const OnGetAlarmEventsRecurringInRange &callback) = 0; + + /** + * Toggles all alarms on/off + * @param toggle disable/enable value + */ + virtual void toggleAll(bool toggle, const OnToggleAll &callback) = 0; }; } // namespace alarms diff --git a/module-services/service-time/ServiceTime.cpp b/module-services/service-time/ServiceTime.cpp index 7708210014295d21e61bd6f6c76394448d076b9b..a56fc4a998e3e04b15ba07c5389779d39aa6e1a8 100644 --- a/module-services/service-time/ServiceTime.cpp +++ b/module-services/service-time/ServiceTime.cpp @@ -142,6 +142,9 @@ namespace stm connect(typeid(alarms::AlarmRemoveRequestMessage), [&](sys::Message *request) -> sys::MessagePointer { return alarmMessageHandler->handleRemoveAlarm(static_cast(request)); }); + connect(typeid(alarms::AlarmToggleAllRequestMessage), [&](sys::Message *request) -> sys::MessagePointer { + return alarmMessageHandler->handleToggleAll(static_cast(request)); + }); connect(typeid(alarms::AlarmsGetInRangeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer { return alarmMessageHandler->handleGetAlarmsInRange( static_cast(request)); diff --git a/module-services/service-time/include/service-time/AlarmMessage.hpp b/module-services/service-time/include/service-time/AlarmMessage.hpp index 84ecfef6ccdec01535f3fd61fd6ff9cbc42a1727..159a4b50da59b3b0d60323636ab4a0f43dbd089e 100644 --- a/module-services/service-time/include/service-time/AlarmMessage.hpp +++ b/module-services/service-time/include/service-time/AlarmMessage.hpp @@ -80,6 +80,20 @@ namespace alarms const bool success; }; + class AlarmToggleAllRequestMessage : public AlarmMessage + { + public: + AlarmToggleAllRequestMessage(const bool toggle) : toggle(toggle){}; + const bool toggle; + }; + + class AlarmToggleAllResponseMessage : public AlarmResponse + { + public: + AlarmToggleAllResponseMessage(const bool success = false) : success(success){}; + const bool success; + }; + class AlarmsGetInRangeRequestMessage : public AlarmMessage { public: diff --git a/module-services/service-time/tests/tests-AlarmOperations.cpp b/module-services/service-time/tests/tests-AlarmOperations.cpp index 4aa505f6646ed8a5b6151cb3c7f91e139bd7d13b..41159b4126f9b141afca6c307f66b79ea4cff9d3 100644 --- a/module-services/service-time/tests/tests-AlarmOperations.cpp +++ b/module-services/service-time/tests/tests-AlarmOperations.cpp @@ -39,6 +39,7 @@ class MockAlarmEventsRepository : public alarms::AbstractAlarmEventsRepository std::uint32_t limit, const alarms::OnGetAlarmEventsInRangeCallback &callback), ()); + MOCK_METHOD(void, toggleAll, (const bool toggle, const alarms::OnToggleAll &callback), ()); auto addAlarmEvent(const AlarmEventRecord &alarmEvent, const alarms::OnAddAlarmEventCallback &callback) -> void { @@ -722,3 +723,50 @@ TEST_F(AlarmOperationsFixture, snoozeCountChangeCallback) alarmOperations->stopAllSnoozedAlarms(); EXPECT_EQ(i, 0); } + +TEST_F(AlarmOperationsFixture, toggleAll) +{ + alarms::IAlarmOperations::OnGetAlarmProcessed callbackOn = [](AlarmEventRecord record) { + EXPECT_TRUE(record.enabled); + }; + + alarms::IAlarmOperations::OnGetAlarmProcessed callbackOff = [](AlarmEventRecord record) { + EXPECT_FALSE(record.enabled); + }; + + auto alarmRepoMock = std::make_unique(); + auto alarmOperations = getMockedAlarmOperations(alarmRepoMock); + + alarmOperations->addAlarm(AlarmEventRecord(1, + defName, + TimePointFromString("2022-11-11 17:00:00"), + defDuration, + defAllDay, + defRRule, + defMusic, + false, + defSnooze), + universalBoolCallback); + + alarmOperations->addAlarm(AlarmEventRecord(2, + defName, + TimePointFromString("2022-11-11 17:00:00"), + defDuration, + defAllDay, + defRRule, + defMusic, + true, + defSnooze), + universalBoolCallback); + + alarmOperations->getAlarm(1, callbackOff); + alarmOperations->getAlarm(2, callbackOn); + + alarmOperations->toggleAll(true, universalBoolCallback); + alarmOperations->getAlarm(1, callbackOn); + alarmOperations->getAlarm(2, callbackOn); + + alarmOperations->toggleAll(false, universalBoolCallback); + alarmOperations->getAlarm(1, callbackOff); + alarmOperations->getAlarm(2, callbackOff); +}