6 files changed, 263 insertions(+), 15 deletions(-)

M module-services/service-db/agents/quotes/QuotesAgent.cpp
M module-services/service-db/agents/quotes/QuotesAgent.hpp
M module-services/service-db/agents/quotes/QuotesQueries.hpp
M module-services/service-db/service-db/QuotesMessages.hpp
M module-services/service-db/test/test-service-db-quotes.cpp
M module-services/service-db/test/test-service-db-quotes.hpp

@@ 30,6 30,12 @@ namespace Quotes
                                std::bind(&QuotesAgent::handleEnableQuoteById, this, _1));
         parentService->connect(typeid(Messages::GetEnabledQuotesListRequest),
                                std::bind(&QuotesAgent::handleEnabledQuotesList, this, _1));
+        parentService->connect(typeid(Messages::AddQuoteRequest), std::bind(&QuotesAgent::handleAddQuote, this, _1));
+        parentService->connect(typeid(Messages::ReadQuoteRequest), std::bind(&QuotesAgent::handleReadQuote, this, _1));
+        parentService->connect(typeid(Messages::WriteQuoteRequest),
+                               std::bind(&QuotesAgent::handleWriteQuote, this, _1));
+        parentService->connect(typeid(Messages::DeleteQuoteRequest),
+                               std::bind(&QuotesAgent::handleDeleteQuote, this, _1));
     }
 
     auto QuotesAgent::getDbFilePath() -> const std::string


@@ 105,4 111,45 @@ namespace Quotes
         return sys::msgNotHandled();
     }
 
+    auto QuotesAgent::handleAddQuote(sys::Message *req) -> sys::MessagePointer
+    {
+        if (auto msg = dynamic_cast<Messages::AddQuoteRequest *>(req)) {
+            auto result = database->execute(
+                Queries::addQuote, msg->langId, msg->quote.c_str(), msg->author.c_str(), msg->enabled);
+            auto quoteId = database->getLastInsertRowId();
+            return std::make_shared<Messages::AddQuoteResponse>(result, quoteId);
+        }
+        return sys::msgNotHandled();
+    }
+
+    auto QuotesAgent::handleReadQuote(sys::Message *req) -> sys::MessagePointer
+    {
+        if (auto msg = dynamic_cast<Messages::ReadQuoteRequest *>(req)) {
+            auto result = database->query(Queries::readQuote, msg->quoteId);
+            QuoteRecord quoteRecord(result.get());
+            return std::make_shared<Messages::ReadQuoteResponse>(
+                quoteRecord.quote_id, quoteRecord.lang_id, quoteRecord.quote, quoteRecord.author, quoteRecord.enabled);
+        }
+        return sys::msgNotHandled();
+    }
+
+    auto QuotesAgent::handleWriteQuote(sys::Message *req) -> sys::MessagePointer
+    {
+        if (auto msg = dynamic_cast<Messages::WriteQuoteRequest *>(req)) {
+            auto result = database->execute(
+                Queries::writeQuote, msg->langId, msg->quote.c_str(), msg->author.c_str(), msg->enabled, msg->quoteId);
+            return std::make_shared<Messages::WriteQuoteResponse>(result);
+        }
+        return sys::msgNotHandled();
+    }
+
+    auto QuotesAgent::handleDeleteQuote(sys::Message *req) -> sys::MessagePointer
+    {
+        if (auto msg = dynamic_cast<Messages::DeleteQuoteRequest *>(req)) {
+            auto result = database->execute(Queries::deleteQuote, msg->quoteId);
+            return std::make_shared<Messages::DeleteQuoteResponse>(result);
+        }
+        return sys::msgNotHandled();
+    }
+
 } // namespace Quotes

@@ 28,6 28,10 @@ namespace Quotes
         auto handleEnableCategoryById(sys::Message *req) -> sys::MessagePointer;
         auto handleEnableQuoteById(sys::Message *req) -> sys::MessagePointer;
         auto handleEnabledQuotesList(sys::Message *req) -> sys::MessagePointer;
+        auto handleAddQuote(sys::Message *req) -> sys::MessagePointer;
+        auto handleReadQuote(sys::Message *req) -> sys::MessagePointer;
+        auto handleWriteQuote(sys::Message *req) -> sys::MessagePointer;
+        auto handleDeleteQuote(sys::Message *req) -> sys::MessagePointer;
 
       private:
         auto getDbInitString() -> const std::string override;

@@ 58,4 58,26 @@ namespace Quotes::Queries
                             and
                             CT.enabled = TRUE
                         )sql";
+
+    constexpr auto addQuote = R"sql(
+                        INSERT INTO quote_table (lang_id, quote, author, enabled)
+                        VALUES ('%lu', '%q' , '%q', '%d');
+                        )sql";
+
+    constexpr auto readQuote = R"sql(
+                        SELECT quote_id, lang_id, quote, author, enabled
+                        FROM quote_table
+                        WHERE quote_id = '%lu';
+                        )sql";
+
+    constexpr auto writeQuote = R"sql(
+                        UPDATE quote_table
+                        SET lang_id = '%lu', quote = '%q', author = '%q', enabled = '%d'
+                        WHERE quote_id = '%lu';
+                        )sql";
+
+    constexpr auto deleteQuote = R"sql(
+                        DELETE FROM quote_table
+                        WHERE quote_id = '%lu';
+                        )sql";
 } // namespace Quotes::Queries

