adding method to use old algorithm using cloning

src/colnod/syncmanager.cpp

@@ -136,6 +136,105 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
     return nullptr;
 }
 
+std::unique_ptr<PreparedData> SyncManager::prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)
+{
+    Q_UNUSED(databaseData);
+    Q_UNUSED(colnodData);
+
+    qInfo(syncmanager) << equals;
+    qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
+    qInfo(syncmanager) << dash;
+    qInfo(syncmanager) << "Resolve conflicts ( changes on same item on both Colnod and DB ):";
+    qInfo(syncmanager) << dash;
+
+
+    Q_ASSERT(colnodData);
+    Q_ASSERT(databaseData);
+
+
+    // TODO: why copy data?
+    std::shared_ptr<Data> cloneColnodDataToProcess = std::make_shared<Data>(*colnodData);
+    std::shared_ptr<Data> cloneDatabaseDataToProcess = std::make_shared<Data>(*databaseData);
+
+    QList<QString> conflicts;
+    QList<QString> alreadySynced;
+
+    // check modifed tokens from colnod, dont want update token, if it was edited in db after or has been already synced
+    for (const auto &colnodToken : cloneColnodDataToProcess->updatedTokens) {
+        if (cloneDatabaseDataToProcess->updatedTokens.contains(colnodToken->id())) {
+            // updated in db later
+            if (cloneDatabaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken) {
+                conflicts.append(colnodToken->id());
+            }
+            continue;
+        }
+        auto token = database->getToken(colnodToken->id());
+        if ( token )
+            // alredy synced ( tokens are same )
+            if (token == colnodToken)
+                alreadySynced.append(colnodToken->id());
+    }
+    // remove tokens which should be not updated
+    for (const auto &id : conflicts)
+        cloneColnodDataToProcess->updatedTokens.remove(id);
+    for (const auto &id : alreadySynced)
+        cloneColnodDataToProcess->updatedTokens.remove(id);
+
+    qInfo(syncmanager) << tab << "-> COLNOD DATA - CHANGES:";
+    qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN DATABASE TOO";
+    qInfo(syncmanager) << tab << tab << alreadySynced.size() << "TOKENS WERE ALREADY SYNCED";
+
+
+
+    conflicts.clear();
+
+    // chech for already deleted ( in previous synced tokens were deleted from colnod, so it come to this sync but we dont want to sync it again
+    for (const auto &id : cloneColnodDataToProcess->deletedTokens) {
+        if (database->isAlreadyDeleted(id)) {
+            conflicts.append(id);
+        }
+    }
+    for (const auto &id : conflicts) {
+        cloneColnodDataToProcess->deletedTokens.removeOne(id);
+    }
+
+    qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ALREADY DELETED";
+    qInfo(syncmanager) << dash;
+
+    conflicts.clear();
+
+    // chech modified from db, remove token if it was edited in colnod later
+    for (const auto &databaseToken : cloneDatabaseDataToProcess->updatedTokens) {
+        if (cloneColnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
+            if (databaseToken < cloneColnodDataToProcess->updatedTokens.value(databaseToken->id()))
+                conflicts.append(databaseToken->id());
+        }
+        else {
+            // restriction cauesed by colnod rest api
+            if (databaseToken->description() != "mobile") {
+                qCritical(syncmanager) << "Token:" << databaseToken->id() << "doesn't have 'mobile' in description, can't be ";
+                conflicts.append(databaseToken->id());
+            }
+        }
+    }
+    for (const auto &id : conflicts)
+        cloneColnodDataToProcess->updatedTokens.remove(id);
+
+    qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
+    qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN IN COLNOD TOO";
+    qInfo(syncmanager) << dash;
+
+    qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
+    qInfo(syncmanager) << equals;
+
+    // Prepare data
+    auto preparedData = std::make_unique<PreparedData>();
+    preparedData->colnodData = cloneColnodDataToProcess;
+    preparedData->databaseData = databaseDataToProcess;
+
+    return preparedData;
+}
+
 bool SyncManager::downloadData()
 {
     bool res = true;

src/colnod/syncmanager.h

@@ -26,6 +26,7 @@ private:
      * @todo rename when removed old aproach
      */
     std::unique_ptr<PreparedData> prepareDataNew(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
+    std::unique_ptr<PreparedData> prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
 
 private:
     bool downloadData();

test/auto/syncmanager/tst_syncmanager.cpp

@@ -18,12 +18,13 @@ void SyncManagerTest::sync_init_test()
     QVERIFY(sync.databaseInitialization());
 }
 
+
 void SyncManagerTest::prepareData_test()
 {
     SyncManager sync(true);
     auto dbData = std::make_shared<Data>();
     auto colnodData = std::make_shared<Data>();
-    QVERIFY2(sync.prepareDataNew(dbData, colnodData), "finish unitest");
+    QVERIFY2(sync.prepareDataUsindOld(dbData, colnodData), "finish unitest");
 }
 
 QTEST_MAIN(SyncManagerTest)