From 2aaed62bd8ae5ab848f84fd7ba9f78a7d992d272 Mon Sep 17 00:00:00 2001
From: KacperLewandowski <themiddleearth1@gmail.com>
Date: Wed, 23 Sep 2020 01:06:00 +0200
Subject: [PATCH] [EGD-3699] Add notifications handling in calendar.

---
 changelog.md                                  |  7 ++
 .../ApplicationCalendar.cpp                   | 31 +++++-
 .../models/AllEventsModel.cpp                 | 23 ++++-
 .../models/AllEventsModel.hpp                 |  4 +-
 .../widgets/CalendarStyle.hpp                 |  4 +-
 .../windows/AllEventsWindow.cpp               | 33 ++-----
 .../windows/CalendarMainWindow.cpp            | 67 ++++++-------
 .../windows/CalendarMainWindow.hpp            |  2 +-
 .../windows/DayEventsWindow.cpp               | 56 ++++++-----
 .../windows/DayEventsWindow.hpp               |  1 +
 module-db/Interface/EventsRecord.cpp          | 99 +++++++++++--------
 module-db/Interface/EventsRecord.hpp          | 16 +--
 module-db/Tables/EventsTable.cpp              |  2 +-
 13 files changed, 205 insertions(+), 140 deletions(-)

diff --git a/changelog.md b/changelog.md
index 62380431c363ce6347cd2e2c73a9a2ec8e98b228..804e8fb9ce8f41e40605ac8117983af873628bcf 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,12 @@
 # Mudita PurePhone changelog
 
+## [Current release]
+
+### Added
+
+* `[calendar]` Add notifications from database handling.
+
+
 ## [0.39.1 2020-09-25]
 
 ### Added
diff --git a/module-apps/application-calendar/ApplicationCalendar.cpp b/module-apps/application-calendar/ApplicationCalendar.cpp
index 616bc525df8e7d0de404d7b02a2929256627013f..8d398b76e7a6269b37dc0450650d1e38ba6ee57a 100644
--- a/module-apps/application-calendar/ApplicationCalendar.cpp
+++ b/module-apps/application-calendar/ApplicationCalendar.cpp
@@ -12,6 +12,7 @@
 #include <module-services/service-db/api/DBServiceAPI.hpp>
 #include <module-db/queries/calendar/QueryEventsAdd.hpp>
 #include <module-services/service-db/messages/QueryMessage.hpp>
+#include <module-services/service-db/messages/DBNotificationMessage.hpp>
 
 namespace app
 {
@@ -41,7 +42,9 @@ namespace app
                                              uint32_t stackDepth,
                                              sys::ServicePriority priority)
         : Application(name, parent, false, stackDepth, priority)
