colnod-connector/src/colnod/datamanager.cpp

#include "datamanager.h"

DataManager::DataManager()
{
    db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
    nextLastSync = db->getNow();
    lastSync = db->getLastSync();
    qDebug() << lastSync;
    //db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12");
}

void DataManager::fillFullTokensColnod(QString response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (items.size() > 0)
    {
        for (QJsonValueRef item : items)
        {
            auto token = new Token();
            token->fromJSON(item.toObject());
            fullTokensColnod.insert(token->idToStringWithoutBraces(), token);
        }
    }
    else
    {
        auto token = new Token("empty");
        fullTokensColnod.insert(token->idToStringWithoutBraces(), token);
    }
}

void DataManager::fillTokensColnod(QString response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (items.size() > 0)
    {
        for (QJsonValueRef item : items)
        {
            auto token = new Token();
            token->fromJSON(item.toObject());
            token->setDeleted(false);
            tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token);
        }
    }
    else
    {
        auto token = new Token("empty");
        tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token);
    }
}

void DataManager::fillSubjectsColnod(QString response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (items.size() > 0)
    {
        for (QJsonValueRef item : items)
        {
            auto subject = new Subject();
            subject->fromJSON(item.toObject());
            subjectsColnod.insert(subject->idToStringWithoutBraces(), subject);
        }
    }
    else
    {
        Subject* subject = new Subject("empty");
        subjectsColnod.insert(subject->idToStringWithoutBraces(), subject);
    }
}

// fills tokensDB and tokensToDeleteDB
void DataManager::fillTokensDB()
{
    QSqlQuery* query = db->getUpdatedTokens();
    while (query->next())
    {
        auto token = new Token;
        token->fromSQLRecord(query);
        tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token);
    }
    qDebug() << "Number of tokens to update from DB: "<< tokensToUpdateDB.size();
    qDebug() << "Number of tokens to delete from DB: "<< tokensToDeleteDB.size();
}

void DataManager::fillSubjectsDB()
{
   // Not needed yet
}

void DataManager::fillSubjectsToDeleteColnod(QString json)
{
    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (items.size() > 0)
    {
        for (QJsonValueRef item : items) {
            subjectsToDeleteColnod.append(item.toString());
        }
    }
    else {
        subjectsToDeleteColnod.append("empty");
    }
}

void DataManager::fillTokensToDeleteColnod(QString json)
{
    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (items.size() > 0)
    {
        for (QJsonValueRef item : items) {
            tokensToDeleteColnod.append(item.toString());
        }
    }
    else {
        tokensToDeleteColnod.append("empty");
    }
}

void DataManager::fillSubjectsToDeleteDB()
{
    // Not needed yet
}

void DataManager::pushSubjectsToDB()
{
    if (subjectsColnod.contains("empty")) {
        qDebug() << "All subjects are up to date";
        return;
    }
    //QSqlDatabase::database().transaction();
    qDebug() << "Subjects in progress...";
    for (auto subject : subjectsColnod)
    {
        db->saveSubject(subject, "colnod_subject");
        db->saveSubjectAttribute(subject, "colnod_subject_attribute");
    }
    //QSqlDatabase::database().commit();
    qDebug() << subjectsColnod.size() << " subjects has been updated";

}

void DataManager::pushTokensToDB()
{
    if (tokensToUpdateColnod.contains("empty"))
    {
        qDebug() << "All tokens are up to date";
        return;
    }
    //QSqlDatabase::database().transaction();
    qDebug() << "Tokens in progress...";
    for (auto token : tokensToUpdateColnod)
    {
        db->saveToken(token, "colnod_token");
    }
    //QSqlDatabase::database().commit();
    qDebug() << tokensToUpdateColnod.size() << " tokens has been updated";
}

void DataManager::deleteSubjectsFromDB()
{
    if (subjectsToDeleteColnod[0] == "empty")
    {
        qDebug() << "No subjects to be deleted";
        return;
    }
    qDebug() << "Deleted subjects in progress...";
    for (auto subjectId : subjectsToDeleteColnod)
    {
        db->setDeleted(subjectId, "colnod_subject");
    }
    qDebug() << subjectsToDeleteColnod.size() << "subject has beed deleted";
}

void DataManager::deleteTokensFromDB()
{
    if (tokensToDeleteColnod[0] == "empty")
    {
        qDebug() << "No tokens to be deleted";
        return;
    }
    qDebug() << "Deleted tokens in progress...";
    for (auto tokenId : tokensToDeleteColnod)
    {
        db->setDeleted(tokenId, "colnod_token");
    }
    qDebug() << tokensToDeleteColnod.size() << "tokens has beed deleted";
}

bool DataManager::haveData()
{
  if ( !subjectsColnod.isEmpty() && !tokensToUpdateColnod.isEmpty() )
    return true;
  return false;
}

bool DataManager::haveChangedData()
{
    if ( !subjectsColnod.isEmpty() &&
         !tokensToUpdateColnod.isEmpty() &&
         !subjectsToDeleteColnod.isEmpty() &&
         !tokensToDeleteColnod.isEmpty() &&
         !fullTokensColnod.isEmpty() )
        return true;
    return false;
}

bool DataManager::haveProcessData()
{
    if ( !tokensToUpdateColnod.isEmpty() && !tokensToDeleteColnod.isEmpty())
        return true;
    return false;
}

void DataManager::emptyDatabase()
{
    db->dropTables();
    db->createTables();
}

void DataManager::clear()
{
    subjectsColnod.clear();
    subjectsToDeleteColnod.clear();
    tokensToUpdateColnod.clear();
    tokensToDeleteColnod.clear();
    subjectsDB.clear();
    subjectsToDeleteDB.clear();
    tokensToUpdateDB.clear();
    tokensToDeleteDB.clear();
    fullTokensColnod.clear();
}

void DataManager::updateLastSync()
{
    db->updateLastSync(nextLastSync);
}

void DataManager::filterTokensDB()
{
    for (auto token : tokensToUpdateDB)
    {
        QString id = token->idToStringWithoutBraces();
        Q_ASSERT(token = fullTokensColnod.value(id));
        if (fullTokensColnod.contains(id) && token < fullTokensColnod.value(id))
            tokensToUpdateDB.remove(id);
    }
}

void DataManager::filterTokensColnod()
{
    for (auto token : tokensToUpdateColnod)
    {
        QString id = token->idToStringWithoutBraces();
        auto record = db->getToken(id);
        if (!record)
            continue;
        auto tokenDB = new Token;
        tokenDB->fromSQLRecord(record);
        Q_ASSERT(tokenDB != token);
        if (tokenDB > token)
            tokensToUpdateColnod.remove(id);
    }
}

// old version
void DataManager::loadTokensToAdd()
{
    QSqlQuery* query = db->getTokensToAdd();
    while (query->next())
    {
        Token* token = new Token(query->value(0).toString(), query->value(1).toString());
        token->setSubjectId(db->getId(token->getName()));
        tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token);
    }
    if (tokensToUpdateDB.isEmpty())
        tokensToUpdateDB.insert("empty", nullptr);
}

void DataManager::loadTokensToDelete()
{
    QSqlQuery* query = db->getTokensToDelete();
    while (query->next())
    {
        tokensToDeleteDB.append(query->value(0).toString());
    }
    if (tokensToDeleteDB.isEmpty())
        tokensToDeleteDB.append("empty");
}


void DataManager::setLastUpdate()
{
    for (auto token : tokensToUpdateColnod){
        db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
    }
}