~aleteoryx/muditaos

7424b4be5859bf6528fcb64f6b3d128abb65f89d — Alek Rudnik 4 years ago c9a41b4 
[EGD-7433] Remove legacy fileindexer database

Removed legacy fileindexer database. New one is already implemented.
patch browse .tar.gz 
10 files changed, 0 insertions(+), 1185 deletions(-)

D image/user/db/file_indexer_001.sql
D image/user/db/file_indexer_002.sql
M module-services/service-db/CMakeLists.txt
D module-services/service-db/agents/file_indexer/FileIndexerAgent.cpp
D module-services/service-db/agents/file_indexer/FileIndexerAgent.hpp
D module-services/service-db/agents/file_indexer/FileIndexer_queries.hpp
D module-services/service-db/test/test-service-db-file_indexer.cpp
D module-services/service-db/test/test-service-db-file_indexer.hpp
M products/BellHybrid/services/db/ServiceDB.cpp
M products/PurePhone/services/db/ServiceDB.cpp

D image/user/db/file_indexer_001.sql => image/user/db/file_indexer_001.sql +0 -36
@@ 1,36 0,0 @@
-- Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
-- For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

-- Main file table
CREATE TABLE IF NOT EXISTS file_tab (
    file_id INTEGER,
    path TEXT NOT NULL UNIQUE,
    size INTEGER,
    mime_type INTEGER,
    mtime INTEGER,
    directory TEXT,
    file_type INTEGER,
    PRIMARY KEY (file_id),
    CONSTRAINT file_path_unique
        UNIQUE (file_id, path) ON CONFLICT REPLACE
    );

-- Table contains information
-- about file metadata.
CREATE TABLE IF NOT EXISTS metadata_tab (
    file_id INTEGER NOT NULL,
    property TEXT NOT NULL,
    value TEXT NOT NULL,
    PRIMARY KEY (file_id, property),
    FOREIGN KEY (file_id) REFERENCES file_tab(file_id)
    );

-- Table contains information who to inform
-- about changes in values.
CREATE TABLE IF NOT EXISTS notifications_tab (
    id INTEGER PRIMARY KEY,
    path TEXT NOT NULL,
    service TEXT,
    CONSTRAINT notification_unique
         UNIQUE(path, service)
);


D image/user/db/file_indexer_002.sql => image/user/db/file_indexer_002.sql +0 -26
@@ 1,26 0,0 @@
-- Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
-- For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

INSERT OR REPLACE INTO file_tab (file_id, path, size, mime_type, mtime, directory, file_type) VALUES
    (1, 'mp3/track1.mp3', 456666, 1, 1603929600, 'mp3',12297),
    (2, 'mp3/track2.mp3', 345354 ,1, 1603929604, 'mp3',12297),
    (3, 'mp3/track3.mp3', 34534 ,1, 1603929604, 'mp3',12297),
    (4, 'mp3/track4.mp3', 345354 ,1, 1603929604, 'mp3',12297);


INSERT OR REPLACE INTO metadata_tab (file_id, property, value) VALUES
    (1,'artist','Sting'),
    (1,'genre','Rock'),
    (1,'album','Album1'),
    (2,'artist','Madonna'),
    (2,'genre','Rock'),
    (2,'album','Album2'),
    (3,'artist','Lady Gaga'),
    (3,'genre','Rock'),
    (3,'album','Album3'),
    (4,'artist','Nick Levis'),
    (4,'genre','Soul'),
    (4,'album','Album4');

INSERT OR REPLACE INTO notifications_tab (id, path, service) VALUES
    (1,'mp3','ServiceDB');


M module-services/service-db/CMakeLists.txt => module-services/service-db/CMakeLists.txt +0 -2
@@ 18,7 18,6 @@ set(SOURCES
    agents/settings/SettingsProxy.cpp
    agents/settings/SettingsCache.cpp
    agents/settings/FactorySettings.cpp
    agents/file_indexer/FileIndexerAgent.cpp
    agents/quotes/QuotesAgent.cpp
)