-    {}
+    {
+        busChannels.push_back(sys::BusChannels::ServiceDBNotifications);
+    }
 
     sys::Message_t ApplicationCalendar::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
     {
@@ -50,6 +53,19 @@ namespace app
         if (retMsg && (dynamic_cast<sys::ResponseMessage *>(retMsg.get())->retCode == sys::ReturnCodes::Success)) {
             return retMsg;
         }
+
+        auto msg = dynamic_cast<db::NotificationMessage *>(msgl);
+        if (msg != nullptr) {
+            LOG_DEBUG("Received notification");
+            // window-specific actions
+            if (msg->interface == db::Interface::Name::Events) {
+                for (auto &[name, window] : windows) {
+                    window->onDatabaseMessage(msg);
+                }
+            }
+            return std::make_shared<sys::ResponseMessage>();
+        }
+
         // this variable defines whether message was processed.
         bool handled = false;
         // handle database response
@@ -57,8 +73,17 @@ namespace app
             handled = true;
             switch (resp->responseTo) {
             case MessageType::DBQuery: {
-                if (getCurrentWindow()->onDatabaseMessage(resp))
-                    refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
+
+                if (auto queryResponse = dynamic_cast<db::QueryResponse *>(resp)) {
+                    auto result = queryResponse->getResult();
+                    LOG_DEBUG("queryResponse != nullptr");
+                    if (result->hasListener()) {
+                        LOG_DEBUG("Has listener");
+                        if (result->handle()) {
+                            refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
+                        }
+                    }
+                }
             } break;
             default:
                 break;
diff --git a/module-apps/application-calendar/models/AllEventsModel.cpp b/module-apps/application-calendar/models/AllEventsModel.cpp
index b52bb9e5a8319df0e24e2eb8897ea2c56770afc4..858f5b5542e4c25c1ce80bc8f201a111459b3e71 100644
--- a/module-apps/application-calendar/models/AllEventsModel.cpp
+++ b/module-apps/application-calendar/models/AllEventsModel.cpp
@@ -2,6 +2,7 @@
 #include "application-calendar/widgets/AllEventsItem.hpp"
 #include "application-calendar/widgets/CalendarStyle.hpp"
 #include "module-apps/application-calendar/data/CalendarData.hpp"
+#include "module-apps/application-calendar/ApplicationCalendar.hpp"
 #include <ListView.hpp>
 #include <module-services/service-db/api/DBServiceAPI.hpp>
 #include <queries/calendar/QueryEventsGetAllLimited.hpp>
@@ -20,6 +21,8 @@ unsigned int AllEventsModel::requestRecordsCount()
 void AllEventsModel::requestRecords(const uint32_t offset, const uint32_t limit)
 {
     auto query = std::make_unique<db::query::events::GetAllLimited>(offset, limit);
+    query->setQueryListener(
+        db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
     DBServiceAPI::GetQuery(application, db::Interface::Name::Events, std::move(query));
 }
 
@@ -56,7 +59,23 @@ bool AllEventsModel::updateRecords(std::unique_ptr<std::vector<EventsRecord>> re
     list->onProviderDataUpdate();
     return true;
 }
-void AllEventsModel::setRecordsCount(const uint32_t count)
+
+auto AllEventsModel::handleQueryResponse(db::QueryResult *queryResult) -> bool
 {
-    list->setElementsCount(count);
+    auto response = dynamic_cast<db::query::events::GetAllLimitedResult *>(queryResult);
+    assert(response != nullptr);
+
+    auto records_data = response->getResult();
+    list->setElementsCount(*response->getCountResult());
+    auto records = std::make_unique<std::vector<EventsRecord>>(records_data->begin(), records_data->end());
+
+    if (records->empty()) {
+        auto app = dynamic_cast<app::ApplicationCalendar *>(application);
+        assert(application != nullptr);
+        auto filter = std::chrono::system_clock::now();
+        app->switchToNoEventsWindow(
+            utils::localize.get("app_calendar_title_main"), filter, style::window::calendar::name::all_events_window);
+    }
+
+    return this->updateRecords(std::move(records));
 }
diff --git a/module-apps/application-calendar/models/AllEventsModel.hpp b/module-apps/application-calendar/models/AllEventsModel.hpp
index 7d41d25e85a508a28082844b1d8bd26dc30d2393..b6e6c3a2ef6e909dcc1cb700dbac5c6073934d7c 100644
--- a/module-apps/application-calendar/models/AllEventsModel.hpp
+++ b/module-apps/application-calendar/models/AllEventsModel.hpp
@@ -1,9 +1,9 @@
 #pragma once
-
 #include "Application.hpp"
 #include <ListItemProvider.hpp>
 #include <DatabaseModel.hpp>
 #include <module-db/Interface/EventsRecord.hpp>
+#include <module-db/Common/Query.hpp>
 
 class AllEventsModel : public app::DatabaseModel<EventsRecord>, public gui::ListItemProvider
 {
@@ -13,10 +13,10 @@ class AllEventsModel : public app::DatabaseModel<EventsRecord>, public gui::List
     AllEventsModel(app::Application *app);
     virtual ~AllEventsModel() override = default;
 
-    void setRecordsCount(const uint32_t count);
     void requestRecords(const uint32_t offset, const uint32_t limit) override;
     bool updateRecords(std::unique_ptr<std::vector<EventsRecord>> records) override;
 
+    auto handleQueryResponse(db::QueryResult *) -> bool;
     // virtual methods for ListViewProvider
     [[nodiscard]] unsigned int getMinimalItemHeight() const override;
     gui::ListItem *getItem(gui::Order order) override;
diff --git a/module-apps/application-calendar/widgets/CalendarStyle.hpp b/module-apps/application-calendar/widgets/CalendarStyle.hpp
index 3c4f357dbfa112964a3187e128d3469a2d330017..f0be6766761e3f68758d42f5b36f0fee5c7c862f 100644
--- a/module-apps/application-calendar/widgets/CalendarStyle.hpp
+++ b/module-apps/application-calendar/widgets/CalendarStyle.hpp
@@ -82,11 +82,11 @@ namespace style
 
                 namespace eventDetail
                 {
-                    const inline int height_min    = 90;
+                    const inline int height_min        = 90;
                     const inline int height_max        = 155;
                     const inline int margin_top        = 2 * style::margins::big;
                     const inline int event_time_margin = 25;
-                    const inline int title_h       = 20;
+                    const inline int title_h           = 20;
                     const inline int label_h           = 35;
                 } // namespace eventDetail
 
diff --git a/module-apps/application-calendar/windows/AllEventsWindow.cpp b/module-apps/application-calendar/windows/AllEventsWindow.cpp
index ece090629a7f8bd5678644837740533590268e30..b5ff1389c03468da47a5cb39f753e689823678b6 100644
--- a/module-apps/application-calendar/windows/AllEventsWindow.cpp
+++ b/module-apps/application-calendar/windows/AllEventsWindow.cpp
@@ -1,5 +1,4 @@
 #include "AllEventsWindow.hpp"
-#include "module-apps/application-calendar/ApplicationCalendar.hpp"
 #include "module-apps/application-calendar/data/CalendarData.hpp"
 #include <gui/widgets/Window.hpp>
 #include <gui/widgets/BottomBar.hpp>
@@ -10,6 +9,7 @@
 #include <module-db/queries/calendar/QueryEventsGetAllLimited.hpp>
 #include <module-services/service-db/api/DBServiceAPI.hpp>
 #include <time/time_conversion.hpp>
+#include <module-services/service-db/messages/DBNotificationMessage.hpp>
 
 namespace gui
 {
@@ -53,7 +53,6 @@ namespace gui
 
     void AllEventsWindow::onBeforeShow(gui::ShowMode mode, gui::SwitchData *data)
     {
-        allEventsList->rebuildList();
         auto dataReceived = dynamic_cast<PrevWindowData *>(data);
         if (dataReceived != nullptr) {
             if (dataReceived->getData() == PrevWindowData::PrevWindow::Delete) {
@@ -81,7 +80,7 @@ namespace gui
         if (inputEvent.keyCode == gui::KeyCode::KEY_LEFT) {
             LOG_DEBUG("Switch to new event window");
             std::unique_ptr<EventRecordData> data = std::make_unique<EventRecordData>();
-            data->setDescription("New");
+            data->setDescription(style::window::calendar::new_event);
             auto event       = std::make_shared<EventsRecord>();
             event->date_from = TimePointNow();
             event->date_till = TimePointNow();
@@ -103,30 +102,16 @@ namespace gui
 
     bool AllEventsWindow::onDatabaseMessage(sys::Message *msgl)
     {
-        auto msg = dynamic_cast<db::QueryResponse *>(msgl);
-        if (msg != nullptr) {
-            auto temp = msg->getResult();
-            if (auto response = dynamic_cast<db::query::events::GetAllLimitedResult *>(temp.get())) {
-                auto records_data = response->getResult();
-                allEventsModel->setRecordsCount(*response->getCountResult());
-                auto records = std::make_unique<std::vector<EventsRecord>>(records_data->begin(), records_data->end());
-                if (checkEmpty) {
-                    if (records->size() == 0) {
-                        auto app = dynamic_cast<app::ApplicationCalendar *>(application);
-                        assert(application != nullptr);
-                        auto filter = std::chrono::system_clock::now();
-                        app->switchToNoEventsWindow(utils::localize.get("app_calendar_title_main"),
-                                                    filter,
-                                                    style::window::calendar::name::all_events_window);
-                    }
+        auto *msgNotification = dynamic_cast<db::NotificationMessage *>(msgl);
+        if (msgNotification != nullptr) {
+            if (msgNotification->interface == db::Interface::Name::Events) {
+                if (msgNotification->dataModified()) {
+                    allEventsList->rebuildList(style::listview::RebuildType::InPlace);
+                    return true;
                 }
-                application->refreshWindow(RefreshModes::GUI_REFRESH_FAST);
-                return allEventsModel->updateRecords(std::move(records));
             }
-            LOG_DEBUG("Response False");
-            return false;
         }
-        LOG_DEBUG("AllEventsWindow DB Message != QueryResponse");
+
         return false;
     }
 } /* namespace gui */
diff --git a/module-apps/application-calendar/windows/CalendarMainWindow.cpp b/module-apps/application-calendar/windows/CalendarMainWindow.cpp
index 6faebd7b1431a1a5fd228ca0ab9f458df92a2e23..4a13f5daff91c2ff87cc5f6d917a22486a5d6f27 100644
--- a/module-apps/application-calendar/windows/CalendarMainWindow.cpp
+++ b/module-apps/application-calendar/windows/CalendarMainWindow.cpp
@@ -177,8 +177,10 @@ namespace gui
         }
 
         if (inputEvent.keyCode == gui::KeyCode::KEY_LF) {
-            DBServiceAPI::GetQuery(
-                application, db::Interface::Name::Events, std::make_unique<db::query::events::GetAll>());
+            auto query = std::make_unique<db::query::events::GetAll>();
+            query->setQueryListener(
+                db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
+            DBServiceAPI::GetQuery(application, db::Interface::Name::Events, std::move(query));
             return true;
         }
 
@@ -192,46 +194,41 @@ namespace gui
         auto filter_from       = TimePointFromYearMonthDay(date_from);
         auto filter_till       = TimePointFromYearMonthDay(date_till);
         LOG_DEBUG("filter:  %s", TimePointToString(filter_till).c_str());
-        DBServiceAPI::GetQuery(application,
-                               db::Interface::Name::Events,
-                               std::make_unique<db::query::events::GetFiltered>(filter_from, filter_till));
+        auto query = std::make_unique<db::query::events::GetFiltered>(filter_from, filter_till);
+        query->setQueryListener(
+            db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
+        DBServiceAPI::GetQuery(application, db::Interface::Name::Events, std::move(query));
     }
 
-    bool CalendarMainWindow::onDatabaseMessage(sys::Message *msgl)
+    auto CalendarMainWindow::handleQueryResponse(db::QueryResult *queryResult) -> bool
     {
         std::fill(begin(isDayEmpty), end(isDayEmpty), true);
-        auto msg = dynamic_cast<db::QueryResponse *>(msgl);
-        if (msg != nullptr) {
-            auto temp = msg->getResult();
-            if (auto response = dynamic_cast<db::query::events::GetFilteredResult *>(temp.get())) {
-                unique_ptr<vector<EventsRecord>> records = response->getResult();
-                for (auto &rec : *records) {
-                    date::year_month_day recordDate = TimePointToYearMonthDay(rec.date_from);
-                    uint32_t dayNumb                = static_cast<unsigned>(recordDate.day());
-                    isDayEmpty[dayNumb - 1]         = false;
-                }
-                refresh();
-                return true;
+        if (auto response = dynamic_cast<db::query::events::GetFilteredResult *>(queryResult)) {
+            const auto records = response->getResult();
+            for (auto &rec : *records) {
+                date::year_month_day recordDate = TimePointToYearMonthDay(rec.date_from);
+                uint32_t dayNumb                = static_cast<unsigned>(recordDate.day());
+                isDayEmpty[dayNumb - 1]         = false;
             }
-            if (auto response = dynamic_cast<db::query::events::GetAllResult *>(temp.get())) {
-                unique_ptr<vector<EventsRecord>> records = response->getResult();
-                if (records->size() != 0) {
-                    application->switchWindow(style::window::calendar::name::all_events_window);
-                }
-                else {
-                    auto appCalendar = dynamic_cast<app::ApplicationCalendar *>(application);
-                    assert(appCalendar != nullptr);
-                    auto filter = TimePointFromYearMonthDay(actualDate);
-                    appCalendar->switchToNoEventsWindow(utils::localize.get("app_calendar_title_main"),
-                                                        filter,
-                                                        style::window::calendar::name::all_events_window);
-                }
-                return true;
+            refresh();
+            return true;
+        }
+        if (auto response = dynamic_cast<db::query::events::GetAllResult *>(queryResult)) {
+            const auto records = response->getResult();
+            if (!records->empty()) {
+                application->switchWindow(style::window::calendar::name::all_events_window);
             }
-            LOG_DEBUG("Response False");
-            return false;
+            else {
+                auto appCalendar = dynamic_cast<app::ApplicationCalendar *>(application);
+                assert(appCalendar != nullptr);
+                auto filter = TimePointFromYearMonthDay(actualDate);
+                appCalendar->switchToNoEventsWindow(utils::localize.get("app_calendar_title_main"),
+                                                    filter,
+                                                    style::window::calendar::name::all_events_window);
+            }
+            return true;
         }
-        LOG_DEBUG("Calendar MainWindow DB Message != QueryResponse");
+        LOG_DEBUG("Response False");
         return false;
     }
 
diff --git a/module-apps/application-calendar/windows/CalendarMainWindow.hpp b/module-apps/application-calendar/windows/CalendarMainWindow.hpp
index d60493b977bf6ac8ca15753cb6b2b064fec8f3e6..8615a351bc58c791be27eebb607f74d3b6de2d94 100644
--- a/module-apps/application-calendar/windows/CalendarMainWindow.hpp
+++ b/module-apps/application-calendar/windows/CalendarMainWindow.hpp
@@ -41,8 +41,8 @@ namespace gui
         void buildInterface() override;
         void destroyInterface() override;
         bool onInput(const gui::InputEvent &inputEvent) override;
-        bool onDatabaseMessage(sys::Message *msgl) override;
         void onBeforeShow(ShowMode mode, SwitchData *data) override;
+        auto handleQueryResponse(db::QueryResult *queryResult) -> bool;
         std::unique_ptr<MonthModel> getMonthModel()
         {
             return std::move(monthModel);
diff --git a/module-apps/application-calendar/windows/DayEventsWindow.cpp b/module-apps/application-calendar/windows/DayEventsWindow.cpp
index 573b134517871334cd1ffd67b5eefe4435d2cdc1..a86c9a96b5fed0d2a116a428d9784b3bc51bf82f 100644
--- a/module-apps/application-calendar/windows/DayEventsWindow.cpp
+++ b/module-apps/application-calendar/windows/DayEventsWindow.cpp
@@ -11,6 +11,7 @@
 #include <module-services/service-db/messages/QueryMessage.hpp>
 #include <module-db/queries/calendar/QueryEventsGetFiltered.hpp>
 #include <module-services/service-db/api/DBServiceAPI.hpp>
+#include <module-services/service-db/messages/DBNotificationMessage.hpp>
 
 namespace gui
 {
@@ -29,9 +30,10 @@ namespace gui
     void DayEventsWindow::onBeforeShow(ShowMode mode, SwitchData *data)
     {
         auto filterTill = filterFrom + std::chrono::hours(style::window::calendar::time::max_hour_24H_mode + 1);
-        DBServiceAPI::GetQuery(application,
-                               db::Interface::Name::Events,
-                               std::make_unique<db::query::events::GetFiltered>(filterFrom, filterTill));
+        auto query      = std::make_unique<db::query::events::GetFiltered>(filterFrom, filterTill);
+        query->setQueryListener(
+            db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
+        DBServiceAPI::GetQuery(application, db::Interface::Name::Events, std::move(query));
         setTitle(dayMonthTitle);
         auto dataReceived = dynamic_cast<PrevWindowData *>(data);
         if (dataReceived != nullptr) {
@@ -100,7 +102,7 @@ namespace gui
         if (inputEvent.keyCode == gui::KeyCode::KEY_LEFT) {
             LOG_DEBUG("Switch to new window - edit window");
             std::unique_ptr<EventRecordData> data = std::make_unique<EventRecordData>();
-            data->setDescription("New");
+            data->setDescription(style::window::calendar::new_event);
             auto rec       = new EventsRecord();
             rec->date_from = filterFrom;
             rec->date_till = filterFrom;
@@ -114,31 +116,37 @@ namespace gui
         return false;
     }
 
-    bool DayEventsWindow::onDatabaseMessage(sys::Message *msgl)
+    auto DayEventsWindow::handleQueryResponse(db::QueryResult *queryResult) -> bool
     {
-        auto msg = dynamic_cast<db::QueryResponse *>(msgl);
-        if (msg != nullptr) {
-            auto temp = msg->getResult();
-            if (auto response = dynamic_cast<db::query::events::GetFilteredResult *>(temp.get())) {
-                unique_ptr<vector<EventsRecord>> records = response->getResult();
-                for (auto &rec : *records) {
-                    LOG_DEBUG("record: %s", rec.title.c_str());
+        if (const auto response = dynamic_cast<db::query::events::GetFilteredResult *>(queryResult)) {
+            unique_ptr<vector<EventsRecord>> records = response->getResult();
+            if (checkEmpty) {
+                if (records->empty()) {
+                    auto app = dynamic_cast<app::ApplicationCalendar *>(application);
+                    assert(application != nullptr);
+                    auto name = dayMonthTitle;
+                    app->switchToNoEventsWindow(name, filterFrom, style::window::calendar::name::day_events_window);
                 }
-                if (checkEmpty) {
-                    if (records->size() == 0) {
-                        auto app = dynamic_cast<app::ApplicationCalendar *>(application);
-                        assert(application != nullptr);
-                        auto name = dayMonthTitle;
-                        app->switchToNoEventsWindow(name, filterFrom, style::window::calendar::name::day_events_window);
-                    }
+            }
+            dayEventsModel->loadData(std::move(records));
+            application->refreshWindow(RefreshModes::GUI_REFRESH_FAST);
+            return true;
+        }
+        LOG_DEBUG("Response False");
+        return false;
+    }
+
+    bool DayEventsWindow::onDatabaseMessage(sys::Message *msgl)
+    {
+        auto *msgNotification = dynamic_cast<db::NotificationMessage *>(msgl);
+        if (msgNotification != nullptr) {
+            if (msgNotification->interface == db::Interface::Name::Events) {
+                if (msgNotification->dataModified()) {
+                    dayEventsList->rebuildList(style::listview::RebuildType::InPlace);
+                    return true;
                 }
-                dayEventsModel->loadData(std::move(records));
-                application->refreshWindow(RefreshModes::GUI_REFRESH_FAST);
             }
-            LOG_DEBUG("Response False");
-            return false;
         }
-        LOG_DEBUG("DayWindow DB Message != QueryResponse");
         return false;
     }
 } /* namespace gui */
diff --git a/module-apps/application-calendar/windows/DayEventsWindow.hpp b/module-apps/application-calendar/windows/DayEventsWindow.hpp
index 4015c538fc210ef28762892ad6583c331256d0f3..26d849c3c009667230405df45f740f1d8cc2269a 100644
--- a/module-apps/application-calendar/windows/DayEventsWindow.hpp
+++ b/module-apps/application-calendar/windows/DayEventsWindow.hpp
@@ -30,6 +30,7 @@ namespace gui
         void rebuild() override;
         void buildInterface() override;
         void onBeforeShow(ShowMode mode, SwitchData *data) override;
+        auto handleQueryResponse(db::QueryResult *queryResult) -> bool;
 
         bool checkEmpty = false;
     };
diff --git a/module-db/Interface/EventsRecord.cpp b/module-db/Interface/EventsRecord.cpp
index accd6b58422cc34a107c7aa8f70c50e786907ab8..d715e941607d5eeca1b6e460d2cac04cdcbe4f90 100644
--- a/module-db/Interface/EventsRecord.cpp
+++ b/module-db/Interface/EventsRecord.cpp
@@ -180,81 +180,102 @@ uint32_t EventsRecordInterface::GetCount()
 std::unique_ptr<db::QueryResult> EventsRecordInterface::runQuery(std::shared_ptr<db::Query> query)
 {
     if (typeid(*query) == typeid(db::query::events::Get)) {
-        const auto local_query = dynamic_cast<const db::query::events::Get *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplGetResult(query);
     }
     if (typeid(*query) == typeid(db::query::events::GetAll)) {
-        const auto local_query = dynamic_cast<const db::query::events::GetAll *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplGetAllResult(query);
     }
     if (typeid(*query) == typeid(db::query::events::GetAllLimited)) {
-        const auto local_query = dynamic_cast<const db::query::events::GetAllLimited *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplGetAllLimitedResult(query);
     }
     if (typeid(*query) == typeid(db::query::events::GetFiltered)) {
-        const auto local_query = dynamic_cast<const db::query::events::GetFiltered *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplGetFilteredResult(query);
     }
     if (typeid(*query) == typeid(db::query::events::Add)) {
-        const auto local_query = dynamic_cast<const db::query::events::Add *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplAdd(query);
     }
     if (typeid(*query) == typeid(db::query::events::Remove)) {
-        const auto local_query = dynamic_cast<const db::query::events::Remove *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplRemove(query);
     }
     if (typeid(*query) == typeid(db::query::events::Edit)) {
-        const auto local_query = dynamic_cast<const db::query::events::Edit *>(query.get());
-        return runQueryImpl(local_query);
+        return runQueryImplEdit(query);
     }
     return nullptr;
 }
 
-std::unique_ptr<db::query::events::GetResult> EventsRecordInterface::runQueryImpl(const db::query::events::Get *query)
+std::unique_ptr<db::query::events::GetResult> EventsRecordInterface::runQueryImplGetResult(
+    std::shared_ptr<db::Query> query)
 {
-    auto value = GetByID(query->id);
-    return std::make_unique<db::query::events::GetResult>(value);
+    auto getQuery = dynamic_cast<db::query::events::Get *>(query.get());
+    assert(getQuery != nullptr);
+    auto records  = GetByID(getQuery->id);
+    auto response = std::make_unique<db::query::events::GetResult>(records);
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::GetAllResult> EventsRecordInterface::runQueryImpl(
-    const db::query::events::GetAll *query)
+std::unique_ptr<db::query::events::GetAllResult> EventsRecordInterface::runQueryImplGetAllResult(
+    std::shared_ptr<db::Query> query)
 {
     auto numberOfEvents = GetCount();
     auto records        = GetLimitOffset(0, numberOfEvents);
-    return std::make_unique<db::query::events::GetAllResult>(std::move(records));
+    auto response       = std::make_unique<db::query::events::GetAllResult>(std::move(records));
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::GetAllLimitedResult> EventsRecordInterface::runQueryImpl(
-    const db::query::events::GetAllLimited *query)
+std::unique_ptr<db::query::events::GetAllLimitedResult> EventsRecordInterface::runQueryImplGetAllLimitedResult(
+    std::shared_ptr<db::Query> query)
 {
+
+    auto getAllLimitedQuery = dynamic_cast<db::query::events::GetAllLimited *>(query.get());
+    assert(getAllLimitedQuery != nullptr);
+    auto records = GetLimitOffsetByDate(getAllLimitedQuery->offset, getAllLimitedQuery->limit);
     auto count   = GetCount();
-    auto records = GetLimitOffsetByDate(query->offset, query->limit);
-    return std::make_unique<db::query::events::GetAllLimitedResult>(std::move(records),
-                                                                    std::make_unique<uint32_t>(count));
+    auto response =
+        std::make_unique<db::query::events::GetAllLimitedResult>(std::move(records), std::make_unique<uint32_t>(count));
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::GetFilteredResult> EventsRecordInterface::runQueryImpl(
-    const db::query::events::GetFiltered *query)
+std::unique_ptr<db::query::events::GetFilteredResult> EventsRecordInterface::runQueryImplGetFilteredResult(
+    std::shared_ptr<db::Query> query)
 {
-    auto records = Select(query->filter_from, query->filter_till);
-    return std::make_unique<db::query::events::GetFilteredResult>(std::move(records));
+    auto getFilteredQuery = dynamic_cast<db::query::events::GetFiltered *>(query.get());
+    assert(getFilteredQuery != nullptr);
+    auto records  = Select(getFilteredQuery->filter_from, getFilteredQuery->filter_till);
+    auto response = std::make_unique<db::query::events::GetFilteredResult>(std::move(records));
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::AddResult> EventsRecordInterface::runQueryImpl(const db::query::events::Add *query)
+std::unique_ptr<db::query::events::AddResult> EventsRecordInterface::runQueryImplAdd(std::shared_ptr<db::Query> query)
 {
-    bool ret = Add(query->getRecord());
-    return std::make_unique<db::query::events::AddResult>(ret);
+    auto addQuery = dynamic_cast<db::query::events::Add *>(query.get());
+    assert(addQuery != nullptr);
+    bool ret      = Add(addQuery->getRecord());
+    auto response = std::make_unique<db::query::events::AddResult>(ret);
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::RemoveResult> EventsRecordInterface::runQueryImpl(
-    const db::query::events::Remove *query)
+std::unique_ptr<db::query::events::RemoveResult> EventsRecordInterface::runQueryImplRemove(
+    std::shared_ptr<db::Query> query)
 {
-    bool ret = RemoveByID(query->id);
-    return std::make_unique<db::query::events::RemoveResult>(ret);
+    auto removeQuery = dynamic_cast<db::query::events::Remove *>(query.get());
+    assert(removeQuery != nullptr);
+    bool ret      = RemoveByID(removeQuery->id);
+    auto response = std::make_unique<db::query::events::RemoveResult>(ret);
+    response->setRequestQuery(query);
+    return response;
 }
 
-std::unique_ptr<db::query::events::EditResult> EventsRecordInterface::runQueryImpl(const db::query::events::Edit *query)
+std::unique_ptr<db::query::events::EditResult> EventsRecordInterface::runQueryImplEdit(std::shared_ptr<db::Query> query)
 {
-    bool ret = Update(query->getRecord());
-    return std::make_unique<db::query::events::EditResult>(ret);
+    auto editQuery = dynamic_cast<db::query::events::Edit *>(query.get());
+    assert(editQuery != nullptr);
+    bool ret      = Update(editQuery->getRecord());
+    auto response = std::make_unique<db::query::events::EditResult>(ret);
+    response->setRequestQuery(query);
+    return response;
 }
diff --git a/module-db/Interface/EventsRecord.hpp b/module-db/Interface/EventsRecord.hpp
index 678899c1844fde0ffabd6e26b1cad37a386ec995..0ca4401149ae78de8668379bbafc9d62620e8f66 100644
--- a/module-db/Interface/EventsRecord.hpp
+++ b/module-db/Interface/EventsRecord.hpp
@@ -83,11 +83,13 @@ class EventsRecordInterface : public RecordInterface<EventsRecord, EventsRecordF
   private:
     EventsDB *eventsDb = nullptr;
 
-    std::unique_ptr<db::query::events::GetResult> runQueryImpl(const db::query::events::Get *query);
-    std::unique_ptr<db::query::events::GetAllResult> runQueryImpl(const db::query::events::GetAll *query);
-    std::unique_ptr<db::query::events::GetAllLimitedResult> runQueryImpl(const db::query::events::GetAllLimited *query);
-    std::unique_ptr<db::query::events::GetFilteredResult> runQueryImpl(const db::query::events::GetFiltered *query);
-    std::unique_ptr<db::query::events::AddResult> runQueryImpl(const db::query::events::Add *query);
-    std::unique_ptr<db::query::events::RemoveResult> runQueryImpl(const db::query::events::Remove *query);
-    std::unique_ptr<db::query::events::EditResult> runQueryImpl(const db::query::events::Edit *query);
+    std::unique_ptr<db::query::events::GetResult> runQueryImplGetResult(std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::GetAllResult> runQueryImplGetAllResult(std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::GetAllLimitedResult> runQueryImplGetAllLimitedResult(
+        std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::GetFilteredResult> runQueryImplGetFilteredResult(
+        std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::AddResult> runQueryImplAdd(std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::RemoveResult> runQueryImplRemove(std::shared_ptr<db::Query> query);
+    std::unique_ptr<db::query::events::EditResult> runQueryImplEdit(std::shared_ptr<db::Query> query);
 };
diff --git a/module-db/Tables/EventsTable.cpp b/module-db/Tables/EventsTable.cpp
index 5f49b1eab288a4998e3e19a7643d82d70817a5c9..6f3f148270a825bb71e089633c9aa9a19c85bf97 100644
--- a/module-db/Tables/EventsTable.cpp
+++ b/module-db/Tables/EventsTable.cpp
@@ -375,7 +375,7 @@ EventsTableRow EventsTable::getById(uint32_t id)
 std::vector<EventsTableRow> EventsTable::selectByDatePeriod(TimePoint date_filter, TimePoint filter_till)
 {
     auto retQuery =
-        db->query("SELECT * FROM events WHERE date_from >= date('%q') AND date_till < date('%q', 'start of day');",
+        db->query("SELECT * FROM events WHERE date_from >= date('%q') AND date_from < date('%q', 'start of day');",
                   TimePointToString(date_filter).c_str(),
                   TimePointToString(filter_till).c_str());