.gitignore

@@ -80,3 +80,8 @@ CMakeLists.txt.user*
 .rcc/
 .uic/
 /build*/
+
+
+ccache.log
+
+*-odb.*xx

cpp-opds.qbs

@@ -1,13 +0,0 @@
-QtApplication {
-    cpp.defines: [
-        // You can make your code fail to compile if it uses deprecated APIs.
-        // In order to do so, uncomment the following line.
-        //"QT_DISABLE_DEPRECATED_BEFORE=0x060000" // disables all the APIs deprecated before Qt 6.0.0
-    ]
-
-    consoleApplication: true
-    install: true
-    files: [
-        "main.cpp",
-    ]
-}

main.cpp

@@ -1,19 +0,0 @@
-#include <QCoreApplication>
-
-int main(int argc, char *argv[])
-{
-    QCoreApplication a(argc, argv);
-
-    // Set up code that uses the Qt event loop here.
-    // Call a.quit() or a.exit() to quit the application.
-    // A not very useful example would be including
-    // #include <QTimer>
-    // near the top of the file and calling
-    // QTimer::singleShot(5000, &a, &QCoreApplication::quit);
-    // which quits the application after 5 seconds.
-
-    // If you do not need a running Qt event loop, remove the call
-    // to a.exec() or use the Non-Qt Plain C++ Application template.
-
-    return a.exec();
-}

project.qbs

@@ -0,0 +1,19 @@
+import qbs
+
+Project {
+    name: "opds++"
+    qbsSearchPaths: [
+        "qbs",
+        // "redkitty/qbs",
+        // // "guiness/qbs",
+        // // "prerequisites/qbs",
+        // // "report/qbs",
+        // "redkbuild",
+        // // "ext_libs/openssl/qbs",
+        // "redkitty/lib/redkit-gen-integration/qbs",
+    ]
+
+    references: [
+        "src/cpp-opds.qbs",
+    ]
+}

qbs/modules/odbModule/odbModule.qbs

@@ -0,0 +1,48 @@
+import qbs
+import qbs.FileInfo
+
+Module {
+    Depends { name: "cpp" }
+    Depends { name: "Qt.core" }
+
+    FileTagger {
+        patterns: "*.hxx"
+        fileTags: ["odb"]
+    }
+
+    Rule {
+        inputs: ["odb"]
+        Artifact {
+            // filePath: FileInfo.baseName(input.fileName)+ "-odb.hxx"
+            filePath: FileInfo.cleanPath(input.filePath + "/../" ) + "/" + FileInfo.baseName(input.fileName) + "-odb.hxx"
+            fileTags: ["hpp"]
+        }
+        Artifact {
+            // filePath: FileInfo.baseName(input.fileName) + "-odb.cxx"
+            filePath: {
+                // console.error("THIS ART "+FileInfo.cleanPath(input.filePath + "/../") + "/" + FileInfo.baseName(input.fileName) + "-odb.cxx")
+                return FileInfo.cleanPath(input.filePath + "/../") + "/" + FileInfo.baseName(input.fileName) + "-odb.cxx"}
+            fileTags: ["cpp"]
+        }
+
+        prepare: {
+            var cmd = new Command("odb", [
+                "--std", "c++11",
+                "-d", "sqlite",
+                "--generate-query",
+                "--generate-schema",
+                "--generate-prepared",
+                // "--include-prefix", FileInfo.cleanPath(input.filePath + "/../"),
+                // "--output-dir", product.Qt.core.qmDir,
+                "--output-dir", FileInfo.cleanPath(input.filePath + "/../"),
+                input.filePath,
+            ]);
+            cmd.description = "Generating ODB files for " + input.fileName;
+
+            console.error(cmd.arguments)
+
+            return [cmd];
+        }
+    }
+    cpp.includePaths: [ project.sourceDirectory, product.Qt.core.qmDir ]
+}

src/author_s.h

