13 files changed, 205 insertions(+), 140 deletions(-)

M changelog.md
M module-apps/application-calendar/ApplicationCalendar.cpp
M module-apps/application-calendar/models/AllEventsModel.cpp
M module-apps/application-calendar/models/AllEventsModel.hpp
M module-apps/application-calendar/widgets/CalendarStyle.hpp
M module-apps/application-calendar/windows/AllEventsWindow.cpp
M module-apps/application-calendar/windows/CalendarMainWindow.cpp
M module-apps/application-calendar/windows/CalendarMainWindow.hpp
M module-apps/application-calendar/windows/DayEventsWindow.cpp
M module-apps/application-calendar/windows/DayEventsWindow.hpp
M module-db/Interface/EventsRecord.cpp
M module-db/Interface/EventsRecord.hpp
M module-db/Tables/EventsTable.cpp

@@ 1,5 1,12 @@
 # Mudita PurePhone changelog
 
+## [Current release]
+
+### Added
+
+* `[calendar]` Add notifications from database handling.
+
+
 ## [0.39.1 2020-09-25]
 
 ### Added

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

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

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

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

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

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

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

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

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

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

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

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