aswi2021virtual-surreality-gitlab/db_browser/dbaccess.cpp @ c137512e

#include "dbaccess.h"
#include <QSqlQueryModel>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QDate>
#include <QList>
#include "QsLog.h"

#include <QtDebug>

dbAccess::dbAccess(QObject *parent) : QObject(parent)
{
    db = new QSqlDatabase( QSqlDatabase::addDatabase("QPSQL") );
    if (!db->isValid()) {
        QLOG_ERROR() << "db connection err: " << db->lastError().text();
    }
    result_query = new QSqlQuery(*db);
}

dbAccess::~dbAccess()
{
    if (db->isOpen()) {
        db->close();
    }
    QString cn = db->database().connectionName();
    db->removeDatabase(cn);
}

//! Připojení k databázi
/*!
  Funkce slouží pro připojení na databázi, kterou aplikace bude využívat. Databázový server může být
  kdekoliv v síti, takže mezi parametry je i IP adresa a síťový port.
  \param server Adresa server, na kterém je databáze.
  \param userName Uživatelské jméno.
  \param password Heslo.
  \param port Port, na kterém naslouchá databázový server.
  \param dbName Jméno databáze.
  \return True, pokud se podaří k databázi připojit, false pokud ne.
*/
bool dbAccess::connect(QString server, QString userName, QString password, int port, QString dbName)
{
    db->setConnectOptions();
    db->setHostName(server);
    db->setPort(port);
    db->setDatabaseName(dbName);
    db->setUserName(userName);
    db->setPassword(password);

    if(db->open()) {
        return true;
    }
    else {
        QLOG_ERROR() << "db connect err: " << db->lastError().text();
        return false;
    }
}

//! Vytvoření databázového modelu tabulky pacientů
/*!
  Funkce vytvoří databázový model kompletní tabulky pacientů, tento model lze posléze zobrazit v předem připraveném dialogu
  \param *m Ukazatel na objekt typu QSqlQueryModel.
*/
void dbAccess::getPatientsQueryModel(QSqlQueryModel *m)
{
    m->setQuery("select name, surname, birthdate, id_number, ind_id from patient", *db);
    if (m->lastError().isValid())
        qDebug() << m->lastError();
    m->setHeaderData(0, Qt::Horizontal, QObject::tr("Name"));
    m->setHeaderData(1, Qt::Horizontal, QObject::tr("Surname"));
    m->setHeaderData(2, Qt::Horizontal, QObject::tr("Birthdate"));
    m->setHeaderData(3, Qt::Horizontal, QObject::tr("ID number"));
    m->setHeaderData(4, Qt::Horizontal, QObject::tr("Indication ID"));
}

//! Vytvoření databázového modelu tabulky indikací
/*!
  Funkce vytvoří databázový model kompletní tabulky indikací, tento model lze posléze zobrazit v předem připraveném dialogu
  \param *m Ukazatel na objekt typu QSqlQueryModel.
*/
void dbAccess::getIndicationsQueryModel(QSqlQueryModel *m)
{
    m->setQuery("select indication, description, curve_name, procedure_time from indications", *db);
    if (m->lastError().isValid())
        qDebug() << m->lastError();
    m->setHeaderData(0, Qt::Horizontal, QObject::tr("Name"));
    m->setHeaderData(1, Qt::Horizontal, QObject::tr("Description"));
    m->setHeaderData(2, Qt::Horizontal, QObject::tr("Curve name"));
    m->setHeaderData(3, Qt::Horizontal, QObject::tr("Procedure time"));
}

//! Vytvoření databázového modelu tabulky výsledků
/*!
  Funkce vytvoří databázový model tabulky výsledků, tento model lze posléze zobrazit v předem připraveném dialogu.
  Model nemusí vytvořit pohled na celou tabulku, ale výsledky lze filtrovat podle ID pacienta a podle ID indikace.
  \param *m Ukazatel na objekt typu QSqlQueryModel.
  \param p_id ID pacienta
  \param ind_id ID indikace
*/
void dbAccess::getResultsQueryModel(QSqlQueryModel *m, int p_id, int ind_id)
{
    QString queryText = "SELECT p_id, ind_id, series, res_number, date, cycles, result FROM results";

    if (p_id != 0) {
        queryText += " WHERE p_id=" + QString::number(p_id);
        if (ind_id != 0) {
            queryText += " AND ind_id=" + QString::number(ind_id);
        }
    } else {
        if (ind_id != 0) {
            queryText += " WHERE ind_id=" + QString::number(ind_id);
        }
    }
    m->setQuery(queryText, *db);
    if (m->lastError().isValid())
        qDebug() << m->lastError();
    m->setHeaderData(0, Qt::Horizontal, QObject::tr("Patient ID"));
    m->setHeaderData(1, Qt::Horizontal, QObject::tr("Indication ID"));
    m->setHeaderData(2, Qt::Horizontal, QObject::tr("Series number"));
    m->setHeaderData(3, Qt::Horizontal, QObject::tr("Result number"));
    m->setHeaderData(4, Qt::Horizontal, QObject::tr("Date"));
    m->setHeaderData(5, Qt::Horizontal, QObject::tr("Cycles"));
    m->setHeaderData(6, Qt::Horizontal, QObject::tr("Results"));
}