@@ -0,0 +1,63 @@
+// file      : hello/person.hxx
+// copyright : not copyrighted - public domain
+
+#ifndef AUTHOR_S_H
+#define AUTHOR_S_H
+
+#include <cstddef> // std::size_t
+#include <memory>
+#include <string>
+
+#include <odb/core.hxx>
+#include <odb/database.hxx>
+#include <odb/query.hxx>
+
+#pragma db object
+class Author_S
+{
+public:
+    Author_S() = default;
+
+    Author_S(const std::string& first,
+             const std::string& last,
+             const unsigned short age) :
+        m_first(first),
+        m_last(last),
+        m_age(age)
+    {
+    }
+
+    unsigned long long id() const { return m_id; }
+    std::string first() const { return m_first; }
+    std::string last() const { return m_last; }
+    unsigned short age() const { return m_age; }
+
+    std::string full_name() const { return m_first + " " + m_last; }
+
+    void age(unsigned short age) { m_age = age; }
+
+private:
+    friend class odb::access;
+
+#pragma db id auto
+    unsigned long long m_id;
+
+    std::string m_first;
+    std::string m_last;
+    unsigned short m_age;
+};
+
+#pragma db view object(Author_S)
+struct person_stat
+{
+#pragma db column("count(" + Author_S::m_id + ")")
+    std::size_t count;
+
+#pragma db column("min(" + Author_S::m_age + ")")
+    unsigned short min_age;
+
+#pragma db column("max(" + Author_S::m_age + ")")
+    unsigned short max_age;
+};
+
+#endif // AUTHOR_S_H

src/book_s.h

@@ -0,0 +1,46 @@
+// file      : hello/person.hxx
+// copyright : not copyrighted - public domain
+
+#ifndef BOOK_S_H
+#define BOOK_S_H
+
+#include <memory>
+#include <string>
+
+#include <odb/core.hxx>
+
+#include "author_s.h"
+
+#pragma db object
+class Book_S
+{
+public:
+    Book_S() = default;
+
+    Book_S(const std::string& name,
+           const std::shared_ptr<Author_S>& author,
+           const int year)
+    {
+        m_author = author;
+        m_name = name;
+        m_year = year;
+    };
+
+    unsigned long long id() const { return m_id; }
+    std::shared_ptr<Author_S> author() const { return m_author; }
+    std::string name() const { return m_name; }
+    int year() const { return m_year; }
+
+private:
+    friend class odb::access;
+
+private:
+#pragma db id auto
+    unsigned long long m_id;
+
+    std::shared_ptr<Author_S> m_author;
+    std::string m_name;
+    int m_year;
+};
+
+#endif // BOOK_S_H

src/cpp-opds.qbs

@@ -0,0 +1,58 @@
+/*!
+    \qmltype cpp-opds
+    \inherits Project
+    \brief Описание
+*/
+Application {
+    // CppApplication {
+        cpp.defines: [
+            // You can make your code fail to compile if it uses deprecated APIs.
+            // In order to do so, uncomment the following line.
+            //"QT_DISABLE_DEPRECATED_BEFORE=0x060000" // disables all the APIs deprecated before Qt 6.0.0
+            "DATABASE_SQLITE"
+        ]
+        consoleApplication: true
+
+        Depends { name: "Qt"; submodules: [ "core", "sql", "network" ] }
+        Depends { name: "cpp" }
+        Depends { name: "odbModule"}
+
+        // Depends { name: "redkit_gen" }
+
+        cpp.cxxLanguageVersion: "c++20"
+
+        Group {
+            name: "cpp"
+            files: [
+                "books.*",
+                "databasemanager.*",
+                "main.cpp",
+                "restapiserver.*",
+            ]
+        }
+
+        Group {
+            name: "odb"
+            files: [
+                "author_s.h",
+                "book_s.h",
+            ]
+            fileTags: ["odb"]
+        }
+
+        cpp.includePaths: [
+            "/usr/include", // Общие заголовки
+            "/usr/include/odb" // Заголовки ODB
+        ]
+
+        // Подключаем библиотеки ODB
+        cpp.libraryPaths: [
+            "/usr/lib" // Путь к библиотекам
+        ]
+
+        cpp.dynamicLibraries: [
+            "odb",
+            "odb-sqlite"
+        ]
+    // }
+} // Project

