Merge branch 'suggest/next-steps-prepare-data' into suggest/preapre-data-use-old

src/colnod/data.h

@@ -39,6 +39,14 @@ public:
 
 struct PreparedData
 {
+public:
+    PreparedData() = default;
+    PreparedData(const std::shared_ptr<Data> &database, const std::shared_ptr<Data> &colnod)
+        :databaseData(database), colnodData(colnod)
+    {
+    }
+
+
     // TODO: make unique_ptr ( neeed because of ColnodAPI )
     std::shared_ptr<Data> databaseData;
     std::shared_ptr<Data> colnodData;

src/colnod/databaseapi.h

@@ -48,13 +48,14 @@ public:
 
     bool isValid();
 
+    qint16 getNumOfTokensOfSubject(const QString &id);
+    QString getSubjectNameByTokenId(const QString &tokenId);
+
 private:
     int exists(const QString &id, const QString &tableName);
 
     QSqlQuery getUpdatedTokens();
     std::shared_ptr<Data> composeData(const QSqlQuery &updatedQuery, QSqlQuery &deletedQuery);
-    qint16 getNumOfTokensOfSubject(const QString &id);
-    QString getSubjectNameByTokenId(const QString &tokenId);
 
 signals:
     void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());

src/colnod/syncmanager.cpp

@@ -49,7 +49,7 @@ bool SyncManager::startSynchronization()
     qInfo(syncmanager) << equals;
     qInfo(syncmanager) << "SYNCHRONIZATION BEGIN";
 
-    // TODO: check error
+    // TODO: solve this in prepare data
     database->initNewTokens();
 
 
@@ -63,8 +63,8 @@ bool SyncManager::startSynchronization()
 
 
     colnod->downloadData(Timestamp(syncBegin));
-    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> data) {
+    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> colnodData) {
-        if (!data) {
+        if (!colnodData) {
             qCritical(syncmanager) << "Not possible to get correct data from colnod";
             QCoreApplication::exit(-1);
             return;
@@ -73,7 +73,7 @@ bool SyncManager::startSynchronization()
         // NOW I SHOULD HAVE VALID DATA FROM COLNOD
         // I can process data
         qDebug(syncmanager) << "I have colnod and database data";
-        qDebug(syncmanager) << "updated token count" << data->updatedTokens.count();
+        qDebug(syncmanager) << "updated token count" << colnodData->updatedTokens.count();
 
         std::unique_ptr<PreparedData> preparedData = prepareDataNew(databaseData, colnodData);
         if (!preparedData) {
@@ -88,11 +88,6 @@ bool SyncManager::startSynchronization()
     return true;
     //downloadData();
 
-    auto colnodDataFinished = [=](std::shared_ptr<Data> data) {
-        Q_UNUSED(data)
-        qDebug() << "Now I can check that I have all data I need";
-    };
-
     //connect(this, &SyncManager::dataReady, processDownloadedData);
 
 
@@ -104,7 +99,7 @@ bool SyncManager::startSynchronization()
             qInfo(syncmanager) << "PROCESSING DATA -> FINISHED";
             qInfo(syncmanager) << equals;
 
-            updateLastUpdate(syncBegin);
+            updateLastUpdate(syncBegin); // TODO: change to update all attrinutes
             connect(this, &SyncManager::syncFinished, [=](){
                 if (database->isValid() && colnod->isValid()) {
                     database->setLastSync(syncBegin);
@@ -131,9 +126,90 @@ bool SyncManager::startSynchronization()
 
 std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)
 {
-    Q_UNUSED(databaseData);
+    auto preparedColnodData = std::make_shared<Data>();
-    Q_UNUSED(colnodData);
+    auto preparedDatabaseData = std::make_shared<Data>();
-    return nullptr;
+
+    QList<QString> conflicts;
+    QList<QString> alreadySynced;
+
+    for (const auto &colnodToken : colnodData->updatedTokens) {
+
+        // not conflict so add to prepered tokens
+        if (!databaseData->updatedTokens.contains(colnodToken->id())) {
+            preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
+            continue;
+        }
+
+        // change in colnod is newer
+        if (databaseData->updatedTokens.value(colnodToken->id()) < colnodToken) {
+            preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
+        }
+        else {
+            conflicts.append(colnodToken->id());
+        }
+
+        auto token = database->getToken(colnodToken->id());
+        if ( token )
+            // alredy synced ( tokens are same )
+            if (token == colnodToken)
+                alreadySynced.append(colnodToken->id());
+    }
+
+    for (const auto &id : colnodData->deletedTokens) {
+        if (!database->isAlreadyDeleted(id)) {
+            preparedColnodData->deletedTokens.append(id);
+        }
+    }
+
+    qInfo(syncmanager) << tab << "-> COLNOD DATA - CHANGES:";
+    qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN DATABASE AFTER";
+    qInfo(syncmanager) << tab << tab << alreadySynced.size() << "TOKENS WERE ALREADY SYNCED";
+    qInfo(syncmanager) << tab << tab << colnodData->deletedTokens.size() - preparedColnodData->deletedTokens.size() << "TOKENS WERE ALREADY DELETED";
+    qInfo(syncmanager) << dash;
+
+    for (const auto &databaseToken : databaseData->updatedTokens) {
+        if (databaseToken->name().isEmpty()) {
+            initNewToken(databaseToken);
+        }
+
+        // restriction cauesed by colnod rest api
+        if (databaseToken->description() != "mobile") {
+            qCritical(syncmanager) << "Token:" << databaseToken->id() << "doesn't have 'mobile' in description, can't be ";
+            continue;
+        }
+
+        // no conflict
+        if (!colnodData->updatedTokens.contains(databaseToken->id())) {
+            preparedDatabaseData->updatedTokens.insert(databaseToken->id(), databaseToken);
+            continue;
+        }
+
+        // database change is newer
+        if (databaseToken > colnodData->updatedTokens.value(databaseToken->id())) {
+            preparedDatabaseData->updatedTokens.insert(databaseToken->id(), databaseToken);
+        } 
+    }
+
+    qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
+    qInfo(syncmanager) << tab << tab << databaseData->updatedTokens.size() - preparedColnodData->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED IN COLNOD AFTER";
+    qInfo(syncmanager) << dash;
+
+    qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
+    qInfo(syncmanager) << equals;
+
+
+    auto preparedData = std::make_unique<PreparedData>(preparedDatabaseData, preparedColnodData);
+    return preparedData;
+}
+
+void SyncManager::initNewToken(std::shared_ptr<Token> token)
+{
+    qint16 num = database->getNumOfTokensOfSubject(token->subjectId());
+    token->setName(database->getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
+    token->setDescription("mobile");
+    token->setTokenData(token->tokenData().toUpper());
+
+    qInfo(syncmanager).noquote() << Message::massageTemplate("Inicializing new", "token", "sync manager", token->name());
 }
 
 std::unique_ptr<PreparedData> SyncManager::prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)

src/colnod/syncmanager.h

@@ -29,6 +29,8 @@ private:
     std::unique_ptr<PreparedData> prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
 
 private:
+    void initNewToken(std::shared_ptr<Token> token);
+
     bool downloadData();
     bool prepareData();
     bool processData();