@@ 42,4 41,3 @@ target_link_libraries(${PROJECT_NAME}
if (${ENABLE_TESTS})
    add_subdirectory(test)
endif ()



D module-services/service-db/agents/file_indexer/FileIndexerAgent.cpp => module-services/service-db/agents/file_indexer/FileIndexerAgent.cpp +0 -535
@@ 1,535 0,0 @@
// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include "FileIndexerAgent.hpp"
#include "FileIndexer_queries.hpp"

#include <log.hpp>
#include <purefs/filesystem_paths.hpp>
#include <Application.hpp>
#include <memory>

FileIndexerAgent::FileIndexerAgent(sys::Service *parentService) : DatabaseAgent(parentService)
{
    database = std::make_unique<Database>(getDbFilePath().c_str());
}

void FileIndexerAgent::initDb()
{
    auto notifications = database->query(FileIndexer::Statements::getAllNotifications);
    if (nullptr == notifications || DatabaseAgent::ONE_ROW_FOUND == notifications->getRowCount()) {
        return;
    }
    if (notifications->getFieldCount() == FileIndexer::NOTIFICATION_RECORD_COLUMN_COUNT) {
        fileChangeRecipents.clear();
        do {
            std::string directory = (*notifications)[1].getString();
            std::string service   = (*notifications)[2].getString();
            fileChangeRecipents[directory].insert(service);
        } while (notifications->nextRow());
    }
}

void FileIndexerAgent::deinitDb()
{
    database->deinitialize();
}

void FileIndexerAgent::registerMessages()
{
    // connect handler & message in parent service
    using std::placeholders::_1;

    // all API asynchronic
    parentService->connect(FileIndexer::Messages::GetListDirRequest(),
                           std::bind(&FileIndexerAgent::handleListDir, this, _1));

    parentService->connect(FileIndexer::Messages::GetRecordMessage(),
                           std::bind(&FileIndexerAgent::handleGetRecord, this, _1));
    parentService->connect(FileIndexer::Messages::SetRecordMessage(),
                           std::bind(&FileIndexerAgent::handleSetRecord, this, _1));

    parentService->connect(FileIndexer::Messages::GetPropertyMessage(),
                           std::bind(&FileIndexerAgent::handleGetProperty, this, _1));
    parentService->connect(FileIndexer::Messages::SetPropertyMessage(),
                           std::bind(&FileIndexerAgent::handleSetProperty, this, _1));

    parentService->connect(FileIndexer::Messages::GetAllPropertiesMessage(),
                           std::bind(&FileIndexerAgent::handleGetAllProperties, this, _1));
    parentService->connect(FileIndexer::Messages::SetPropertiesMessage(),
                           std::bind(&FileIndexerAgent::handleSetProperties, this, _1));

    parentService->connect(FileIndexer::Messages::DeleteFileMessage(),
                           std::bind(&FileIndexerAgent::handleDeleteFile, this, _1));
    parentService->connect(FileIndexer::Messages::DeleteAllFilesInDirMessage(),
                           std::bind(&FileIndexerAgent::handleDeleteAllFilesInDir, this, _1));

    parentService->connect(FileIndexer::Messages::RegisterOnFileChange(),
                           std::bind(&FileIndexerAgent::handleRegisterOnFileChange, this, _1));
    parentService->connect(FileIndexer::Messages::UnregisterOnFileChange(),
                           std::bind(&FileIndexerAgent::handleUnregisterOnFileChange, this, _1));
}

auto FileIndexerAgent::getDbInitString() -> const std::string
{
    return {};
}

auto FileIndexerAgent::getDbFilePath() -> const std::string
{
    return (purefs::dir::getUserDiskPath() / "file_indexer.db").string();
}
auto FileIndexerAgent::getAgentName() -> const std::string
{
    return std::string("fileIndexerAgent");
}

auto FileIndexerAgent::dbRegisterFileChange(std::string dir, std::string service) -> bool
{
    auto retQuery = database->query(FileIndexer::Statements::getNotification, dir.c_str(), service.c_str());
    if (nullptr == retQuery || DatabaseAgent::ZERO_ROWS_FOUND == retQuery->getRowCount()) {
        // notification does not exist in db, insert a new one
        return database->execute(FileIndexer::Statements::setNotification, dir.c_str(), service.c_str());
    }
    // service already registered for the dir
    return false;
}

auto FileIndexerAgent::dbUnregisterFileChange(std::string dir, std::string service) -> bool
{
    return database->execute(FileIndexer::Statements::clearNotificationdRow, dir.c_str(), service.c_str());
}

auto FileIndexerAgent::handleRegisterOnFileChange(sys::Message *req) -> sys::MessagePointer
{
    std::string directory;
    if (auto msg = dynamic_cast<FileIndexer::Messages::RegisterOnFileChange *>(req)) {
        if (msg->directory != nullptr) {
            directory = *(msg->directory);
            if (dbRegisterFileChange(directory, msg->sender)) {
                auto it = fileChangeRecipents.find(directory);
                if (fileChangeRecipents.end() == it) {
                    fileChangeRecipents[directory] = {msg->sender};
                }
                else {
                    it->second.insert(msg->sender);
                }
            }
        }
    }
    LOG_INFO("RegisterOnFileChange from %s", req->sender.c_str());
    return std::make_shared<sys::ResponseMessage>();
}

auto FileIndexerAgent::handleUnregisterOnFileChange(sys::Message *req) -> sys::MessagePointer
{
    std::string directory;
    if (auto msg = dynamic_cast<FileIndexer::Messages::UnregisterOnFileChange *>(req)) {
        if (msg->directory != nullptr) {
            directory = *(msg->directory);
            if (dbUnregisterFileChange(directory, msg->sender)) {
                auto it = fileChangeRecipents.find(directory);
                if (fileChangeRecipents.end() != it) {
                    it->second.erase(msg->sender);
                }
            }
        }
    }
    LOG_INFO("UnRegisterOnFileChange from %s", req->sender.c_str());
    return std::make_shared<sys::ResponseMessage>();
}

auto FileIndexerAgent::dbGetFilesCount() -> unsigned int
{
    auto retQuery = database->query(FileIndexer::Statements::getFilesCount);
    if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
        return 0;
    }
    return (*retQuery)[0].getUInt32();
}

auto FileIndexerAgent::dbGeMetadataCount() -> unsigned int
{
    auto retQuery = database->query(FileIndexer::Statements::getMetadataCount);
    if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
        return 0;
    }
    return (*retQuery)[0].getUInt32();
}

auto FileIndexerAgent::dbListDir(unsigned int offset, unsigned int limit, const std::string &directory)
    -> std::unique_ptr<FileIndexer::ListDir>
{
    auto retQuery = database->query(FileIndexer::Statements::getFilesByDir, directory.c_str());
    return getList<FileIndexer::ListDir, FileIndexer::FileRecord>(offset, limit, std::move(retQuery));
}

auto FileIndexerAgent::handleListDir(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::GetListDirRequest *>(req)) {
        return std::make_shared<FileIndexer::Messages::GetListDirResponse>(
            dbListDir(msg->offset, msg->limit, msg->directory));
    }
    return std::make_shared<sys::ResponseMessage>();
}

auto FileIndexerAgent::dbGetRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> FileIndexer::FileRecord
{
    std::unique_ptr<QueryResult> retQuery = nullptr;

    if (false == record->path.empty()) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoByPath, record->path.c_str());
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return FileIndexer::FileRecord{};
        }
    }
    else if (record->file_id != FileIndexer::FILE_ID_NOT_EXISTS) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoById, record->file_id);
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return FileIndexer::FileRecord{};
        }
    }
    else {
        return FileIndexer::FileRecord{};
    }
    return FileIndexer::FileRecord(retQuery.get());
}

auto FileIndexerAgent::dbSetRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> bool
{
    auto retQuery = database->query(FileIndexer::Statements::getFileInfoByPath, record->path.c_str());
    FileIndexer::FileRecord retRecord(retQuery.get());

    if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
        // file do not exist in db, insert a new file record
        return database->execute(FileIndexer::Statements::insertFileInfo,
                                 // retRecord.file_id,
                                 record->path.c_str(),
                                 record->size,
                                 record->mime_type,
                                 record->mtime,
                                 record->directory.c_str(),
                                 record->file_type);
    }
    // update existing file record
    return database->execute(FileIndexer::Statements::updateFileInfo,
                             record->path.c_str(),
                             record->size,
                             record->mime_type,
                             record->mtime,
                             record->directory.c_str(),
                             record->file_type,
                             retRecord.file_id);
}

auto FileIndexerAgent::dbDeleteFile(std::unique_ptr<FileIndexer::FileRecord> record) -> bool
{
    unsigned int file_id = FileIndexer::FILE_ID_NOT_EXISTS;
    if (false == record->path.empty()) {
        auto retQuery = database->query(FileIndexer::Statements::getFileIdByPath, record->path.c_str());
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return false;
        }
        else {
            file_id = (*retQuery)[0].getUInt32();
        }
    }
    else {
        file_id = record->file_id;
    }
    return database->execute(FileIndexer::Statements::deleteFileById, file_id, file_id);
}