src/database.hxx

@@ -0,0 +1,177 @@
+// file      : hello/database.hxx
+// copyright : not copyrighted - public domain
+
+//
+// Create concrete database instance based on the DATABASE_* macros.
+//
+
+#ifndef DATABASE_HXX
+#define DATABASE_HXX
+
+#include <cstdlib> // std::exit
+#include <iostream>
+#include <memory> // std::unique_ptr
+#include <string>
+
+#include <odb/database.hxx>
+
+#if defined(DATABASE_MYSQL)
+#include <odb/mysql/database.hxx>
+#elif defined(DATABASE_SQLITE)
+#include <odb/connection.hxx>
+#include <odb/schema-catalog.hxx>
+#include <odb/sqlite/database.hxx>
+#include <odb/transaction.hxx>
+#elif defined(DATABASE_PGSQL)
+#include <odb/pgsql/database.hxx>
+#elif defined(DATABASE_ORACLE)
+#include <odb/oracle/database.hxx>
+#elif defined(DATABASE_MSSQL)
+#include <odb/mssql/database.hxx>
+#else
+#error unknown database; did you forget to define the DATABASE_* macros?
+#endif
+
+#include <filesystem>
+#include <random>
+
+struct testData
+{
+    std::string first;
+    std::string last;
+    int age;
+};
+
+// Функция для генерации случайной строки (имени или фамилии)
+std::string generate_random_string(const std::vector<std::string>& pool)
+{
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(0, pool.size() - 1);
+    return pool[dis(gen)];
+}
+
+// Функция для генерации случайного года
+int generate_random_year(int min_year = 1900, int max_year = 2020)
+{
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(min_year, max_year);
+    return dis(gen);
+}
+
+std::vector<testData> fillDB()
+{
+    std::vector<std::string> first_names = {
+        "John", "Jane", "Alex", "Chris", "Robert", "Emily", "James", "Linda", "David", "Sarah",
+        "Michael", "Elizabeth", "Daniel", "Samantha", "William", "Olivia", "Ethan", "Sophia", "Joshua", "Charlotte",
+        "Daniel", "Grace", "Benjamin", "Isabella", "Matthew", "Victoria", "Henry", "Abigail", "Samuel", "Megan",
+        "Lucas", "Lily", "Andrew", "Madison", "Jackson", "Chloe", "Aiden", "Amelia", "Thomas", "Natalie",
+        "Ryan", "Zoe", "Jack", "Harper", "Elijah", "Ava", "Isaac", "Mia", "Caleb", "Ella"
+    };
+    std::vector<std::string> last_names = {
+        "Doe", "Smith", "Johnson", "Williams", "Jones", "Brown", "Davis", "Miller", "Wilson", "Moore",
+        "Taylor", "Anderson", "Thomas", "Jackson", "White", "Harris", "Martin", "Thompson", "Garcia", "Martinez",
+        "Roberts", "Clark", "Lewis", "Walker", "Young", "Allen", "King", "Wright", "Scott", "Adams",
+        "Baker", "Gonzalez", "Nelson", "Carter", "Mitchell", "Perez", "Robinson", "Hughes", "Flores", "Cook",
+        "Rogers", "Gutierrez", "Ramirez", "Diaz", "Perez", "Ross", "Sanders", "Price", "Howard", "Cooper"
+    };
+
+    std::vector<testData> vecTest;
+
+    for (int i = 0; i < 50; ++i)
+    {
+        std::string first_name = generate_random_string(first_names);
+        std::string last_name = generate_random_string(last_names);
+        int birth_year = generate_random_year(1900, 2000);
+
+        vecTest.push_back({ first_name, last_name, birth_year });
+    }
+
+    return vecTest;
+}
+
+inline std::unique_ptr<odb::database> openDB(std::string path_db)
+{
+    // Открыть БД, если она существует
+    if (std::filesystem::is_regular_file(path_db))
+        return std::unique_ptr<odb::core::database>(new odb::sqlite::database(path_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
+
+    // И создать новую, если не существует
+    std::unique_ptr<odb::core::database> db(new odb::sqlite::database(path_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
+
+    odb::core::connection_ptr connect_ptr(db->connection());
+
+    connect_ptr->execute("PRAGMA foreign_keys=OFF");
+
+    odb::core::transaction tans(db->begin());
+    odb::core::schema_catalog::create_schema(*db);
+    tans.commit();
+
+    connect_ptr->execute("PRAGMA foreign_keys=ON");
+
+    return db;
+}
+
+inline std::unique_ptr<odb::database> create_database(int& argc, char* argv[])
+{
+    using namespace std;
+    using namespace odb::core;
+
+    if (argc > 1 && argv[1] == string("--help"))
+    {
+        cout << "Usage: " << argv[0] << " [options]" << endl
+             << "Options:" << endl;
+
+#if defined(DATABASE_MYSQL)
+        odb::mysql::database::print_usage(cout);
+#elif defined(DATABASE_SQLITE)
+        odb::sqlite::database::print_usage(cout);
+#elif defined(DATABASE_PGSQL)
+        odb::pgsql::database::print_usage(cout);
+#elif defined(DATABASE_ORACLE)
+        odb::oracle::database::print_usage(cout);
+#elif defined(DATABASE_MSSQL)
+        odb::mssql::database::print_usage(cout);
+#endif
+
+        exit(0);
+    }
+
+#if defined(DATABASE_MYSQL)
+    unique_ptr<database> db(new odb::mysql::database(argc, argv));
+#elif defined(DATABASE_SQLITE)
+
+    unique_ptr<database> db(new odb::sqlite::database(argc,
+                                                      argv,
+                                                      false,
+                                                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
+
+    // Create the database schema. Due to bugs in SQLite foreign key
+    // support for DDL statements, we need to temporarily disable
+    // foreign keys.
+    //
+    {
+        connection_ptr connect_ptr(db->connection());
+
+        connect_ptr->execute("PRAGMA foreign_keys=OFF");
+
+        transaction tans(connect_ptr->begin());
+        schema_catalog::create_schema(*db);
+        tans.commit();
+
+        connect_ptr->execute("PRAGMA foreign_keys=ON");
+    }
+#elif defined(DATABASE_PGSQL)
+    unique_ptr<database> db(new odb::pgsql::database(argc, argv));
+#elif defined(DATABASE_ORACLE)
+    unique_ptr<database> db(new odb::oracle::database(argc, argv));
+#elif defined(DATABASE_MSSQL)
+    unique_ptr<database> db(
+    new odb::mssql::database(argc, argv, false, "TrustServerCertificate=yes"));
+#endif
+
+    return db;
+}
+
+#endif // DATABASE_HXX

src/databasemanager.cpp

@@ -0,0 +1,118 @@
+#include "databasemanager.h"
+
+// Singleton instance
+DatabaseManager& DatabaseManager::instance()
+{
+    static DatabaseManager instance;
+    return instance;
+}
+
+// Конструктор: создаем подключение
+DatabaseManager::DatabaseManager()
+{
+    db = QSqlDatabase::addDatabase("QSQLITE");
+    db.setDatabaseName("mydatabase.db");
+
+    if (!db.open())
+    {
+        qDebug() << "Ошибка открытия БД:" << db.lastError().text();
+    }
+    else
+    {
+        qDebug() << "База данных успешно открыта";
+    }
+}
+
+// Деструктор: закрываем подключение
+DatabaseManager::~DatabaseManager()
+{
+    if (db.isOpen())
+    {
+        db.close();
+    }
+}
+
+// Возвращает ссылку на объект БД
+QSqlDatabase& DatabaseManager::database()
+{
+    return db;
+}
+
+// Выполняет SQL-запрос (без параметров)
+bool DatabaseManager::executeQuery(const QString& query)
+{
+    QSqlQuery q;
+    if (!q.exec(query))
+    {
+        qDebug() << "Ошибка выполнения запроса:" << q.lastError().text();
+        return false;
+    }
+    return true;
+}
+
+// Выполняет подготовленный SQL-запрос с параметрами
+bool DatabaseManager::executePreparedQuery(const QString& query, const QStringList& values)
+{
+    QSqlQuery q;
+    q.prepare(query);
+
+    for (const auto& value : values)
+        q.addBindValue(value);
+
+    if (!q.exec())
+    {
+        qDebug() << "Ошибка выполнения подготовленного запроса:" << q.lastError().text();
+        return false;
+    }
+    return true;
+}
+
+QList<QVariantList> DatabaseManager::executeSelectQuery(const QString& query, const QStringList& values)
+{
+    QSqlQuery q;
+    q.prepare(query);
+
+    for (const auto& value : values)
+        q.addBindValue(value);
+
+    if (!q.exec())
+    {
+        qDebug() << "Ошибка выполнения SELECT запроса:" << q.lastError().text();
+        return {};
+    }
+
+    QList<QVariantList> results;
+    while (q.next())
+    {
+        QVariantList row;
+        for (int i = 0; i < q.record().count(); ++i)
+            row.append(q.value(i));
+        results.append(row);
+    }
+
+    return results;
+}
+
+QList<QVariantList> DatabaseManager::executeSelect(const SelectBuilder& selectBuilder)
+{
+    const auto queryString = selectBuilder.getSelect();
+    qDebug() << "Подготовленный запрос: " << queryString;
+
+    QSqlQuery q;
+    if (!q.prepare(queryString))
+        qDebug() << "Ошибка при подготовке запроса:" << q.lastError().text();
+
+    if (!q.exec())
+        qDebug() << "Ошибка при выполнении запроса:" << q.lastError().text();
+
+    QList<QVariantList> results;
+    while (q.next()) // Проходимся по строкам
+    {
+        QVariantList row;
+        for (int i = 0; i < q.record().count(); ++i) // Проходимся по столбцам
+            row.append(q.value(i));
+        results.append(row);
+    }
+
+    return results;
+}

src/databasemanager.h

@@ -0,0 +1,59 @@
+#ifndef DATABASEMANAGER_H
+#define DATABASEMANAGER_H
+
+#include <QDebug>
+#include <QtSql>
+
+struct SelectBuilder
+{
+    QString tableName;
+    QStringList rows = { "*" };
+    QString where;
+
+    QString getSelect() const
+    {
+        QString allRows;
+
+        auto ri = rows.begin();
+        while (ri != rows.end())
+        {
+            allRows += (*ri++);
+
+            if (ri != rows.end())
+                allRows += ", ";
+        }
+
+        QString queryString = QString("SELECT %1").arg(allRows);
+
+        queryString += QString(" FROM %1").arg(tableName);
+
+        if (!where.isEmpty())
+            queryString += QString(" WHERE %1").arg(where);
+
+        queryString += ';';
+        return queryString;
+    }
+};
+
+class DatabaseManager
+{
+public:
+    static DatabaseManager& instance(); // Singleton
+
+    QSqlDatabase& database();
+
+    bool executeQuery(const QString& query);
+    bool executePreparedQuery(const QString& query, const QStringList& values);
+
+    QList<QVariantList> executeSelectQuery(const QString& query, const QStringList& values = {});
+
+    QList<QVariantList> executeSelect(const SelectBuilder& selectBuilder);
+
+private:
+    DatabaseManager();
+    ~DatabaseManager();
+
+    QSqlDatabase db;
+};
+
+#endif // DATABASEMANAGER_H

src/main.cpp

@@ -0,0 +1,180 @@
+#include <QCoreApplication>
+
+#include "restapiserver.h"
+
+/* Опыты с odb */
+#include "author_s-odb.hxx" // Должен быть здесь
+#include "author_s.h"
+
+#include "book_s-odb.hxx" // Должен быть здесь
+#include "book_s.h"
+
+#include <odb/database.hxx>
+
+#include "database.hxx" // create_database
+
+using unidb = std::unique_ptr<odb::database>;
+
+void fillBooksBD(unidb& db)
+{
+    try
+    {
+        std::vector<std::shared_ptr<Author_S>> authors = {
+            std::make_shared<Author_S>("George", "Orwell", 142),
+            std::make_shared<Author_S>("J.K.", "Rowling", 56),
+            std::make_shared<Author_S>("J.R.R.", "Tolkien", 81),
+            std::make_shared<Author_S>("Leo", "Tolstoy", 189),
+            std::make_shared<Author_S>("Fyodor", "Dostoevsky", 174),
+            std::make_shared<Author_S>("Mark", "Twain", 183),
+            std::make_shared<Author_S>("Charles", "Dickens", 208),
+            std::make_shared<Author_S>("Virginia", "Woolf", 134),
+            std::make_shared<Author_S>("Ernest", "Hemingway", 122),
+            std::make_shared<Author_S>("Gabriel", "García Márquez", 98),
+            std::make_shared<Author_S>("Franz", "Kafka", 100),
+            std::make_shared<Author_S>("Harper", "Lee", 64),
+            std::make_shared<Author_S>("William", "Shakespeare", 459),
+            std::make_shared<Author_S>("Oscar", "Wilde", 155),
+            std::make_shared<Author_S>("Aldous", "Huxley", 123),
+            std::make_shared<Author_S>("Jane", "Austen", 210),
+            std::make_shared<Author_S>("John", "Steinbeck", 116),
+            std::make_shared<Author_S>("Agatha", "Christie", 124),
+            std::make_shared<Author_S>("Isaac", "Asimov", 105)
+        };
+
+        // Список книг
+        std::vector<Book_S> books = {
+            Book_S("1984", authors[0], 1949),
+            Book_S("Harry Potter and the Philosopher's Stone", authors[1], 1997),
+            Book_S("The Hobbit", authors[2], 1937),
+            Book_S("War and Peace", authors[3], 1869),
+            Book_S("Crime and Punishment", authors[4], 1866),
+            Book_S("Adventures of Huckleberry Finn", authors[5], 1884),
+            Book_S("A Tale of Two Cities", authors[6], 1859),
+            Book_S("Mrs. Dalloway", authors[7], 1925),
+            Book_S("The Old Man and the Sea", authors[8], 1952),
+            Book_S("One Hundred Years of Solitude", authors[9], 1967),
+            Book_S("The Trial", authors[10], 1925),
+            Book_S("To Kill a Mockingbird", authors[11], 1960),
+            Book_S("Macbeth", authors[12], 1606),
+            Book_S("The Picture of Dorian Gray", authors[13], 1890),
+            Book_S("Brave New World", authors[14], 1932),
+            Book_S("Pride and Prejudice", authors[15], 1813),
+            Book_S("The Brothers Karamazov", authors[4], 1880),
+            Book_S("The Grapes of Wrath", authors[16], 1939),
+            Book_S("Murder on the Orient Express", authors[17], 1934),
+            Book_S("I, Robot", authors[18], 1950),
+            Book_S("Animal Farm", authors[0], 1945),
+            Book_S("Harry Potter and the Chamber of Secrets", authors[1], 1998),
+            Book_S("The Lord of the Rings: The Fellowship of the Ring", authors[2], 1954),
+            Book_S("Anna Karenina", authors[3], 1878),
+            Book_S("The Idiot", authors[4], 1869),
+            Book_S("The Adventures of Tom Sawyer", authors[5], 1876),
+            Book_S("Oliver Twist", authors[6], 1837),
+            Book_S("To the Lighthouse", authors[7], 1927),
+            Book_S("For Whom the Bell Tolls", authors[8], 1940),
+            Book_S("Love in the Time of Cholera", authors[9], 1985),
+            Book_S("The Metamorphosis", authors[10], 1915),
+            Book_S("Go Set a Watchman", authors[11], 2015),
+            Book_S("King Lear", authors[12], 1605),
+            Book_S("The Importance of Being Earnest", authors[13], 1895),
+            Book_S("Brave New World Revisited", authors[14], 1958),
+            Book_S("Emma", authors[15], 1815),
+            Book_S("The Double", authors[4], 1846),
+            Book_S("Of Mice and Men", authors[16], 1937),
+            Book_S("And Then There Were None", authors[17], 1939),
+            Book_S("The Foundation Trilogy", authors[18], 1951),
+            Book_S("Down and Out in Paris and London", authors[0], 1933),
+            Book_S("Harry Potter and the Prisoner of Azkaban", authors[1], 1999),
+            Book_S("The Lord of the Rings: The Two Towers", authors[2], 1954),
+            Book_S("War and Peace", authors[3], 1869),
+            Book_S("The Brothers Karamazov", authors[4], 1880),
+            Book_S("The Prince and the Pauper", authors[5], 1881),
+            Book_S("David Copperfield", authors[6], 1850),
+            Book_S("The Waves", authors[7], 1931),
+            Book_S("A Farewell to Arms", authors[8], 1929),
+            Book_S("Chronicle of a Death Foretold", authors[9], 1981)
+        };
+
+        // Сохранение авторов в базу данных
+        {
+            odb::core::transaction t(db->begin());
+            for (auto& author : authors)
+                db->persist(author.get()); // Используем get() для получения сырого указателя
+            t.commit();
+        }
+
+        // Сохранение книг в базу данных
+        {
+            odb::core::transaction t(db->begin());
+            for (auto& book : books)
+                db->persist(book);
+            t.commit();
+        }
+
+        std::cout << "Test data added successfully." << std::endl;
+    }
+    catch (const odb::exception& e)
+    {
+        std::cerr << "Error adding test data: " << e.what() << std::endl;
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    const std::string dbPath = "test_db.sqlite";
+    std::unique_ptr<odb::database> db(openDB(dbPath));
+
+    // fillBooksBD(db);
+
+    RestApiServer server(*db);
+    server.start(8080);
+
+    /* Опыты с odb */
+
+    // const std::string dbPath = "test_db.sqlite";
+
+    // std::vector<Author_S> authors;
+
+    // odb::core::transaction trans(db->begin());
+    // for (auto data : fillDB())
+    // {
+    //     auto a = Author_S(data.first, data.last, data.age);
+    //     db->persist(a);
+    // }
+    // trans.commit();
+
+    // try
+    // {
+    //     odb::core::transaction tr(db->begin());
+    //     odb::query<Author_S> query;
+    //     odb::result<Author_S> result;
+
+    //     odb::result<Author_S> r(db->query<Author_S>(odb::query<Author_S>::age >= 2000));
+
+    //     for (const auto& author : r)
+    //     {
+    //         std::cout << "First: " << author.first() << ", Last: " << author.last() << ", Year: " << author.age() << std::endl;
+    //     }
+
+    //     tr.commit();
+    // }
+    // catch (const odb::exception& e)
+    // {
+    //     std::cerr << "ODB error: " << e.what() << std::endl;
+    //     return 1;
+    // }
+    // Set up code that uses    the Qt event loop here.
+    // Call a.quit() or a.exit() to quit the application.
+    // A not very useful example would be including
+    // #include <QTimer>
+    // near the top of the file and calling
+    // QTimer::singleShot(5000, &a, &QCoreApplication::quit);
+    // which quits the application after 5 seconds.
+
+    // If you do not need a running Qt event loop, remove the call
+    // to a.exec() or use the Non-Qt Plain C++ Application template.
+
+    return a.exec();
+}

src/restapiserver.cpp

@@ -0,0 +1,129 @@
+#include "restapiserver.h"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+
+#include "book_s-odb.hxx"
+#include "book_s.h"
+
+#include <odb/core.hxx>
+#include <odb/database.hxx>
+#include <odb/query.hxx>
+
+RestApiServer::RestApiServer(odb::database& db, QObject* parent) :
+    m_db(db), QTcpServer(parent) {}
+
+void RestApiServer::start(quint16 port)
+{
+    if (!this->listen(QHostAddress::Any, port))
+    {
+        qWarning() << "Ошибка запуска сервера!";
+    }
+    else
+    {
+        qDebug() << "REST API сервер запущен на порту:" << port;
+    }
+}
+
+void RestApiServer::incomingConnection(qintptr socketDescriptor)
+{
+    QTcpSocket* socket = new QTcpSocket(this);
+    socket->setSocketDescriptor(socketDescriptor);
+
+    connect(socket, &QTcpSocket::readyRead, this, &RestApiServer::handleRequest);
+    connect(socket, &QTcpSocket::disconnected, socket, &QTcpSocket::deleteLater);
+}
+
+void RestApiServer::handleRequest()
+{
+    QTcpSocket* socket = qobject_cast<QTcpSocket*>(sender());
+    if (!socket)
+        return;
+
+    QString request = QString::fromUtf8(socket->readAll());
+    QByteArray response = processRequest(request);
+
+    socket->write(response);
+    socket->flush();
+    socket->disconnectFromHost();
+}
+
+QByteArray RestApiServer::processRequest(const QString& request)
+{
+    if (request.startsWith("GET /books/author/"))
+    {
+        QString author = request.section(' ', 1, 1).section('/', 3, 3).replace("%20", " ");
+
+        // Books books;
+        // QList<BookRecord> results = books.getBooksByAuthor(author);
+
+        QByteArray jsonResponse = "{ \"books\": [";
+        // for (const BookRecord& book : results)
+        // {
+        //     jsonResponse += QString("{ \"id\": %1, \"title\": \"%2\", \"author\": \"%3\", \"year\": %4 },")
+        //                     .arg(book.id)
+        //                     .arg(book.title)
+        //                     .arg(book.author)
+        //                     .arg(book.year)
+        //                     .toUtf8();
+        // }
+        // if (results.size() > 0)
+        //     jsonResponse.chop(1); // Убираем последнюю запятую
+        // jsonResponse += "] }";
+
+        return "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n" + jsonResponse;
+    }
+
+    if (request.startsWith("GET /books"))
+    {
+        odb::transaction t(m_db.begin());
+        odb::result<Book_S> res(m_db.query<Book_S>());
+
+        QJsonArray jArray;
+
+        for (auto it = res.begin(); it != res.end(); ++it)
+        {
+            const auto& book = *it;
+
+            QJsonObject j;
+            j["id"] = QString::number(book.id());
+            j["title"] = QString::fromStdString(book.name());
+            j["author"] = QString::fromStdString(book.author()->full_name());
+            j["year"] = book.year();
+            jArray.push_back(j);
+        }
+        auto jDoc = QJsonDocument(jArray);
+
+        t.commit();
+
+        return "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n" + jDoc.toJson(QJsonDocument::Indented);
+    }
+
+    if (request.startsWith("GET /author"))
+    {
+        odb::transaction t(m_db.begin());
+        odb::result<Author_S> res(m_db.query<Author_S>());
+
+        QJsonArray jArray;
+
+        for (auto it = res.begin(); it != res.end(); ++it)
+        {
+            const auto& author = *it;
+
+            QJsonObject j;
+            j["id"] = QString::number(author.id());
+            j["first"] = QString::fromStdString(author.first());
+            j["last"] = QString::fromStdString(author.last());
+            j["age"] = author.age();
+            jArray.push_back(j);
+        }
+        auto jDoc = QJsonDocument(jArray);
+
+        t.commit();
+        return "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n" + jDoc.toJson(QJsonDocument::Indented);
+    }
+
+    return "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\n\r\nNot Found";
+}

src/restapiserver.h

@@ -0,0 +1,28 @@
+#ifndef RESTAPISERVER_H
+#define RESTAPISERVER_H
+
+#include <odb/database.hxx>
+
+#include <QTcpServer>
+#include <QTcpSocket>
+
+class RestApiServer : public QTcpServer
+{
+    Q_OBJECT
+public:
+    explicit RestApiServer(odb::core::database& db, QObject* parent = nullptr);
+    void start(quint16 port = 8080);
+
+protected:
+    void incomingConnection(qintptr socketDescriptor) override;
+
+private slots:
+    void handleRequest();
+
+private:
+    QByteArray processRequest(const QString& request);
+
+    odb::core::database& m_db;
+};
+
+#endif // RESTAPISERVER_H

test/requests/all_books.http

@@ -0,0 +1 @@
+GET http://localhost:8080/books/

test/requests/autor_books.http

@@ -0,0 +1 @@
+GET http://localhost:8080/books/author/George%20Orwell