//! Přidání nového pacienta do databáze
/*!
  Funkce je použita pro přidání údajů o novém pacientovi do databáze.
  \param name Jméno
  \param surname Příjmení
  \param birthdate Datum narození
  \param idNo Identifikační číslo pacienta (může to být RČ, nebo pořadové číslo....)
  \param indNo Indikace přiřazená danému pacientovi
*/
int dbAccess::addNewPatient(QString name, QString surname, QDate birthdate, QString idNo, QString indNo)
{
    QSqlQuery query(*db);

    query.prepare("INSERT INTO patient (name, surname, birthdate, id_number, ind_id)"
                  "VALUES (:name, :surname, :birthdate, :id_number, :ind_id)");
    query.bindValue(":name", name);
    query.bindValue(":surname", surname);
    query.bindValue(":birthdate", birthdate);
    query.bindValue(":id_number", idNo);
    query.bindValue(":ind_id", indNo);

    db->transaction();
    if (query.exec()) {
        db->commit();

        return ALL_OK;
    } else {
        qDebug() << query.lastError();
        db->rollback();
        return OTHER_ERR;
    }
}

//! Přidání nové indikace do databáze
/*!
  Funkce je použita pro přidání údajů o nové indikaci do databáze.
  \param name Jméno
  \param description Popis
  \param curveName Jméno cvičené křivky, odpovídající indikaci
  \param time Čas (v minutách), pokterý se bude daná křivka cvičit
 */
int dbAccess::addNewIndication(QString name, QString description, QString curveName, int time)
{
    QSqlQuery query(*db);

    query.prepare("INSERT INTO indications (indication, description, curve_name, procedure_time)"
                  "VALUES (:name, :description, :curve_name, :time)");
    query.bindValue(":name", name);
    query.bindValue(":description", description);
    query.bindValue(":curve_name", curveName);
    query.bindValue(":time", time);

    db->transaction();
    if (query.exec()) {
        db->commit();
        return ALL_OK;
    } else {
        qDebug() << query.lastError();
        db->rollback();
        return OTHER_ERR;
    }
    return ALL_OK;
}

//! Získání interního id pacienta
/*!
  Funkce je použita pro získání interního id daného pacienta na základě znalosti jeho identifikačního
  čísla. Interní ID se používá v dalších databázových dotazech
  \param pid Identifikační číslo pacienta
  \return Interní číslo pacienta
*/
int dbAccess::getPatientId(QString pid)
{
    QSqlQuery query(*db);
    int p_id = 0;

    if (query.exec("SELECT id FROM patient WHERE id_number=\'" + pid + "\'"))
    {
        while (query.next()) {
            p_id = query.value(0).toInt();
        }
    } else {
        qDebug() << query.lastError();
    }
    return p_id;
}

//! Získání interního id indikace
/*!
  Funkce je použita pro získání interního id dané indikace na základě znalosti jejího jména.
  Interní ID se používá v dalších databázových dotazech
  \param name Jméno indikace
  \return Interní číslo indikace
*/
int dbAccess::getIndicationId(QString name)
{
    QSqlQuery query(*db);
    int ind_id = 0;

    if (query.exec("SELECT ind_id FROM indications WHERE indication=\'" + name + "\'"))
    {
        while (query.next()) {
            ind_id = query.value(0).toInt();
        }
    } else {
        qDebug() << query.lastError();
    }
    return ind_id;
}

//! Získání údajů o indikaci
/*!
  Funkce je použita pro získání dalších informací o indikaci na základě znalosti jejího interního ID.
  \param[in] indId interní ID
  \param[out] *pTime doba trvání cvičení
  \param[out] *cName Jméno křivky
  \return True - data se podařilo načíst, False - data nelze načíst
*/
bool dbAccess::getIndicationInfo(int indId, int *pTime, QString *cName)
{
    QSqlQuery query(*db);

    if (query.exec("SELECT curve_name, procedure_time FROM indications WHERE ind_id=\'" + QString::number(indId) + "\'"))
    {
        while (query.next()) {
            *cName = query.value(0).toString();
            *pTime = query.value(1).toInt();
        }
    } else {
        qDebug() << query.lastError();
        return false;
    }
    return true;

}