auto FileIndexerAgent::dbDeleteAllFilesInDir(std::unique_ptr<FileIndexer::FileRecord> record) -> bool
{
    bool retStatus = false;
    if (false == record->directory.empty()) {
        auto retQuery = database->query(FileIndexer::Statements::getFilesIdByDir, record->directory.c_str());
        if (nullptr == retQuery || DatabaseAgent::ZERO_ROWS_FOUND == retQuery->getRowCount()) {
            return false;
        }
        else {
            do {
                unsigned int file_id = (*retQuery)[0].getUInt32();
                retStatus            = database->execute(FileIndexer::Statements::deleteFileById, file_id, file_id);
            } while (retQuery->nextRow() && retStatus);
            return retStatus;
        }
    }
    else {
        return false;
    }
}

auto FileIndexerAgent::dbUpdateRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> bool
{
    return database->execute(FileIndexer::Statements::updateFileInfo,
                             record->path.c_str(),
                             record->size,
                             record->mime_type,
                             record->mtime,
                             record->directory.c_str(),
                             record->file_type,
                             record->file_id);
}

auto FileIndexerAgent::handleGetRecord(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::GetRecordMessage *>(req)) {
        auto record   = std::move(msg->record);
        msg->dbRecord = dbGetRecord(std::move(record));
        return std::make_shared<FileIndexer::Messages::GetRecordResponseMessage>(
            std::make_unique<FileIndexer::FileRecord>(msg->dbRecord));
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleSetRecord(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::SetRecordMessage *>(req)) {
        auto recordPtr                 = std::move(msg->record);
        FileIndexer::FileRecord record = *recordPtr;
        msg->dbRecord                  = dbGetRecord(std::make_unique<FileIndexer::FileRecord>(record));

        if (!(msg->dbRecord.RecordEqual(record))) {
            auto updateMsg = std::make_shared<FileIndexer::Messages::RecordChangedMessage>(
                std::move(recordPtr), std::make_unique<FileIndexer::FileRecord>(msg->dbRecord));

            parentService->bus.sendUnicast(std::move(updateMsg), msg->sender);
            dbSetRecord(std::make_unique<FileIndexer::FileRecord>(record));

            for (auto recipient : fileChangeRecipents[record.directory]) {
                auto notifyMsg = std::make_shared<FileIndexer::Messages::DirectoryContentChangedMessage>(
                    std::make_unique<std::string>(record.directory));
                parentService->bus.sendUnicast(std::move(notifyMsg), recipient);
            }
        }
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleDeleteFile(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::DeleteFileMessage *>(req)) {
        auto recordPtr                 = std::move(msg->record);
        FileIndexer::FileRecord record = *recordPtr;
        msg->dbRecord                  = dbGetRecord(std::make_unique<FileIndexer::FileRecord>(record));

        auto deleteMsg = std::make_shared<FileIndexer::Messages::FileDeletedMessage>(std::move(recordPtr));

        parentService->bus.sendUnicast(std::move(deleteMsg), msg->sender);
        dbDeleteFile(std::make_unique<FileIndexer::FileRecord>(record));

        for (auto recipient : fileChangeRecipents[record.directory]) {
            auto notifyMsg = std::make_shared<FileIndexer::Messages::DirectoryContentChangedMessage>(
                std::make_unique<std::string>(record.directory));
            parentService->bus.sendUnicast(std::move(notifyMsg), recipient);
        }
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleDeleteAllFilesInDir(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::DeleteAllFilesInDirMessage *>(req)) {
        auto recordPtr                 = std::move(msg->record);
        FileIndexer::FileRecord record = *recordPtr;
        msg->dbRecord                  = dbGetRecord(std::make_unique<FileIndexer::FileRecord>(record));

        auto deleteMsg =
            std::make_shared<FileIndexer::Messages::AllFilesInDirDeletedDeletedMessage>(std::move(recordPtr));

        parentService->bus.sendUnicast(std::move(deleteMsg), msg->sender);
        dbDeleteAllFilesInDir(std::make_unique<FileIndexer::FileRecord>(record));

        for (auto recipient : fileChangeRecipents[record.directory]) {
            auto notifyMsg = std::make_shared<FileIndexer::Messages::DirectoryContentChangedMessage>(
                std::make_unique<std::string>(record.directory));
            parentService->bus.sendUnicast(std::move(notifyMsg), recipient);
        }
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::dbGetProperty(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> FileIndexer::FileMetadata
{
    auto itr      = metaData->properties.begin();
    auto property = itr->first;

    std::unique_ptr<QueryResult> retQuery = nullptr;

    retQuery = database->query(FileIndexer::Statements::getPropertyValue, property.c_str(), metaData->path.c_str());
    if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
        return *metaData;
    }
    FileIndexer::FileMetadata retMetaData;
    retMetaData.file_id = (*retQuery)[0].getUInt32();
    retMetaData.properties.clear();
    retMetaData.properties.emplace((*retQuery)[1].getString(), (*retQuery)[2].getString());
    return retMetaData;
}

auto FileIndexerAgent::dbGetAllProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData)
    -> FileIndexer::FileMetadata
{
    std::unique_ptr<QueryResult> retQuery = nullptr;
    FileIndexer::FileMetadata retMetaData = {};

    retQuery = database->query(FileIndexer::Statements::getAllProperties, metaData->path.c_str());
    if (nullptr == retQuery) {
        return retMetaData;
    }
    if (retQuery->getRowCount() > 0) {
        retMetaData.file_id = (*retQuery)[0].getUInt32();
        retMetaData.properties.clear();
        do {
            retMetaData.properties.emplace((*retQuery)[1].getString(), (*retQuery)[2].getString());
        } while (retQuery->nextRow());
    }
    return retMetaData;
}

auto FileIndexerAgent::dbSetProperty(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool
{
    std::unique_ptr<QueryResult> retQuery = nullptr;
    unsigned int fileId;

    if (false == metaData->path.empty()) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoByPath, metaData->path.c_str());
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return false;
        }
        fileId = (*retQuery)[0].getUInt32();
    }
    else if (metaData->file_id != FileIndexer::FILE_ID_NOT_EXISTS) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoById, metaData->file_id);
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return false;
        }
        fileId = metaData->file_id;
    }
    else {
        // there is no way to identify the file (id or path)
        return false;
    }

    auto itr      = metaData->properties.begin();
    auto property = itr->first;
    auto value    = itr->second;
    return database->execute(FileIndexer::Statements::insertPropertyValue, fileId, property.c_str(), value.c_str());
}

