database.h

/*
 *openPilotLog - A FOSS Pilot Logbook Application
 *Copyright (C) 2020-2021 Felix Turowsky
 *
 *This program is free software: you can redistribute it and/or modify
 *it under the terms of the GNU General Public License as published by
 *the Free Software Foundation, either version 3 of the License, or
 *(at your option) any later version.
 *
 *This program is distributed in the hope that it will be useful,
 *but WITHOUT ANY WARRANTY; without even the implied warranty of
 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *GNU General Public License for more details.
 *
 *You should have received a copy of the GNU General Public License
 *along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef DATABASE_H
#define DATABASE_H
 
#include <QPair>
#include <QHash>
#include <QString>
#include <QDir>
#include <QSqlDatabase>
#include <QSqlDriver>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlTableModel>
#include <QSqlQuery>
#include <QSqlRecord>
#include <QSqlField>
 
#include "src/opl.h"
#include "src/database/row.h"
#include "src/classes/astandardpaths.h"
 
using RowData_T = QHash<QString, QVariant>;
 
namespace OPL {
 
#define DB OPL::Database::instance()
 
struct UserDataState {
 
    UserDataState(){numTails = 0; numPilots = 0;}
    UserDataState(int numTails_, int numPilots_)
        : numTails(numTails_), numPilots(numPilots_){}
 
    bool operator==(const UserDataState& other)
    {
        return numTails == other.numTails && numPilots == other.numPilots;
    }
    bool operator!=(const UserDataState& other)
    {
        return numTails != other.numTails || numPilots != other.numPilots;
    }
 
    int numTails;
    int numPilots;
};
 
 
 
class Database : public QObject {
 
private:
    Q_OBJECT
    Database()
        : databaseFile(QFileInfo(AStandardPaths::directory(AStandardPaths::Database).
                                 absoluteFilePath(QStringLiteral("logbook.db"))))
    {}
    static Database* self;
    const QFileInfo databaseFile;
    QStringList tableNames;
    QHash<QString, QStringList> tableColumns;
 
    inline const static QString SQLITE_DRIVER  = QStringLiteral("QSQLITE");
    inline const static QList<OPL::DbTable> USER_TABLES = {
        OPL::DbTable::Flights,
        OPL::DbTable::Pilots,
        OPL::DbTable::Tails
    };
    inline const static QList<OPL::DbTable> TEMPLATE_TABLES = {
        OPL::DbTable::Aircraft,
        OPL::DbTable::Airports,
        OPL::DbTable::Currencies,
        OPL::DbTable::Changelog
    };
 
 
public:
    Database(const Database&) = delete;
    void operator=(const Database&) = delete;
    static Database* instance();
 
    QSqlError lastError;
 
    bool connect();
 
    void disconnect();
 
    void updateLayout();
 
    const QString version() const;
 
    const QString sqliteVersion() const;
 
    const QStringList getTableNames() const;
 
    const QStringList getTableColumns(OPL::DbTable table_name) const;
 
    static QSqlDatabase database();
 
    QVector<QVariant> customQuery(QString statement, int return_values);
 
    bool exists(const OPL::Row &row);
 
    bool clear();
 
    bool commit(const OPL::Row &row);
 
    bool commit(const QJsonArray &json_arr, const OPL::DbTable table);
 
    bool insert(const OPL::Row &new_row);
 
    bool update(const OPL::Row &updated_row);
 
    bool remove(const OPL::Row &row);
 
    bool removeMany(OPL::DbTable table, const QList<int> &row_id_list);
 
    OPL::Row getRow(const OPL::DbTable table, const int row_id);
 
    RowData_T getRowData(const OPL::DbTable table, const int row_id);
 
    inline OPL::PilotEntry getPilotEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Pilots, row_id);
        return OPL::PilotEntry(row_id, data);
    }
 
    inline OPL::TailEntry getTailEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Tails, row_id);
        return OPL::TailEntry(row_id, data);
    }
 
    inline OPL::AircraftEntry getAircraftEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Aircraft, row_id);
        return OPL::AircraftEntry(row_id, data);
    }
 
    inline OPL::FlightEntry getFlightEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Flights, row_id);
        return OPL::FlightEntry(row_id, data);
    }
 
    inline OPL::SimulatorEntry getSimEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Simulators, row_id);
        return OPL::SimulatorEntry(row_id, data);
    }
 
    inline OPL::CurrencyEntry getCurrencyEntry(int row_id)
    {
        const auto data = getRowData(OPL::DbTable::Currencies, row_id);
        return OPL::CurrencyEntry(row_id, data);
    }
 
    int getLastEntry(OPL::DbTable table);
 
    QList<int> getForeignKeyConstraints(int foreign_row_id, OPL::DbTable table);
 
    QVector<RowData_T> getTable(OPL::DbTable table);
 
    const QList<OPL::DbTable> &getUserTables() const;
 
    const QList<OPL::DbTable> &getTemplateTables() const;
 
    const UserDataState getUserDataState() const;
 
    // Maintenance and setup
 
    bool createSchema();
    bool importTemplateData(bool use_local_ressources);
 
    bool resetUserData();
 
    bool createBackup(const QString& dest_file);
 
    bool restoreBackup(const QString& backup_file);
 
 
 
signals:
    void dataBaseUpdated();
    void connectionReset();
};
 
} // namespace OPL
 
#endif // DATABASE_H