//! Získání názvů všech indikací
/*!
  Funkce je použita pro získání názvů a interních ID všech indikací uložených v databázi.
  \param[out] *allIndIds Výsledný seznam všech interních ID
  \param[out] *allNames Seznam všech jmen indikací
  \return True - data se podařilo načíst, False - data nelze načíst
*/
bool dbAccess::getAllIndicationsName(QList<int> *allIndIds, QStringList *allNames)
{
    QSqlQuery query(*db);

    if (query.exec("SELECT ind_id, indication FROM indications")) {
        while (query.next()) {
            allIndIds->append(query.value(0).toInt());
            allNames->append(query.value(1).toString());
        }
    } else {
        qDebug() << query.lastError();
        return false;
    }
    return true;
}

//! Získání jmen všech pacientů
/*!
  Funkce je použita pro získání jmen a příjmení a interních ID všech pacientů uložených v databázi.
  \param[out] *allPIds Výsledný seznam všech interních ID
  \param[out] *allNames Seznam všech jmen pacientů
  \return True - data se podařilo načíst, False - data nelze načíst
*/
bool dbAccess::getAllPatientsName(QList<int> *allPIds, QStringList *allNames)
{
    QSqlQuery query(*db);

    if (query.exec("SELECT id, name, surname  FROM patient")) {
        while (query.next()) {
            allPIds->append(query.value(0).toInt());
            allNames->append(query.value(1).toString() + " " + query.value(2).toString());
        }
    } else {
        qDebug() << query.lastError();
        return false;
    }
    return true;
}

bool dbAccess::setActualIndication(int p_id, int ind_id)
{
    QSqlQuery query(*db);
    bool p_id_exists = false;

    if (query.exec("SELECT * FROM actual_indication WHERE id_p=" + QString::number(p_id))) {
        while (query.next()) {
            p_id_exists = true;
        }
    } else {
        qDebug() << query.lastError();
        return false;
    }

    if (p_id_exists) { //update
        if (query.exec("UPDATE actual_indication set id_ind=" + QString::number(ind_id) + " WHERE id_p=" + QString::number(p_id)))
            return true;
        else
            qDebug() << query.lastError();
    } else { //insert
        if (query.exec("INSERT INTO actual_indication VALUES (" + QString::number(p_id) + "," + QString::number(ind_id) +")"))
            return true;
        else
            qDebug() << query.lastError();
    }

    return false;

}

//! Získání pořadového čísla poslední série
/*!
  Funkce je použita pro získání pořadového čísla poslední série procedur pro pacienta s daným
interním identifikačním číslem
  \param p_id Interní identifikační číslo pacienta
  \return Pořadové číslo poslední série procedur
*/
int dbAccess::getLastSeriesNo(int p_id)
{
    int nRet = 0;
    QSqlQuery query(*db);
    QString seriesStr = QString::number(p_id);

    if (query.exec("SELECT series FROM results WHERE p_id=" + seriesStr + "ORDER BY series DESC LIMIT 1"))
    {
        while (query.next()) {
            nRet = query.value(0).toInt();
        }
    }
    return nRet;
}

//! Získání pořadového čísla poslední procedury v sérii
/*!
  Funkce je použita pro získání pořadového čísla poslední procedury v zadané sérii pro pacienta s daným
interním identifikačním číslem
  \param p_id Interní identifikační číslo pacienta
  \param series Pořadové číslo série, ke které se má vyhledat poslední procedura
  \return Pořadové číslo poslední procedury v dané sérii
*/
int dbAccess::getLastSeriesResultNo(int p_id, int series)
{
    int nRet = 0;
    QSqlQuery query(*db);
    QString seriesStr = QString::number(series);

    if (query.exec("SELECT res_number FROM results WHERE p_id=" + QString::number(p_id) + "AND series=" + seriesStr + "ORDER BY res_number DESC LIMIT 1"))
    {
        while (query.next()) {
            nRet = query.value(0).toInt();
        }
    }
    return nRet;
}