auto FileIndexerAgent::dbSetProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool
{
    bool statusCode                       = true;
    std::unique_ptr<QueryResult> retQuery = nullptr;
    unsigned int fileId;

    if (false == metaData->path.empty()) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoByPath, metaData->path.c_str());
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return false;
        }
        fileId = (*retQuery)[0].getUInt32();
    }
    else if (metaData->file_id != FileIndexer::FILE_ID_NOT_EXISTS) {
        retQuery = database->query(FileIndexer::Statements::getFileInfoById, metaData->file_id);
        if (nullptr == retQuery || DatabaseAgent::ONE_ROW_FOUND != retQuery->getRowCount()) {
            return false;
        }
        fileId = metaData->file_id;
    }
    else {
        // there is no way to identify the file (id or path)
        return false;
    }

    for (auto propVal : metaData->properties) {
        statusCode = database->execute(
            FileIndexer::Statements::insertPropertyValue, fileId, propVal.first.c_str(), propVal.second.c_str());
        if (!statusCode)
            return statusCode;
    }
    return statusCode;
}

auto FileIndexerAgent::dbUpdateProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool
{
    bool statusCode = true;
    for (auto propVal : metaData->properties) {
        statusCode = database->execute(FileIndexer::Statements::updatePropertyValue,
                                       propVal.second.c_str(),
                                       metaData->file_id,
                                       propVal.first.c_str());
        if (!statusCode)
            return statusCode;
    }
    return statusCode;
}

