fix problems

src/colnod/colnodapi.cpp

@@ -243,7 +243,7 @@ qint64 ColnodAPI::lastSync() const
 
 void ColnodAPI::setlastSync(const qint64 &lastSync)
 {
-    mLastSync.set_timestamp(lastSync);
+    mLastSync.setTimestamp(lastSync);
 }
 
 

src/colnod/colnodapi.h

@@ -10,31 +10,24 @@ Q_DECLARE_LOGGING_CATEGORY(colnod)
 
 class LoginResp : public serversdk::DatabaseTable {
     Q_OBJECT
-    TABLE_PROPERTY(QString, username, set_username, "")
-    TABLE_PROPERTY(QString, password, set_password, "")
+    TABLE_PROPERTY(QString, username, setUsername, "")
+    TABLE_PROPERTY(QString, password, setPassword, "")
 };
 
 class AuthToken : public serversdk::DatabaseTable {
     Q_OBJECT
-    TABLE_PROPERTY(QString, id, set_id, QString())
+    TABLE_PROPERTY(QString, id, setId, QString())
 };
 
 class Timestamp : public serversdk::DatabaseTable {
     Q_OBJECT
-    TABLE_PROPERTY(qint64, timestamp, set_timestamp, 0)
+    TABLE_PROPERTY(qint64, timestamp, setTimestamp, 0)
 public:
     Timestamp() = default;
-    explicit Timestamp(const Timestamp &time)
+
+    void setTimestamp(QDateTime time)
     {
-        this->set_timestamp(time.timestamp());
-    }
-    explicit Timestamp(qint64 time)
-    {
-        set_timestamp(time);
-    }
-    explicit Timestamp(QDateTime time)
-    {
-        set_timestamp(time.toMSecsSinceEpoch());
+        setTimestamp(time.toMSecsSinceEpoch());
     }
 
     QString toDateString()

src/colnod/syncmanager.cpp

@@ -31,7 +31,7 @@ bool SyncManager::databaseInitialization()
     }
 
     // here -> nothing can fail
-    mlastSync.set_timestamp(database->getLastSync());
+    mlastSync.setTimestamp(database->getLastSync());
     colnod = std::make_shared<ColnodAPI>(&reqMan, mDryMode);
     return true;
 }
@@ -213,6 +213,105 @@ void SyncManager::initNewToken(std::shared_ptr<Token> token)
     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)
+{
+    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 = cloneDatabaseDataToProcess;
+
+    return preparedData;
+}
+
 bool SyncManager::downloadData()
 {
     bool res = true;
@@ -338,7 +437,7 @@ bool SyncManager::processData()
 void SyncManager::updateLastUpdate(qint64 syncBegin)
 {
     Timestamp time;
-    time.set_timestamp(syncBegin);
+    time.setTimestamp(syncBegin);
     colnod->getTokensUpdated(time);
     database->setLastUpdate(databaseDataToProcess->deletedTokens);
     connect(colnod.get(), &ColnodAPI::partOfDataReady, [=](const std::shared_ptr<Data> &data){

test/auto/colnod/tst_colnodapi.cpp

@@ -79,7 +79,7 @@ void ColnodTest::download_data_test()
         auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
         QVERIFY(data);
 
-        QVERIFY(data->updatedTokens.size() == 0);
+        QVERIFY(data->updatedTokens.isEmpty());
     }
 }
 

test/auto/syncmanager/tst_syncmanager.cpp

@@ -23,7 +23,12 @@ 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");
+
+    auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
+    auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
+
+    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
+    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
 }
 
 QTEST_MAIN(SyncManagerTest)