//! Vložení výsledku procedury
/*!
  Funkce je použita pro vložení výsledku procedury v zadané sérii pro prčitého pacienta a indikaci. Pořadové číslo procedury
se zvýší automaticky při zadání nového výsledku.
  \param p_id Interní identifikační číslo pacienta
  \param ind_id Interní identifikační číslo indikace
  \param series Pořadové číslo série, ke které se ukládá výsledek
  \param quality Seznam kvalit jednotlivých cyklů procedury
  \return True - výsledek se podařilo uložit, False - chyba při ukládání výsledku
*/
bool dbAccess::addResult(int p_id, int ind_id, int series, QList<int> quality)
{
    QSqlQuery query(*db);
    QString queryText;
    int res_no = getLastSeriesResultNo(p_id, series)+1;
    QDateTime now = QDateTime::currentDateTime();

    queryText = "INSERT INTO results(p_id, ind_id, series, res_number, date, cycles, result) VALUES (" + QString::number(p_id) + "," + QString::number(ind_id) + ",";
    queryText += QString::number(series) + ",";
    queryText += QString::number(res_no) + ",";
    queryText += " TIMESTAMP \'" + now.toString("yyyy-MM-dd hh:mm:ss") + "\',";
    queryText += QString::number(quality.size()) + ",'{";

    for(auto &val: quality) { //C++ 11 use
        queryText += QString::number(val) + ",";
    }
    queryText.chop(1);
    queryText += "}')";

    if (!query.exec(queryText)) {
        qDebug() << query.lastError();
        return false;
    }

    return true;
}

/*! Získání jednotlivého výsledku
 Po volání funkce getResultsNumber lze použít tuto funkci, která při každém volání vrátí výsledky další procedury
 \param[out] *cycles Počet cyklů procedury
 \param[out] *quality Seznam kvalit cvičení pro každý cyklus procedury
 \return true - dotaz byl ukončen úspěšně, false - chyba při volání dotazu
 \sa getResultsNumber()
 */
bool dbAccess::getNextResult(int *cycles, QString *quality)
{
    if (result_query->isActive()) {
        if (result_query->next()) {
            *cycles = result_query->value(0).toInt();
            *quality = result_query->value(1).toString();
            return true;
        }
    }
    return false;
}

//! Získání průměrné hodnoty kvality cvičení pro každou proceduru v dané sérii
/*!
  Funkce je použita pro získání průměrné hodnoty kvality cvičení pro každou proceduru
 v dané sérii pro pacienta s požadovaným interním identifikačním číslem
  \param p_id Interní identifikační číslo pacienta
  \param series Pořadové číslo série, ke které se mají vyhledat průměry
  \param *avg - pole, které bude obsahovat jednotlivé průměry kvality cvičení
  \return Pořadové číslo poslední procedury v dané sérii
*/
bool dbAccess::getSeriesResultAvg(int p_id, int series, QList<int> *avg)
{
    QString res, queryText = "SELECT result FROM results";
    QStringList partQ;
    int quality;
    QSqlQuery query(*db);

    queryText += " WHERE p_id=" + QString::number(p_id);
    queryText += " AND series=" + QString::number(series);
    queryText += "ORDER BY res_number ASC";

    avg->clear();

    if (query.exec(queryText)) {
        while (query.next()) {
            res = query.value(0).toString();
            //remove '{' and '}' from result string
            if (res.contains('{'))
                res.remove(0,1);
            if (res.contains('}'))
                res.chop(1);
            partQ = res.split(",");
            quality = 0;
            for (auto &str : partQ ) {
                quality += str.toInt();
            }
            avg->append(quality/partQ.size());
        }
    } else {
        qDebug() << result_query->lastError();
        return false;
    }
    return true;
}

/*! Získání počtu výsledků
 *!
 Funkce slouží pro získání celkového počtu výsledků pro zadané číslo pacienta a procedury. Pokud je číslo pacienta, nebo procedury 0,
 vyhledávají se výsledky pro všechny pacienty, nebo indikace. Funkce také slouží jako start pro iteraci přes jednotlivé výsledky. Pro iteraci slouží funkce
 getNextResult()
 \param[in] p_id Interní číslo pacienta
 \param[in] ind_id Interní číslo indikace
 \param[out] *results_count počet výsledků, které odpovídají zadaným parametrům p_id a ind_id
 \return true - dotaz byl ukončen úspěšně, false - chyba při volání dotazu
 \sa getNextResult()
*/
bool dbAccess::getResultsNumber(int p_id, int ind_id, int *results_count)
{
    QString queryText = "SELECT cycles, result FROM results";

    if (p_id != 0) {
        queryText += " WHERE p_id=" + QString::number(p_id);
        if (ind_id != 0) {
            queryText += " AND ind_id=" + QString::number(ind_id);
        }
    } else {
        if (ind_id != 0) {
            queryText += " WHERE ind_id=" + QString::number(ind_id);
        }
    }

    if (result_query->exec(queryText)) {
        *results_count = result_query->size();
    } else {
        qDebug() << result_query->lastError();
        return false;
    }
    return true;
}