auto FileIndexerAgent::handleGetProperty(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::GetPropertyMessage *>(req)) {
        auto metaDataPtr                   = std::move(msg->metaData);
        FileIndexer::FileMetadata metaData = *metaDataPtr;
        msg->dbMetaData                    = dbGetProperty(std::make_unique<FileIndexer::FileMetadata>(metaData));
        return std::make_shared<FileIndexer::Messages::GetPropertyResponseMessage>(
            std::make_unique<FileIndexer::FileMetadata>(msg->dbMetaData));
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleGetAllProperties(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::GetAllPropertiesMessage *>(req)) {
        auto metaDataPtr                   = std::move(msg->metaData);
        FileIndexer::FileMetadata metaData = *metaDataPtr;
        msg->dbMetaData                    = dbGetAllProperties(std::make_unique<FileIndexer::FileMetadata>(metaData));
        return std::make_shared<FileIndexer::Messages::GetPropertyResponseMessage>(
            std::make_unique<FileIndexer::FileMetadata>(msg->dbMetaData));
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleSetProperty(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::SetPropertyMessage *>(req)) {
        auto metaDataPtr                   = std::move(msg->metaData);
        FileIndexer::FileMetadata metaData = *metaDataPtr;

        auto itr   = metaDataPtr->properties.begin();
        auto value = itr->second;

        msg->dbMetaData = dbGetProperty(std::make_unique<FileIndexer::FileMetadata>(metaData));
        auto dbItr      = msg->dbMetaData.properties.begin();
        auto dbValue    = dbItr->second;

        if (dbValue != value) {
            auto updateMsg = std::make_shared<FileIndexer::Messages::PropertyChangedMessage>(
                std::move(metaDataPtr), std::make_unique<FileIndexer::FileMetadata>(msg->dbMetaData));
            parentService->bus.sendUnicast(std::move(updateMsg), msg->sender);
            dbSetProperty(std::make_unique<FileIndexer::FileMetadata>(metaData));
        }
    }
    return sys::msgHandled();
}

auto FileIndexerAgent::handleSetProperties(sys::Message *req) -> sys::MessagePointer
{
    if (auto msg = dynamic_cast<FileIndexer::Messages::SetPropertiesMessage *>(req)) {
        auto metaDataPtr                   = std::move(msg->metaData);
        FileIndexer::FileMetadata metaData = *metaDataPtr;
        msg->dbMetaData                    = dbGetAllProperties(std::make_unique<FileIndexer::FileMetadata>(metaData));
        auto updateMsg                     = std::make_shared<FileIndexer::Messages::PropertyChangedMessage>(
            std::move(metaDataPtr), std::make_unique<FileIndexer::FileMetadata>(msg->dbMetaData));
        parentService->bus.sendUnicast(std::move(updateMsg), msg->sender);
        dbSetProperties(std::make_unique<FileIndexer::FileMetadata>(metaData));

        for (auto recipient : fileChangeRecipents[metaData.directory]) {
            auto notifyMsg = std::make_shared<FileIndexer::Messages::DirectoryContentChangedMessage>(
                std::make_unique<std::string>(metaData.directory));
            parentService->bus.sendUnicast(std::move(notifyMsg), recipient);
        }
    }
    return sys::msgHandled();
}


D module-services/service-db/agents/file_indexer/FileIndexerAgent.hpp => module-services/service-db/agents/file_indexer/FileIndexerAgent.hpp +0 -59
@@ 1,59 0,0 @@
// 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 <service-db/DatabaseAgent.hpp>
#include <service-db/FileIndexerMessages.hpp>

#include <set>

class FileIndexerAgent : public DatabaseAgent
{
  public:
    FileIndexerAgent(sys::Service *parentService);
    ~FileIndexerAgent() = default;

    void initDb() override;
    void deinitDb() override;
    void registerMessages() override;
    auto getAgentName() -> const std::string override;

  protected:
    // msg handlers
    auto handleRegisterOnFileChange(sys::Message *req) -> sys::MessagePointer;
    auto handleUnregisterOnFileChange(sys::Message *req) -> sys::MessagePointer;
    auto handleListDir(sys::Message *req) -> sys::MessagePointer;
    auto handleGetProperty(sys::Message *req) -> sys::MessagePointer;
    auto handleGetAllProperties(sys::Message *req) -> sys::MessagePointer;
    auto handleSetProperty(sys::Message *req) -> sys::MessagePointer;
    auto handleSetProperties(sys::Message *req) -> sys::MessagePointer;
    auto handleGetRecord(sys::Message *req) -> sys::MessagePointer;
    auto handleSetRecord(sys::Message *req) -> sys::MessagePointer;
    auto handleDeleteFile(sys::Message *req) -> sys::MessagePointer;
    auto handleDeleteAllFilesInDir(sys::Message *req) -> sys::MessagePointer;

    using MapOfRecipentsToBeNotified = std::map<std::string, std::set<std::string>>;
    MapOfRecipentsToBeNotified fileChangeRecipents;

  private:
    // db operations
    auto dbRegisterFileChange(std::string dir, std::string service) -> bool;
    auto dbUnregisterFileChange(std::string dir, std::string service) -> bool;
    auto dbListDir(unsigned int offset, unsigned int limit, const std::string &directory)
        -> std::unique_ptr<FileIndexer::ListDir>;
    auto dbGetProperty(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> FileIndexer::FileMetadata;
    auto dbSetProperty(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool;
    auto dbSetProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool;
    auto dbUpdateProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> bool;
    auto dbGetAllProperties(std::unique_ptr<FileIndexer::FileMetadata> metaData) -> FileIndexer::FileMetadata;
    auto dbGetRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> FileIndexer::FileRecord;
    auto dbSetRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> bool;
    auto dbDeleteFile(std::unique_ptr<FileIndexer::FileRecord> record) -> bool;
    auto dbDeleteAllFilesInDir(std::unique_ptr<FileIndexer::FileRecord> record) -> bool;
    auto dbUpdateRecord(std::unique_ptr<FileIndexer::FileRecord> record) -> bool;
    auto getDbInitString() -> const std::string override;
    auto getDbFilePath() -> const std::string override;
    auto dbGetFilesCount() -> unsigned int;
    auto dbGeMetadataCount() -> unsigned int;
};


D module-services/service-db/agents/file_indexer/FileIndexer_queries.hpp => module-services/service-db/agents/file_indexer/FileIndexer_queries.hpp +0 -136
@@ 1,136 0,0 @@
// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#pragma once

namespace FileIndexer::Statements
{

    constexpr auto getFilesCount = R"sql(
                        SELECT COUNT(FT.file_id) AS FILE_PATH_EXISTS FROM  file_tab AS FT;
                        )sql";

    constexpr auto getMetadataCount = R"sql(
                        SELECT COUNT(MT.file_id) AS FILE_PATH_EXISTS FROM  metadata_tab AS MT;
                        )sql";

    constexpr auto checkFileExists = R"sql(
                        SELECT COUNT(size) AS FILE_PATH_EXISTS FROM  file_tab AS FT
                        WHERE FT.path = '%q'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getFileIdByPath = R"sql(
                        SELECT FT.file_id FROM file_tab AS FT
                        WHERE FT.path = '%q'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getFilePathById = R"sql(
                        SELECT FT.path  FROM  file_tab AS FT
                        WHERE FT.file_id = '%lu'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getFileInfoByPath = R"sql(
                        SELECT file_id, path, size, mime_type, mtime, directory ,file_type  FROM  file_tab AS FT
                        WHERE FT.path = '%q'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getFileInfoById = R"sql(
                        SELECT file_id, path, size, mime_type, mtime, directory, file_type   FROM  file_tab AS FT
                        WHERE FT.file_id = '%lu'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getFilesByDir = R"sql(
                        SELECT file_id, path, size, mime_type, mtime, directory, file_type   FROM  file_tab AS FT
                        WHERE FT.directory = '%q'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto insertFileInfo = R"sql(
                        INSERT OR REPLACE INTO file_tab (path, size, mime_type, mtime, directory, file_type) VALUES
                        ('%q', '%lu', '%lu' , '%lu', '%q', '%lu') ;
                        )sql";

    constexpr auto updateFileInfo = R"sql(
                        UPDATE file_tab SET path= '%q',
                        size= '%lu',
                        mime_type= '%lu',
                        mtime= '%lu',
                        directory ='%q',
                        file_type= '%lu'
                        WHERE file_id = '%lu' ;
                        )sql";

    constexpr auto deleteFileById = R"sql(
                        DELETE FROM file_tab AS FT
                        WHERE FT.file_id = '%lu';
                        DELETE FROM metadata_tab AS MT
                        WHERE MT.file_id = '%lu';
                        )sql";

    constexpr auto deleteAllFileInfoInDir = R"sql(
                        DELETE FROM file_tab AS FT
                        WHERE FT.directory = '%q';
                        )sql";

    constexpr auto getFilesIdByDir = R"sql(
                        SELECT file_id FROM  file_tab AS FT
                        WHERE FT.directory = '%q'
                        COLLATE NOCASE;
                        )sql";

    constexpr auto getPropertyValue = R"sql(
                         SELECT MT.file_id, MT.property, MT.value
                         FROM metadata_tab AS MT, file_tab AS FT
                         WHERE MT.property = '%q' AND FT.path = '%q' AND  FT.file_id = MT.file_id
                         COLLATE NOCASE;
                         )sql";

    constexpr auto getAllProperties = R"sql(
                         SELECT MT.file_id, MT.property, MT.value
                         FROM metadata_tab AS MT, file_tab AS FT
                         WHERE FT.path = '%q' AND  FT.file_id = MT.file_id
                         COLLATE NOCASE;
                         )sql";

    constexpr auto insertPropertyValue = R"sql(
                        INSERT OR REPLACE INTO metadata_tab (file_id, property, value) VALUES
                        ( '%lu', '%q', '%q' ) ;
                        )sql";

    constexpr auto updatePropertyValue = R"sql(
                        UPDATE metadata_tab SET value = '%q'
                        WHERE file_id= '%lu' AND property = '%q' ;
                        )sql";

    constexpr auto setNotification = R"sql(
                        INSERT OR REPLACE INTO notifications_tab (path, service) VALUES
                        ( '%q' , '%q' ) ;
                        )sql";

    constexpr auto updateNotification = R"sql(
                        UPDATE notifications_tab SET path = '%q', service = '%q'
                        WHERE id = '%lu';
                        )sql";

    constexpr auto clearNotificationdRow = R"sql(
                        DELETE FROM notifications_tab
                        WHERE path = '%q' AND service = '%q';
                        )sql";

    constexpr auto getAllNotifications = R"sql(
                        SELECT id, path, service
                        FROM notifications_tab  AS NT;
                        )sql";

    constexpr auto getNotification = R"sql(
                        SELECT id, path, service
                        FROM notifications_tab  AS NT
                        WHERE path= '%q' AND service = '%q';
                        )sql";

} // namespace FileIndexer::Statements


D module-services/service-db/test/test-service-db-file_indexer.cpp => module-services/service-db/test/test-service-db-file_indexer.cpp +0 -318
@@ 1,318 0,0 @@
// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include <catch2/catch.hpp>