@@ 227,5 227,86 @@ namespace Quotes
           private:
             std::unique_ptr<QuotesList> quotesList;
         };
+
+        class AddQuoteRequest : public QuotesMessage
+        {
+          public:
+            explicit AddQuoteRequest(unsigned int langId, std::string quote, std::string author, bool enabled)
+                : langId(langId), quote(std::move(quote)), author(std::move(author)), enabled(enabled)
+            {}
+            const unsigned int langId;
+            const std::string quote;
+            const std::string author;
+            const bool enabled;
+        };
+
+        class AddQuoteResponse : public QuotesMessage
+        {
+          public:
+            explicit AddQuoteResponse(bool success, unsigned int quoteId) : success(success), quoteId(quoteId)
+            {}
+            const bool success;
+            const unsigned int quoteId;
+        };
+
+        class ReadQuoteRequest : public QuotesMessage
+        {
+          public:
+            explicit ReadQuoteRequest(unsigned int quoteId) : quoteId(quoteId)
+            {}
+            const unsigned int quoteId;
+        };
+
+        class ReadQuoteResponse : public QuotesMessage
+        {
+          public:
+            explicit ReadQuoteResponse(
+                unsigned int quoteId, unsigned int langId, std::string quote, std::string author, bool enabled)
+                : quoteId(quoteId), langId(langId), quote(std::move(quote)), author(std::move(author)), enabled(enabled)
+            {}
+            const unsigned int quoteId;
+            const unsigned int langId;
+            const std::string quote;
+            const std::string author;
+            const bool enabled;
+        };
+
+        class WriteQuoteRequest : public QuotesMessage
+        {
+          public:
+            explicit WriteQuoteRequest(
+                unsigned int quoteId, unsigned int langId, std::string quote, std::string author, bool enabled)
+                : quoteId(quoteId), langId(langId), quote(std::move(quote)), author(std::move(author)), enabled(enabled)
+            {}
+            const unsigned int quoteId;
+            const unsigned int langId;
+            const std::string quote;
+            const std::string author;
+            const bool enabled;
+        };
+
+        class WriteQuoteResponse : public QuotesMessage
+        {
+          public:
+            explicit WriteQuoteResponse(bool success) : success(success)
+            {}
+            const bool success;
+        };
+
+        class DeleteQuoteRequest : public QuotesMessage
+        {
+          public:
+            explicit DeleteQuoteRequest(unsigned int quoteId) : quoteId(quoteId)
+            {}
+            const unsigned int quoteId;
+        };
+
+        class DeleteQuoteResponse : public QuotesMessage
+        {
+          public:
+            explicit DeleteQuoteResponse(bool success) : success(success)
+            {}
+            const bool success;
+        };
     } // namespace Messages
 } // namespace Quotes

@@ 48,28 48,18 @@ TEST_CASE("Quotes")
 
     SECTION("Get quotes with limit and offset")
     {
-        QuotesList quotesList;
-        quotesList.limit  = 3;
-        quotesList.offset = 4;
+        unsigned int limit  = 3;
+        unsigned int offset = 4;
 
-        auto record  = std::make_unique<QuotesList>(quotesList);
-        auto request = std::make_shared<Messages::GetQuotesListRequest>(std::move(record));
-        auto response =
-            std::dynamic_pointer_cast<Messages::GetQuotesListResponse>(tester->handleQuotesList(request.get()));
+        auto response = tester->getAllQuotes(limit, offset);
 
         REQUIRE(response->getCount() == totalNumOfQuotesInDb);
-        REQUIRE(response->getResults().size() == quotesList.limit);
+        REQUIRE(response->getResults().size() == limit);
     }
 
     SECTION("Get all quotes")
     {
-        QuotesList quotesList;
-        quotesList.limit = 0;
-
-        auto record  = std::make_unique<QuotesList>(quotesList);
-        auto request = std::make_shared<Messages::GetQuotesListRequest>(std::move(record));
-        auto response =
-            std::dynamic_pointer_cast<Messages::GetQuotesListResponse>(tester->handleQuotesList(request.get()));
+        auto response = tester->getAllQuotes();
 
         REQUIRE(response->getCount() == totalNumOfQuotesInDb);
         REQUIRE(response->getResults().size() == totalNumOfQuotesInDb);


@@ 126,5 116,54 @@ TEST_CASE("Quotes")
         REQUIRE(quotes.size() == totalNumOfQuotesInDb);
     }
 
