19 files changed, 257 insertions(+), 7 deletions(-)

M module-apps/application-alarm-clock/models/AlarmsRepository.cpp
M module-db/CMakeLists.txt
M module-db/Interface/AlarmEventRecord.cpp
M module-db/Interface/AlarmEventRecord.hpp
M module-db/Tables/AlarmEventsTable.cpp
M module-db/Tables/AlarmEventsTable.hpp
A module-db/queries/alarm_events/QueryAlarmEventsToggleAll.cpp
A module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp
M module-db/tests/AlarmEventRecord_tests.cpp
M module-services/service-time/AlarmEventsDBRepository.cpp
M module-services/service-time/AlarmEventsDBRepository.hpp
M module-services/service-time/AlarmMessageHandler.cpp
M module-services/service-time/AlarmMessageHandler.hpp
M module-services/service-time/AlarmOperations.cpp
M module-services/service-time/AlarmOperations.hpp
M module-services/service-time/AlarmRepository.hpp
M module-services/service-time/ServiceTime.cpp
M module-services/service-time/include/service-time/AlarmMessage.hpp
M module-services/service-time/tests/tests-AlarmOperations.cpp

@@ 72,5 72,7 @@ namespace app::alarmClock
     }
 
     void AlarmsDBRepository::turnOffAll(const AbstractAlarmsRepository::OnResultCallback &callback)
-    {}
+    {
+        GetQuery<alarms::AlarmToggleAllRequestMessage, alarms::AlarmToggleAllResponseMessage>(callback, false);
+    }
 } // namespace app::alarmClock

@@ 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

@@ 12,6 12,7 @@
 #include <queries/alarm_events/QueryAlarmEventsGetNext.hpp>
 #include <queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp>
 #include <queries/alarm_events/QueryAlarmEventsRemove.hpp>
+#include <queries/alarm_events/QueryAlarmEventsToggleAll.hpp>
 
 #include <rrule/rrule.hpp>
 


@@ 71,6 72,9 @@ std::unique_ptr<db::QueryResult> AlarmEventRecordInterface::runQuery(std::shared
     if (typeid(*query) == typeid(db::query::alarmEvents::Remove)) {
         return runQueryImplRemove(std::static_pointer_cast<db::query::alarmEvents::Remove>(query));
     }
+    if (typeid(*query) == typeid(db::query::alarmEvents::ToggleAll)) {
+        return runQueryImplRemove(std::static_pointer_cast<db::query::alarmEvents::ToggleAll>(query));
+    }
     return nullptr;
 }
 


@@ 163,6 167,15 @@ std::unique_ptr<db::query::alarmEvents::RemoveResult> AlarmEventRecordInterface:
     return response;
 }
 
+std::unique_ptr<db::query::alarmEvents::ToggleAllResult> AlarmEventRecordInterface::runQueryImplRemove(
+    std::shared_ptr<db::query::alarmEvents::ToggleAll> query)
+{
+    const bool ret = eventsDB->alarmEvents.toggleAll(query->toggle);
+    auto response  = std::make_unique<db::query::alarmEvents::ToggleAllResult>(ret);
+    response->setRequestQuery(query);
+    return response;
+}
+
 std::vector<AlarmEventRecord> generateRecordsVector(const std::vector<AlarmEventsTableRow> &tableRowVector)
 {
     std::vector<AlarmEventRecord> recordVector;

@@ 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<db::query::alarmEvents::GetRecurringBetweenDates> query);
     std::unique_ptr<db::query::alarmEvents::RemoveResult> runQueryImplRemove(
         std::shared_ptr<db::query::alarmEvents::Remove> query);
+    std::unique_ptr<db::query::alarmEvents::ToggleAllResult> runQueryImplRemove(
+        std::shared_ptr<db::query::alarmEvents::ToggleAll> query);
 };

@@ 220,6 220,13 @@ std::vector<AlarmEventsTableRow> 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<int>(toggle));
+
+    return ret;
+}
+
 uint32_t AlarmEventsTable::count()
 {
     auto queryRet = db->query("SELECT COUNT(*) FROM alarm_events;");

@@ 67,6 67,7 @@ class AlarmEventsTable : public Table<AlarmEventsTableRow, AlarmEventsTableField
     auto getRecurringBetweenDates(TimePoint startDate, TimePoint endDate, uint32_t offset, uint32_t limit)
         -> std::vector<AlarmEventsTableRow>;
     auto getNext(TimePoint start, uint32_t offset, uint32_t limit) -> std::vector<AlarmEventsTableRow>;
+    auto toggleAll(bool toggle) -> bool;
 
     auto count() -> uint32_t override;
     auto countByFieldId(const char *field, uint32_t id) -> uint32_t override;

@@ 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

@@ 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 <Common/Query.hpp>
+
+#include <string>
+
+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

@@ 14,6 14,7 @@
 #include <queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp>
 #include <queries/alarm_events/QueryAlarmEventsGetNext.hpp>
 #include <queries/alarm_events/QueryAlarmEventsRemove.hpp>
+#include <queries/alarm_events/QueryAlarmEventsToggleAll.hpp>
 #include <catch2/catch.hpp>
 
 #include <algorithm>


@@ 139,6 140,15 @@ TEST_CASE("AlarmEventRecord tests")
         return alarmsRec;
     };
 