#include <Service/Service.hpp>
#include <functional>
#include <thread> // for Message_t, ResponseMessage, DataMessage, Message
#include <service-db/ServiceDBCommon.hpp>

#include <service-db/test/test-service-db-file_indexer.hpp>
#include <service-db/FileIndexerMessages.hpp>

class ClientService : public sys::Service
{
  public:
    using sys::Service::Service;

    explicit ClientService(std::string name) : Service(name)
    {}

    sys::MessagePointer DataReceivedHandler(sys::DataMessage *msg, sys::ResponseMessage *resp)
    {
        return std::make_shared<sys::ResponseMessage>();
    }

    sys::ReturnCodes InitHandler()
    {
        return sys::ReturnCodes::Success;
    }

    sys::ReturnCodes DeinitHandler()
    {
        return sys::ReturnCodes::Success;
    }

    sys::ReturnCodes SwitchPowerModeHandler(const sys::ServicePowerMode mode)
    {
        return sys::ReturnCodes::Success;
    }
};

TEST_CASE("FileIndexer")
{
    Database::initialize();
    std::string serviceName = "file_indexer_client";
    ClientService file_indexer_client_service(serviceName);
    file_indexer_client_service.InitHandler();

    SECTION("init db, register /unregister on file change")
    {
        std::cout << "Init File Indexer DB" << std::endl << std::flush;
        std::unique_ptr<FileIndexerTest> fiAgentTest{new FileIndexerTest(&file_indexer_client_service)};
        fiAgentTest->initDb();
        fiAgentTest->registerMessages();

        std::cout << "Register on file change" << std::endl << std::flush;
        std::string inputDirReg = "mp3";
        auto recordPtr          = std::make_unique<std::string>(inputDirReg);
        auto regMsg             = std::make_shared<FileIndexer::Messages::RegisterOnFileChange>(std::move(recordPtr));
        regMsg->sender          = serviceName;
        sys::MessagePointer recMsg = fiAgentTest->handleRegisterOnFileChangeTest(regMsg.get());
        fiAgentTest->getNumberOfRecipients(inputDirReg);

        regMsg->sender        = "serv1";
        recMsg                = fiAgentTest->handleRegisterOnFileChangeTest(regMsg.get());
        auto recipientsCount1 = fiAgentTest->getNumberOfRecipients(inputDirReg);

        std::cout << "Unregister on file change" << std::endl << std::flush;
        std::string inputDirUnReg = "mp3";
        auto strPtr               = std::make_unique<std::string>(inputDirUnReg);
        auto unregMsg             = std::make_shared<FileIndexer::Messages::UnregisterOnFileChange>(std::move(strPtr));
        unregMsg->sender          = serviceName;
        recMsg                    = fiAgentTest->handleUnregisterOnFileChangeTest(unregMsg.get());
        auto recipientsCount2     = fiAgentTest->getNumberOfRecipients(inputDirUnReg);

        REQUIRE(recipientsCount2 == recipientsCount1 - 1);
        REQUIRE(fiAgentTest->getAgentName() == "fileIndexerAgent");
    }

    SECTION("SetRecord & GetRecord")
    {
        FileIndexer::FileRecord record{};
        std::cout << "Test File indexer Get/Set/Get Record sequence:" << std::endl << std::flush;

        // GetRecord
        record.file_id = 1;
        auto recordPtr = std::make_unique<FileIndexer::FileRecord>(record);
        auto getMsg    = std::make_shared<FileIndexer::Messages::GetRecordMessage>(std::move(recordPtr));
        std::unique_ptr<FileIndexerTest> fiAgentTest{new FileIndexerTest(&file_indexer_client_service)};
        sys::MessagePointer recMsg = fiAgentTest->handleGetRecordTest(getMsg.get());
        auto msg                   = dynamic_cast<FileIndexer::Messages::GetRecordResponseMessage *>(recMsg.get());
        auto fileRec               = msg->record.get();

        LOG_INFO("file id= %d file path= %s  size = %d  mime= %d  mtime = %d directory= %s ftype= %d",
                 fileRec->file_id,
                 fileRec->path.c_str(),
                 fileRec->size,
                 fileRec->mime_type,
                 fileRec->mtime,
                 fileRec->directory.c_str(),
                 fileRec->file_type);

        REQUIRE(fileRec->file_id == record.file_id);

        record = *fileRec; // fill record by data recived from db

        // SetRecord - modify mime_type
        record.mime_type = 2;
        recordPtr        = std::make_unique<FileIndexer::FileRecord>(record);
        auto setMsg      = std::make_shared<FileIndexer::Messages::SetRecordMessage>(std::move(recordPtr));
        setMsg->sender   = serviceName;
        recMsg           = fiAgentTest->handleSetRecordTest(setMsg.get());

        // GetRecord to confirm changes in mime_type
        recordPtr = std::make_unique<FileIndexer::FileRecord>(record);
        getMsg    = std::make_shared<FileIndexer::Messages::GetRecordMessage>(std::move(recordPtr));
        recMsg    = fiAgentTest->handleGetRecordTest(getMsg.get());
        msg       = dynamic_cast<FileIndexer::Messages::GetRecordResponseMessage *>(recMsg.get());
        fileRec   = msg->record.get();

        LOG_INFO("file id= %d file path= %s  size = %d  mime= %d  mtime = %d directory= %s ftype= %d",
                 fileRec->file_id,
                 fileRec->path.c_str(),
                 fileRec->size,
                 fileRec->mime_type,
                 fileRec->mtime,
                 fileRec->directory.c_str(),
                 fileRec->file_type);
        // check if new value was set
        REQUIRE(fileRec->mime_type == record.mime_type);
        // check if the rest of the record did not change
        REQUIRE(fileRec->file_id == record.file_id);
        REQUIRE(fileRec->path == record.path);
        REQUIRE(fileRec->size == record.size);
        REQUIRE(fileRec->mtime == record.mtime);
        REQUIRE(fileRec->directory == record.directory);
        REQUIRE(fileRec->file_type == record.file_type);
    }

    SECTION("List dir - support for listview")
    {
        FileIndexer::ListDir inputData{};
        std::cout << "List dir - support for listview" << std::endl << std::flush;

        // GetListDir
        inputData.directory   = "mp3";
        inputData.offset      = 1;
        inputData.limit       = 2;

        auto recordPtr = std::make_unique<FileIndexer::ListDir>(inputData);
        auto getMsg    = std::make_shared<FileIndexer::Messages::GetListDirRequest>(std::move(recordPtr));
        std::unique_ptr<FileIndexerTest> fiAgentTest{new FileIndexerTest(&file_indexer_client_service)};
        sys::MessagePointer recMsg = fiAgentTest->handleListDirTest(getMsg.get());
        auto msg                   = dynamic_cast<FileIndexer::Messages::GetListDirResponse *>(recMsg.get());
        auto fileCount             = msg->getCount();
        auto fileList              = msg->getResults();
        LOG_INFO("Total number of files in %s = %d", inputData.directory.c_str(), fileCount);
        LOG_INFO("Limit= %d Offset= %d", inputData.limit, inputData.offset);
        for (auto fileRec : fileList) {
            LOG_INFO("file id= %d file path= %s  size = %d  mime= %d  mtime = %d directory= %s ftype= %d",
                     fileRec.file_id,
                     fileRec.path.c_str(),
                     fileRec.size,
                     fileRec.mime_type,
                     fileRec.mtime,
                     fileRec.directory.c_str(),
                     fileRec.file_type);
        }
        REQUIRE(fileList.size() == inputData.limit);
        REQUIRE(fileList[0].directory == inputData.directory);
    }

    SECTION("get/set Properties")
    {
        FileIndexer::FileMetadata inputMetaData{};
        std::cout << "get/set Properties" << std::endl << std::flush;

        // Get Properties
        inputMetaData.path = "mp3/track3.mp3";
        LOG_INFO("File path= %s", inputMetaData.path.c_str());

        auto recordPtr = std::make_unique<FileIndexer::FileMetadata>(inputMetaData);
        auto getMsg    = std::make_shared<FileIndexer::Messages::GetAllPropertiesMessage>(std::move(recordPtr));
        std::unique_ptr<FileIndexerTest> fiAgentTest{new FileIndexerTest(&file_indexer_client_service)};
        sys::MessagePointer recMsg = fiAgentTest->handleGetAllPropertiesTest(getMsg.get());
        auto msg                   = dynamic_cast<FileIndexer::Messages::GetPropertyResponseMessage *>(recMsg.get());
        for (auto prop : msg->metaData->properties) {
            LOG_INFO("file id= %d property= %s  value = %s",
                     msg->metaData->file_id,
                     prop.first.c_str(),
                     prop.second.c_str());
        }
        REQUIRE(msg->metaData->properties.size() > 0);

        // set Properties
        inputMetaData.properties.clear();
        inputMetaData.properties.emplace("year", "2015");

        std::string newProperty      = "time";
        std::string newPropertyValue = "5min";
        inputMetaData.properties.emplace(newProperty, newPropertyValue);
        recordPtr      = std::make_unique<FileIndexer::FileMetadata>(inputMetaData);
        auto setMsg    = std::make_shared<FileIndexer::Messages::SetPropertiesMessage>(std::move(recordPtr));
        setMsg->sender = serviceName;
        recMsg         = fiAgentTest->handleSetPropertiesTest(setMsg.get());

        // Get Properties
        recordPtr = std::make_unique<FileIndexer::FileMetadata>(inputMetaData);
        getMsg    = std::make_shared<FileIndexer::Messages::GetAllPropertiesMessage>(std::move(recordPtr));
        recMsg    = fiAgentTest->handleGetAllPropertiesTest(getMsg.get());
        msg       = dynamic_cast<FileIndexer::Messages::GetPropertyResponseMessage *>(recMsg.get());
        for (auto prop : msg->metaData->properties) {
            LOG_INFO("file id= %d property= %s  value = %s",
                     msg->metaData->file_id,
                     prop.first.c_str(),
                     prop.second.c_str());
        }
        //  serch if a new property was set correctly
        std::string newPropertyValueFound;
        auto it = msg->metaData->properties.find(newProperty);
        if (msg->metaData->properties.end() != it) {
            newPropertyValueFound = it->second;
        }
        REQUIRE(newPropertyValueFound == newPropertyValue);
    }

    SECTION("DeleteFile /DeleteAllFilesInDir")
    {
        FileIndexer::ListDir inputData{};
        FileIndexer::FileRecord record{};
        std::cout << "DeleteFile /DeleteAllFilesInDir" << std::endl << std::flush;

        // SetRecord - add files
        auto recordPtr = std::make_unique<FileIndexer::FileRecord>(record);
        std::unique_ptr<FileIndexerTest> fiAgentTest{new FileIndexerTest(&file_indexer_client_service)};
        record.directory = "wav";
        record.path      = "wav/file1.wav";

        recordPtr                  = std::make_unique<FileIndexer::FileRecord>(record);
        auto setMsg                = std::make_shared<FileIndexer::Messages::SetRecordMessage>(std::move(recordPtr));
        setMsg->sender             = serviceName;
        sys::MessagePointer recMsg = fiAgentTest->handleSetRecordTest(setMsg.get());

        record.path    = "wav/file2.wav";
        recordPtr      = std::make_unique<FileIndexer::FileRecord>(record);
        setMsg         = std::make_shared<FileIndexer::Messages::SetRecordMessage>(std::move(recordPtr));
        setMsg->sender = serviceName;
        recMsg         = fiAgentTest->handleSetRecordTest(setMsg.get());

        record.path    = "wav/file3.wav";
        recordPtr      = std::make_unique<FileIndexer::FileRecord>(record);
        setMsg         = std::make_shared<FileIndexer::Messages::SetRecordMessage>(std::move(recordPtr));
        setMsg->sender = serviceName;
        recMsg         = fiAgentTest->handleSetRecordTest(setMsg.get());

        std::cout << "Get listDir" << std::endl << std::flush;
        inputData.directory   = "wav";
        inputData.offset      = 0;
        inputData.limit       = 10;
        auto inputDataPtr     = std::make_unique<FileIndexer::ListDir>(inputData);
        auto getListDirMsg    = std::make_shared<FileIndexer::Messages::GetListDirRequest>(std::move(inputDataPtr));
        recMsg                = fiAgentTest->handleListDirTest(getListDirMsg.get());
        auto msg              = dynamic_cast<FileIndexer::Messages::GetListDirResponse *>(recMsg.get());
        auto fileCount        = msg->getCount();
        auto fileList         = msg->getResults();
        LOG_INFO("Total number of files in %s = %d", inputData.directory.c_str(), fileCount);
        LOG_INFO("Limit= %d Offset= %d", inputData.limit, inputData.offset);
        for (auto fileRec : fileList) {
            LOG_INFO("file id= %d file path= %s  size = %d  mime= %d  mtime = %d directory= %s ftype= %d",
                     fileRec.file_id,
                     fileRec.path.c_str(),
                     fileRec.size,
                     fileRec.mime_type,
                     fileRec.mtime,
                     fileRec.directory.c_str(),
                     fileRec.file_type);
        }

        std::cout << "DeleteFile" << std::endl << std::flush;
        record.path      = "wav/file1.wav";
        record.directory = "wav";
        recordPtr        = std::make_unique<FileIndexer::FileRecord>(record);
        auto delMsg      = std::make_shared<FileIndexer::Messages::DeleteFileMessage>(std::move(recordPtr));
        delMsg->sender   = serviceName;
        auto delRecMsg   = fiAgentTest->handleDeleteFileTest(delMsg.get());

        inputData.directory    = "wav";
        inputData.offset       = 0;
        inputData.limit        = 10;
        inputDataPtr           = std::make_unique<FileIndexer::ListDir>(inputData);
        getListDirMsg          = std::make_shared<FileIndexer::Messages::GetListDirRequest>(std::move(inputDataPtr));
        recMsg                 = fiAgentTest->handleListDirTest(getListDirMsg.get());
        msg                    = dynamic_cast<FileIndexer::Messages::GetListDirResponse *>(recMsg.get());
        auto fileCountAfterDel = msg->getCount();
        REQUIRE(fileCountAfterDel == fileCount - 1);

        std::cout << "DeleteAllFilesInDir" << std::endl << std::flush;
        record.directory  = "wav";
        recordPtr         = std::make_unique<FileIndexer::FileRecord>(record);
        auto delAllMsg    = std::make_shared<FileIndexer::Messages::DeleteAllFilesInDirMessage>(std::move(recordPtr));
        delAllMsg->sender = serviceName;
        delRecMsg         = fiAgentTest->handleDeleteAllFilesInDirTest(delAllMsg.get());

        inputData.directory   = "wav";
        inputData.offset      = 0;
        inputData.limit       = 10;
        inputDataPtr          = std::make_unique<FileIndexer::ListDir>(inputData);
        getListDirMsg         = std::make_shared<FileIndexer::Messages::GetListDirRequest>(std::move(inputDataPtr));
        recMsg                = fiAgentTest->handleListDirTest(getListDirMsg.get());
        msg                   = dynamic_cast<FileIndexer::Messages::GetListDirResponse *>(recMsg.get());
        fileCountAfterDel     = msg->getCount();
        REQUIRE(fileCountAfterDel == 0);
        std::cout << "DeleteFile /DeleteAllFilesInDir  finished" << std::endl << std::flush;
    }

    Database::deinitialize();
}


