forked from ondra/colnod-connector
309 lines
10 KiB
C++
309 lines
10 KiB
C++
#include "datamanager.h"
|
|
|
|
DataManager::DataManager(const bool &dryMode)
|
|
{
|
|
db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12", dryMode);
|
|
//db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12");
|
|
Logger::setDBMan(db);
|
|
nextLastSync = db->getNow();
|
|
lastSync = db->getLastSync();
|
|
this->dryMode = dryMode;
|
|
}
|
|
|
|
// load all tokens from colnod to comparing with working set from DB
|
|
void DataManager::fillFullTokensColnod(const QString& response)
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
|
|
QJsonArray items = doc.object()["items"].toArray();
|
|
if (!items.empty())
|
|
{
|
|
for (QJsonValueRef item : items){
|
|
auto token = new Token();
|
|
token->fromJSON(item.toObject());
|
|
allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
|
|
}
|
|
}
|
|
else{
|
|
qCritical() << "Colnod is Empty";
|
|
auto token = new Token("empty");
|
|
allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
|
|
}
|
|
}
|
|
|
|
// load working set with updated tokens from Colnod
|
|
void DataManager::fillTokensToUpdateColnod(const QString& response)
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
|
|
QJsonArray items = doc.object()["items"].toArray();
|
|
if (!items.empty())
|
|
{
|
|
for (QJsonValueRef item : items)
|
|
{
|
|
auto token = new Token();
|
|
token->fromJSON(item.toObject());
|
|
token->setDeleted(false);
|
|
tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
|
|
}
|
|
qInfo() << "Colnod:" << tokensToUpdateFromColnodToDB.size() << "tokens to update";
|
|
}
|
|
else
|
|
{
|
|
qInfo() << "Colnod: 0 tokens to update";
|
|
auto token = new Token("empty");
|
|
tokensToUpdateFromColnodToDB.insert(token->getName(), token);
|
|
}
|
|
}
|
|
|
|
// load working set with updated subjects from Colnod
|
|
void DataManager::fillSubjectsToUpdateColnod(const QString& response)
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
|
|
QJsonArray items = doc.object()["items"].toArray();
|
|
if (!items.empty())
|
|
{
|
|
for (QJsonValueRef item : items)
|
|
{
|
|
auto subject = new Subject();
|
|
subject->fromJSON(item.toObject());
|
|
subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
|
|
}
|
|
qInfo() << "Colnod:" << subjectsToUpdateFromColnodToDB.size() << "subjects to update";
|
|
}
|
|
else
|
|
{
|
|
qInfo() << "Colnod:" << "0 subjects to update";
|
|
Subject* subject = new Subject("empty");
|
|
subjectsToUpdateFromColnodToDB.insert(subject->getName(), subject);
|
|
}
|
|
}
|
|
|
|
// load working sets with updated/deleted tokens from DB
|
|
void DataManager::fillTokensToChangeDB()
|
|
{
|
|
QSqlQuery* query = db->getUpdatedTokens();
|
|
while (query->next())
|
|
{
|
|
auto token = new Token;
|
|
token->fromSQLRecord(query);
|
|
if (token->getDeleted()){ // sort to delete / to update
|
|
tokensFromDBToDeleteFromColnod.append(token->idToStringWithoutBraces());
|
|
}
|
|
else{
|
|
tokensToUpdateFromDBToColnod.insert(token->idToStringWithoutBraces(), token);
|
|
}
|
|
}
|
|
qDebug() << "DB:" << tokensToUpdateFromDBToColnod.size() << "tokens to update";
|
|
qDebug() << "DB:" << tokensFromDBToDeleteFromColnod.size() << "tokens to delete";
|
|
}
|
|
|
|
void DataManager::fillSubjectsToUpdateDB()
|
|
{
|
|
// Not needed yet
|
|
}
|
|
|
|
// load working set with subjest to delete from Colnod
|
|
void DataManager::fillSubjectsToDeleteColnod(const QString& json)
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
|
|
QJsonArray items = doc.object()["items"].toArray();
|
|
if (!items.empty())
|
|
{
|
|
for (QJsonValueRef item : items) {
|
|
subjectsFromColnodToDeleteFromDB.append(item.toString());
|
|
}
|
|
qInfo() << "Colnod:" << subjectsFromColnodToDeleteFromDB.size() << "subjects to delete";
|
|
}
|
|
else {
|
|
qInfo() << "Colnod: 0 subjects to delete";
|
|
subjectsFromColnodToDeleteFromDB.append("empty");
|
|
}
|
|
}
|
|
|
|
// load working set with tokens to delete from DB
|
|
void DataManager::fillTokensToDeleteColnod(const QString& json)
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
|
|
QJsonArray items = doc.object()["items"].toArray();
|
|
if (!items.empty())
|
|
{
|
|
for (QJsonValueRef item : items) {
|
|
tokensFromColnodToDeleteFromDB.append(item.toString());
|
|
}
|
|
qInfo() << "Colnod:" << tokensFromColnodToDeleteFromDB.size() << "tokens to delete";
|
|
}
|
|
else {
|
|
qInfo() << "Colnod: 0 tokens to delete";
|
|
tokensFromColnodToDeleteFromDB.append("empty");
|
|
}
|
|
}
|
|
|
|
void DataManager::fillSubjectsToDeleteDB()
|
|
{
|
|
// Not needed yet
|
|
}
|
|
|
|
// update subjects from colnod to DB
|
|
void DataManager::pushSubjectsToDB()
|
|
{
|
|
if (subjectsToUpdateFromColnodToDB.contains("empty")) {
|
|
qInfo() << "DB: 0 subjects added";
|
|
qInfo() << "DB: 0 subjects updated";
|
|
return;
|
|
}
|
|
int updated = 0;
|
|
int added = 0;
|
|
for (const auto& subject : subjectsToUpdateFromColnodToDB)
|
|
{
|
|
if (db->saveSubject(subject, "colnod_subject") > 0){
|
|
added++;
|
|
Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"added", "DB"));
|
|
}
|
|
else{
|
|
updated++;
|
|
Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"updated", "DB"));
|
|
}
|
|
db->saveSubjectAttributes(subject, "colnod_subject_attribute");
|
|
}
|
|
qInfo() << "DB:" << added << "subjects added";
|
|
qInfo() << "DB:" << updated << "subjects updated";
|
|
}
|
|
|
|
// update tokens from colnod to DB
|
|
void DataManager::pushTokensToDB()
|
|
{
|
|
if (tokensToUpdateFromColnodToDB.contains("empty")){
|
|
qInfo() << "DB: 0 tokens added";
|
|
qInfo() << "DB: 0 tokens updated";
|
|
return;
|
|
}
|
|
filterTokensColnod();
|
|
int updated = 0;
|
|
int added = 0;
|
|
for (const auto& token : tokensToUpdateFromColnodToDB)
|
|
{
|
|
if (db->saveToken(token, "colnod_token") > 0){
|
|
added++;
|
|
Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "added", "DB"));
|
|
}
|
|
else{
|
|
updated++;
|
|
Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "updated", "DB"));
|
|
}
|
|
}
|
|
qInfo() << "DB:" << added << " tokens added";
|
|
qInfo() << "DB:" << updated << " tokens updated";
|
|
|
|
}
|
|
|
|
void DataManager::deleteSubjectsFromDB()
|
|
{
|
|
if (subjectsFromColnodToDeleteFromDB[0] == "empty")
|
|
{
|
|
qInfo() << "DB: 0 subjects deleted";
|
|
return;
|
|
}
|
|
for (const auto& subjectId : subjectsFromColnodToDeleteFromDB)
|
|
{
|
|
db->setDeleted(subjectId, "colnod_subject");
|
|
Logger::logToDb(Logger::makeSubjectMsg(subjectId, "deleted", "DB"));
|
|
}
|
|
qInfo() << "DB:" << subjectsFromColnodToDeleteFromDB.size() << " subject deleted";
|
|
}
|
|
|
|
// "delete" (set deleted true) tokens in DB depends on Colnod
|
|
void DataManager::setDeletedToTokensFromDB()
|
|
{
|
|
if (tokensFromColnodToDeleteFromDB[0] == "empty")
|
|
{
|
|
qDebug() << "DB: 0 tokens deleted";
|
|
return;
|
|
}
|
|
int alreadyDeleted = 0;
|
|
for (const auto& tokenId : tokensFromColnodToDeleteFromDB)
|
|
{
|
|
if (!db->checkDeletedToken(tokenId)){
|
|
db->setDeleted(tokenId, "colnod_token");
|
|
Logger::logToDb(Logger::makeTokenMsg(tokenId, "deleted", "DB"));
|
|
}
|
|
else
|
|
alreadyDeleted++;
|
|
}
|
|
qDebug() << "DB:" << tokensFromColnodToDeleteFromDB.size() - alreadyDeleted << "tokens deleted";
|
|
}
|
|
|
|
// do I have loaded all data
|
|
bool DataManager::haveChangedData()
|
|
{
|
|
return !subjectsToUpdateFromColnodToDB.isEmpty() &&
|
|
!tokensToUpdateFromColnodToDB.isEmpty() &&
|
|
!subjectsFromColnodToDeleteFromDB.isEmpty() &&
|
|
!tokensFromColnodToDeleteFromDB.isEmpty() &&
|
|
!allTokensFromColnod.isEmpty();
|
|
}
|
|
|
|
// recreate working tables
|
|
void DataManager::emptyDatabase()
|
|
{
|
|
db->dropTables();
|
|
db->createTables();
|
|
}
|
|
|
|
//clear all structures
|
|
void DataManager::clear()
|
|
{
|
|
subjectsToUpdateFromColnodToDB.clear();
|
|
subjectsFromColnodToDeleteFromDB.clear();
|
|
tokensToUpdateFromColnodToDB.clear();
|
|
tokensFromColnodToDeleteFromDB.clear();
|
|
//subjectsDB.clear(); // not need yet
|
|
// subjectsToDeleteDB.clear(); // not need yet
|
|
tokensToUpdateFromDBToColnod.clear();
|
|
tokensFromDBToDeleteFromColnod.clear();
|
|
allTokensFromColnod.clear();
|
|
}
|
|
|
|
// on the very end of sync update last sync time to begin time of this sync
|
|
void DataManager::updateLastSync()
|
|
{
|
|
db->updateLastSync(nextLastSync);
|
|
}
|
|
|
|
// these to filter functions solve colision tokens -> remove when change on this token is earlier then change on the same token on the other side (Colnod/DB)
|
|
void DataManager::filterTokensDB()
|
|
{
|
|
for (const auto& token : tokensToUpdateFromDBToColnod)
|
|
{
|
|
QString id = token->idToStringWithoutBraces();
|
|
Q_ASSERT(token != allTokensFromColnod.value(id)); // if working sets are loading correctly equels should never happend
|
|
if (allTokensFromColnod.contains(id) && *token < *allTokensFromColnod.value(id))
|
|
tokensToUpdateFromDBToColnod.remove(id);
|
|
}
|
|
}
|
|
|
|
void DataManager::filterTokensColnod()
|
|
{
|
|
for (const auto &token : tokensToUpdateFromColnodToDB)
|
|
{
|
|
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)
|
|
tokensToUpdateFromColnodToDB.remove(id);
|
|
}
|
|
}
|
|
|
|
// sync last update from colnod to DB
|
|
void DataManager::setLastUpdate()
|
|
{
|
|
for (const auto &token : tokensToUpdateFromColnodToDB){
|
|
db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
|
|
}
|
|
}
|
|
|
|
|
|
|