+    auto toggleAll = [&](const bool toggle) {
+        auto query  = std::make_shared<db::query::alarmEvents::ToggleAll>(toggle);
+        auto ret    = alarmEventRecordInterface.runQuery(query);
+        auto result = dynamic_cast<db::query::alarmEvents::ToggleAllResult *>(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();
 }

@@ 12,6 12,7 @@
 #include <module-db/queries/alarm_events/QueryAlarmEventsGetNext.hpp>
 #include <module-db/queries/alarm_events/QueryAlarmEventsGetRecurringBetweenDates.hpp>
 #include <module-db/queries/alarm_events/QueryAlarmEventsRemove.hpp>
+#include <module-db/queries/alarm_events/QueryAlarmEventsToggleAll.hpp>
 
 namespace alarms
 {


@@ 90,6 91,12 @@ namespace alarms
                               OnGetAlarmEventsRecurringInRange>(callback, start, end, offset, limit);
     }
 
+    auto AlarmEventsDBRepository::toggleAll(bool toggle, const OnToggleAll &callback) -> void
+    {
+        sendQueryWithCallback<db::query::alarmEvents::ToggleAll, db::query::alarmEvents::ToggleAllResult, OnToggleAll>(
+            callback, toggle);
+    }
+
     template <typename requestT, typename responseT, typename callbackT, typename... Types>
     void AlarmEventsDBRepository::sendQueryWithCallback(const callbackT &callback, Types... queryArgs)
     {

@@ 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 <typename requestT, typename responseT, typename callbackT, typename... Types>

@@ 52,6 52,15 @@ namespace alarms
             });
     }
 
+    auto AlarmMessageHandler::handleToggleAll(AlarmToggleAllRequestMessage *request)
+        -> std::shared_ptr<AlarmToggleAllResponseMessage>
+    {
+        return handleWithCallback<AlarmToggleAllRequestMessage, AlarmToggleAllResponseMessage, bool>(
+            request, [&](AlarmToggleAllRequestMessage *request, IAlarmOperations::OnToggleAllProcessed callback) {
+                alarmOperations->toggleAll(request->toggle, callback);
+            });
+    }
+
     auto AlarmMessageHandler::handleGetAlarmsInRange(AlarmsGetInRangeRequestMessage *request)
         -> std::shared_ptr<AlarmsGetInRangeResponseMessage>
     {

@@ 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<AlarmToggleAllResponseMessage>;
 
       private:
         stm::ServiceTime *service = nullptr;

@@ 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;

@@ 26,8 26,9 @@ namespace alarms
         using OnGetNextSingleProcessed      = std::function<void(std::vector<SingleEventRecord>)>;
         using OnSnoozeRingingAlarm          = std::function<void(bool)>;
         using OnTurnOffRingingAlarm         = std::function<void(bool)>;
-        using OnSnoozedAlarmsCountChange  = std::function<void(unsigned)>;
-        using OnActiveAlarmCountChange    = std::function<void(bool)>;
+        using OnSnoozedAlarmsCountChange    = std::function<void(unsigned)>;
+        using OnActiveAlarmCountChange      = std::function<void(bool)>;
+        using OnToggleAllProcessed          = std::function<void(bool)>;
 
         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<alarms::AlarmHandler> handler) = 0;
-        virtual void stopAllSnoozedAlarms()                                                        = 0;
-        virtual void addSnoozedAlarmsCountChangeCallback(OnSnoozedAlarmsCountChange)               = 0;
-        virtual void addActiveAlarmCountChangeCallback(OnActiveAlarmCountChange)                   = 0;
+                                              const std::shared_ptr<alarms::AlarmHandler> 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<AbstractAlarmEventsRepository> alarmEventsRepo;

@@ 27,6 27,7 @@ namespace alarms
     using OnRemoveAlarmEventCallback       = std::function<void(bool)>;
     using OnGetNextCallback                = std::function<void(std::vector<AlarmEventRecord>)>;
     using OnGetAlarmEventsRecurringInRange = std::function<void(std::vector<AlarmEventRecord>)>;
+    using OnToggleAll                      = std::function<void(bool)>;
 
     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

@@ 142,6 142,9 @@ namespace stm
         connect(typeid(alarms::AlarmRemoveRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
             return alarmMessageHandler->handleRemoveAlarm(static_cast<alarms::AlarmRemoveRequestMessage *>(request));
         });
+        connect(typeid(alarms::AlarmToggleAllRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
+            return alarmMessageHandler->handleToggleAll(static_cast<alarms::AlarmToggleAllRequestMessage *>(request));
+        });
         connect(typeid(alarms::AlarmsGetInRangeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
             return alarmMessageHandler->handleGetAlarmsInRange(
                 static_cast<alarms::AlarmsGetInRangeRequestMessage *>(request));

@@ 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:

@@ 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<MockAlarmEventsRepository>();
+    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);
+}