D module-services/service-db/test/test-service-db-file_indexer.hpp => module-services/service-db/test/test-service-db-file_indexer.hpp +0 -70
@@ 1,70 0,0 @@
// 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 <service-db/DatabaseAgent.hpp>
#include <service-db/FileIndexerMessages.hpp>
#include <service-db/agents/file_indexer/FileIndexerAgent.hpp>

class FileIndexerTest : public FileIndexerAgent
{
  public:
    FileIndexerTest(sys::Service *parentService) : FileIndexerAgent(parentService){};
    ~FileIndexerTest() = default;

    auto handleGetRecordTest(FileIndexer::Messages::GetRecordMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleGetRecord(req);
    }

    auto handleSetRecordTest(FileIndexer::Messages::SetRecordMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleSetRecord(req);
    }

    auto handleListDirTest(FileIndexer::Messages::GetListDirRequest *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleListDir(req);
    }

    auto handleGetAllPropertiesTest(FileIndexer::Messages::GetAllPropertiesMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleGetAllProperties(req);
    }

    auto handleSetPropertiesTest(FileIndexer::Messages::SetPropertiesMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleSetProperties(req);
    }

    auto handleRegisterOnFileChangeTest(FileIndexer::Messages::RegisterOnFileChange *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleRegisterOnFileChange(req);
    }