+    SECTION("Add/Read/Write/Delete quote")
+    {
+        unsigned int langId = 1;
+        std::string quote   = "TEST QUOTE";
+        std::string author  = "TEST AUTHOR";
+        bool enabled        = true;
+
+        // Add a new quote
+        auto addQuoteResponse = tester->addQuote(langId, quote, author, enabled);
+        REQUIRE(addQuoteResponse->success);
+        const auto quoteId = addQuoteResponse->quoteId;
+
+        // Check if quotes count has increased
+        auto getAllQuotesResponse = tester->getAllQuotes();
+
+        REQUIRE(getAllQuotesResponse->getCount() == totalNumOfQuotesInDb + 1);
+        REQUIRE(getAllQuotesResponse->getResults().size() == totalNumOfQuotesInDb + 1);
+
+        // Read added quote
+        auto readQuoteResponse = tester->readQuote(quoteId);
+
+        REQUIRE(readQuoteResponse->quoteId == quoteId);
+        REQUIRE(readQuoteResponse->quote == quote);
+        REQUIRE(readQuoteResponse->author == author);
+
+        // Change added quote (overwrite)
+        quote                   = "TEST QUOTE CHANGED";
+        author                  = "TEST AUTHOR CHANGED";
+        auto writeQuoteResponse = tester->writeQuote(quoteId, langId, quote, author, enabled);
+        REQUIRE(writeQuoteResponse->success);
+
+        // Read quote if values have been properly updated
+        readQuoteResponse = tester->readQuote(quoteId);
+
+        REQUIRE(readQuoteResponse->quoteId == quoteId);
+        REQUIRE(readQuoteResponse->quote == quote);
+        REQUIRE(readQuoteResponse->author == author);
+
+        // Delete added quote
+        auto deleteQuoteResponse = tester->deleteQuote(quoteId);
+        REQUIRE(deleteQuoteResponse->success);
+
+        // Check if quotes count match count before added quote
+        getAllQuotesResponse = tester->getAllQuotes();
+
+        REQUIRE(getAllQuotesResponse->getCount() == totalNumOfQuotesInDb);
+        REQUIRE(getAllQuotesResponse->getResults().size() == totalNumOfQuotesInDb);
+    }
+
     Database::deinitialize();
 }

@@ 44,6 44,33 @@ namespace Quotes
             return QuotesAgent::handleEnabledQuotesList(req);
         }
 
+        auto handleAddQuote(Messages::AddQuoteRequest *req) -> sys::MessagePointer
+        {
+            return QuotesAgent::handleAddQuote(req);
+        }
+
+        auto handleReadQuote(Messages::ReadQuoteRequest *req) -> sys::MessagePointer
+        {
+            return QuotesAgent::handleReadQuote(req);
+        }
+
+        auto handleWriteQuote(Messages::WriteQuoteRequest *req) -> sys::MessagePointer
+        {
+            return QuotesAgent::handleWriteQuote(req);
+        }
+
+        auto getAllQuotes(unsigned int limit = 0, unsigned int offset = 0)
+            -> std::shared_ptr<Messages::GetQuotesListResponse>
+        {
+            QuotesList quotesList;
+            quotesList.limit  = limit;
+            quotesList.offset = offset;
+
+            auto record  = std::make_unique<QuotesList>(quotesList);
+            auto request = std::make_shared<Messages::GetQuotesListRequest>(std::move(record));
+            return std::dynamic_pointer_cast<Messages::GetQuotesListResponse>(handleQuotesList(request.get()));
+        }
+
         auto getQuotesByCategoryId(unsigned int categoryId) -> std::vector<QuoteRecord>
         {
             QuotesList quotesList;


@@ 83,5 110,33 @@ namespace Quotes
             auto request = std::make_shared<Messages::EnableQuoteByIdRequest>(quoteId, enable);
             return std::dynamic_pointer_cast<Messages::EnableQuoteByIdResponse>(handleEnableQuoteById(request.get()));
         }
+
+        auto addQuote(unsigned int langId, std::string quote, std::string author, bool enabled)
+            -> std::shared_ptr<Messages::AddQuoteResponse>
+        {
+            auto request =
+                std::make_shared<Messages::AddQuoteRequest>(langId, std::move(quote), std::move(author), enabled);
+            return std::dynamic_pointer_cast<Messages::AddQuoteResponse>(handleAddQuote(request.get()));
+        }
+
+        auto readQuote(unsigned int quoteId) -> std::shared_ptr<Messages::ReadQuoteResponse>
+        {
+            auto request = std::make_shared<Messages::ReadQuoteRequest>(quoteId);
+            return std::dynamic_pointer_cast<Messages::ReadQuoteResponse>(handleReadQuote(request.get()));
+        }
+
+        auto writeQuote(unsigned int quoteId, unsigned int langId, std::string quote, std::string author, bool enabled)
+            -> std::shared_ptr<Messages::WriteQuoteResponse>
+        {
+            auto request = std::make_shared<Messages::WriteQuoteRequest>(
+                quoteId, langId, std::move(quote), std::move(author), enabled);
+            return std::dynamic_pointer_cast<Messages::WriteQuoteResponse>(handleWriteQuote(request.get()));
+        }
+
+        auto deleteQuote(unsigned int quoteId) -> std::shared_ptr<Messages::DeleteQuoteResponse>
+        {
+            auto request = std::make_shared<Messages::DeleteQuoteRequest>(quoteId);
+            return std::dynamic_pointer_cast<Messages::DeleteQuoteResponse>(handleDeleteQuote(request.get()));
+        }
     };
 } // namespace Quotes