colnod-connector/src/colnod/colnodapi.cpp

#include "colnodapi.h"

ColnodAPI::ColnodAPI(bool debug)
{
    reqMan = new RequestManager();
    dataMan = new DataManager();
    debugMode = debug;
}


// PUBLIC FUNCTIONS
//void ColnodAPI::downloadData()
//{
//    Response* resp0 = reqMan->getSubjects();
//    connect(resp0, &Response::ready, [=](){
//        dataMan->localSaveSubjects(resp0->getJson());
//        areDataReady();
//        resp0->deleteLater();
//    });

//    Response* resp1 = reqMan->getTokens();
//    connect(resp1, &Response::ready, [=](){
//        dataMan->localSaveTokens(resp1->getJson());
//        areDataReady();
//        resp1->deleteLater();
//    });

//    /*
//    QNetworkReply* reply2 = reqMan->getTokens();
//    connect(reply2, &QNetworkReply::finished, [=](){
//        data->saveTokens(reply2->readAll());
//    });
//    */
//}


void ColnodAPI::loadDataFromColnod()
{
    loadTokensFromColnod();
    loadUpdatedDataFromColnod();
    loadDeletedDataFromColnod();
}

void ColnodAPI::loadTokensFromColnod()
{
    Response* resp = reqMan->getTokens();
    connect(resp, &Response::ready, [=](){
        dataMan->fillFullTokensColnod(resp->getJson());
        areChangedDataReady();
        resp->deleteLater();
    });
}

void ColnodAPI::loadUpdatedDataFromColnod()
{
    uint64_t lastUpdate = dataMan->getLastSync();
    Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate);
    connect(resp0, &Response::ready, [=](){
        dataMan->fillSubjectsColnod(resp0->getJson());
        areChangedDataReady();
        resp0->deleteLater();
    });

    Response* resp1 = reqMan->getTokensUpdated(lastUpdate);
    connect(resp1, &Response::ready, [=](){
        dataMan->fillTokensColnod(resp1->getJson());
        areChangedDataReady();
        resp1->deleteLater();
    });
}

void ColnodAPI::loadDeletedDataFromColnod()
{
    uint64_t lastUpdate = dataMan->getLastSync();
    Response* resp2 = reqMan->getSubjectsDeleted(lastUpdate);
    connect(resp2, &Response::ready, [=](){
        dataMan->fillSubjectsToDeleteColnod(resp2->getJson());
        areChangedDataReady();
        resp2->deleteLater();
    });

    Response* resp3 = reqMan->getTokensDeleted(lastUpdate);
    connect(resp3, &Response::ready, [=](){
        dataMan->fillTokensToDeleteColnod(resp3->getJson());
        areChangedDataReady();
        resp3->deleteLater();
    });

}

void ColnodAPI::loadDataFromDB()
{
    dataMan->fillTokensDB();

}

//void ColnodAPI::syncDataFromColnod()
//{
//    dataMan->pushTokensToDB();
//    dataMan->pushSubjectsToDB();
//    dataMan->updateLastSync();
//    dataMan->clear();
//}

void ColnodAPI::syncDataFromColnod()
{
    dataMan->filterTokensColnod();
    syncUpdatedDataFromColnod();
    if (dataMan->getLastSync() != 0)
        syncDeletedDataFromColnod();
    //dataMan->updateLastSync();
   // dataMan->clear();
}

void ColnodAPI::syncUpdatedDataFromColnod()
{
    dataMan->pushSubjectsToDB();
    dataMan->pushTokensToDB();
}


void ColnodAPI::syncDeletedDataFromColnod()
{
    dataMan->deleteSubjectsFromDB();
    dataMan->deleteTokensFromDB();
}

void ColnodAPI::syncDataFromDB()
{
    // TODO
    dataMan->filterTokensDB();
    processDataToColnod();
    connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::clear);
    connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::setLastSync);
    connect(this, &ColnodAPI::dataProcessed, [=](){
        auto resp = reqMan->getTokensUpdated(dataMan->getActualSync());
        connect(resp, &Response::ready, [=](){
            dataMan->fillTokensColnod(resp->getJson());
            dataMan->setLastUpdate();
            dataMan->clear();
            emit syncFinished();
            resp->deleteLater();
        });
    });
}

void ColnodAPI::processDataToColnod()
{
    auto tokensToUpdate = dataMan->getTokensToUpdateDB();

    if (tokensToUpdate.contains("empty")){
        qDebug() << "No tokens to be modified.";
        return;
    }
    auto tokensToDelete = dataMan->getTokensToDeleteDB();
    auto resp0 = reqMan->setTokens(tokensToUpdate);
    auto resp1 = reqMan->deleteTokens(tokensToDelete);
    connect(resp0, &Response::ready, [=](){
        updateFinished = true;
        areDataProcessed();
        resp0->deleteLater();
    });
    connect(resp1, &Response::ready, [=](){
        deleteFinished = true;
        areDataProcessed();
        resp1->deleteLater();
    });
}

// old version
//void ColnodAPI::processDataToColnod()
//{
//    QList<QString>* tokensToDelete = dataMan->getTokensToDelete();
//    if ((*tokensToDelete)[0] != "empty")
//    {
//     Response* resp0 = reqMan->deleteTokens(tokensToDelete);
//        connect(resp0, &Response::ready, [=](){
//            isProcessDone();
//            resp0->deleteLater();
//        });
//    }
//    QHash<QString, QPointer<Token>>* tokens = dataMan->getTokens();
//    if (!tokens[0].contains("empty"))
//    {
//        Response* resp1 = reqMan->setTokens(tokens);
//        connect(resp1, &Response::ready, [=](){
//            isProcessDone();
//            resp1->deleteLater();
//        });
//    }
//    dataMan->clear();
//    connect(this, &ColnodAPI::dataProcessed, this, &ColnodAPI::loadDataFromColnod);
//}

// For full sync
void ColnodAPI::prepareDatabase()
{
    dataMan->emptyDatabase();
}

// PRIVATE FUNCTIONS
void ColnodAPI::areDataReady()
{
    if (dataMan->haveData())
        emit dataDownloaded();
}

void ColnodAPI::areChangedDataReady()
{
    if (dataMan->haveChangedData())
        emit dataDownloaded();
}


void ColnodAPI::areDataProcessed()
{
    if (deleteFinished && updateFinished)
    {
        emit dataProcessed();
    }
}