    auto handleUnregisterOnFileChangeTest(FileIndexer::Messages::UnregisterOnFileChange *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleUnregisterOnFileChange(req);
    }

    auto handleDeleteFileTest(FileIndexer::Messages::DeleteFileMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleDeleteFile(req);
    }

    auto handleDeleteAllFilesInDirTest(FileIndexer::Messages::DeleteAllFilesInDirMessage *req) -> sys::MessagePointer
    {
        return FileIndexerAgent::handleDeleteAllFilesInDir(req);
    }

    unsigned int getNumberOfRecipients(std::string directory)
    {
        unsigned int recipientCount = 0;
        for (auto recipient : fileChangeRecipents[directory]) {
            LOG_INFO("Notifications:  directory= %s service= %s", directory.c_str(), recipient.c_str());
            recipientCount++;
        }
        return recipientCount++;
    }
};


M products/BellHybrid/services/db/ServiceDB.cpp => products/BellHybrid/services/db/ServiceDB.cpp +0 -1
@@ 8,7 8,6 @@

#include <service-db/DBServiceMessage.hpp>
#include <service-db/agents/settings/SettingsAgent.hpp>
#include <service-db/agents/file_indexer/FileIndexerAgent.hpp>
#include <time/ScopedTime.hpp>

#include <purefs/filesystem_paths.hpp>


M products/PurePhone/services/db/ServiceDB.cpp => products/PurePhone/services/db/ServiceDB.cpp +0 -2
@@ 16,7 16,6 @@
#include <module-db/Interface/SMSRecord.hpp>
#include <module-db/Interface/SMSTemplateRecord.hpp>
#include <purefs/filesystem_paths.hpp>
#include <service-db/agents/file_indexer/FileIndexerAgent.hpp>
#include <service-db/agents/quotes/QuotesAgent.hpp>
#include <service-db/agents/settings/SettingsAgent.hpp>
#include <service-db/DBCalllogMessage.hpp>


@@ 235,7 234,6 @@ sys::ReturnCodes ServiceDB::InitHandler()
        std::make_unique<db::multimedia_files::MultimediaFilesRecordInterface>(multimediaFilesDB.get());

    databaseAgents.emplace(std::make_unique<SettingsAgent>(this, "settings_v2.db"));
    databaseAgents.emplace(std::make_unique<FileIndexerAgent>(this));

    for (auto &dbAgent : databaseAgents) {
        dbAgent->initDb();