Merge branch 'feat/unitest-syncmanager' into 'master'

Feat/unitest syncmanager

See merge request spaceti-app/integrations/acs/colnod-connector!33

README.md

@@ -169,6 +169,115 @@ It is possible to chain requests: [see doc](https://support.insomnia.rest/articl
 
 `npm install -g snowboard`
 
+## Tests made
+Changes on colnod are made by [Colnod client](https://spaceti.atlassian.net/wiki/spaces/IN/pages/194576388/Colnod+client)
+
+Changes on db can be made by sql commands directly or by [pgAdmin](https://www.pgadmin.org/)
+- add token to db/colnod (2 tests)
+- edit token in db/colnod (2 tests)
+- delete token from db/colnod (2 tests)
+- add subject to colnod
+- edit subject in colnod
+- delete subject from colnod
+- edit same token on both db/colnod (diffrent time)
+
+## First sync expected results
+- 2892 tokens updated
+- 173 tokens deleted
+- 2894 subjects updated
+- 117 subjects deleted
+
+## Database inicialization
+- Token table
+```SQL create
+-- Table: public.colnod_token
+-- DROP TABLE public.colnod_token;
+CREATE TABLE public.colnod_token
+(
+    id character(36) COLLATE pg_catalog."default" NOT NULL,
+    auth_errors integer DEFAULT 255,
+    description character varying(255) COLLATE pg_catalog."default",
+    enabled boolean DEFAULT true,
+    last_update timestamp without time zone DEFAULT '1970-01-01 00:00:00.001'::timestamp without time zone,
+    name character varying(255) COLLATE pg_catalog."default",
+    no_validity boolean DEFAULT true,
+    time_to_live integer DEFAULT 255,
+    token_bits integer DEFAULT 32,
+    token_data character varying(255) COLLATE pg_catalog."default",
+    token_type character varying(255) COLLATE pg_catalog."default" DEFAULT 'Token'::character varying,
+    subject_id character(36) COLLATE pg_catalog."default",
+    last_modified timestamp without time zone NOT NULL,
+    deleted boolean DEFAULT false,
+    CONSTRAINT colnod_token_pkey PRIMARY KEY (id)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+
+ALTER TABLE public.colnod_token
+    OWNER to postgres;
+```
+- Subject table
+```SQL create
+-- Table: public.colnod_subject
+-- DROP TABLE public.colnod_subject;
+CREATE TABLE public.colnod_subject
+(
+    id character(36) COLLATE pg_catalog."default" NOT NULL,
+    description character varying(255) COLLATE pg_catalog."default",
+    last_update timestamp without time zone NOT NULL,
+    name character varying(255) COLLATE pg_catalog."default",
+    pin character varying(255) COLLATE pg_catalog."default",
+    last_modified timestamp without time zone,
+    deleted boolean,
+    CONSTRAINT colnod_subject_pkey PRIMARY KEY (id)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+
+ALTER TABLE public.colnod_subject
+    OWNER to postgres;
+```
+- Subject attributes table
+```SQL create
+-- Table: public.colnod_subject_attribute
+-- DROP TABLE public.colnod_subject_attribute;
+CREATE TABLE public.colnod_subject_attribute
+(
+    id character varying(255) COLLATE pg_catalog."default" NOT NULL,
+    attribute_key character varying(255) COLLATE pg_catalog."default",
+    attribute_value character varying(255) COLLATE pg_catalog."default",
+    subject_id character(36) COLLATE pg_catalog."default",
+    CONSTRAINT colnod_subject_attribute_pkey PRIMARY KEY (id)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+
+ALTER TABLE public.colnod_subject_attribute
+    OWNER to postgres;
+```
+- Config
+```SQL create
+-- Table: public.config
+-- DROP TABLE public.config;
+CREATE TABLE public.config
+(
+    last_sync bigint NOT NULL DEFAULT 0,
+    CONSTRAINT config_pkey PRIMARY KEY (last_sync)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+
+ALTER TABLE public.config
+    OWNER to postgres;
+```
 ## Possible checks
   [here](https://gitlab.com/spaceti-app/integrations/acs/colnod-connector/blob/master/doc/possible-checks.md)
 

server-sdk

@@ -1 +1 @@
-Subproject commit a818055b75dc0de97e26be44cbbfd2e94516c09e
+Subproject commit 3640c0db5d1e24b314b00cc2b0dd61915080381b

src/app/main.cpp

@@ -45,13 +45,13 @@ int main(int argc, char *argv[])
 
     // Initialize database and colnod API
     if (!syncManager.databaseInitialization()) {
-        qCritical("Not possible to initialize sync application");
+        qCritical() << "Not possible to initialize sync application";
         return -1;
     }
 
     // Synchronizaiton
     if (!syncManager.startSynchronization()) {
-        qCritical("Not possible to start synchronization");
+        qCritical() << "Not possible to start synchronization";
         return -1;
     }
 

src/colnod/colnodapi.cpp

@@ -1,10 +1,12 @@
 #include "colnodapi.h"
 
+#include <utility>
+
 Q_LOGGING_CATEGORY(colnod, "colnod.api");
 
 
-ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, const QString &userName, const QString &password)
+ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, QString userName, QString password)
-    :mReqMan(reqMan), mUserName(userName), mPassword(password), mDryMode(dryMode)
+    :mReqMan(reqMan), mUserName(std::move(userName)), mPassword(std::move(password)), mDryMode(dryMode)
 {
     // -----------------------------------
     mReqMan->setIgnoreSsl(true);
@@ -18,89 +20,126 @@ ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, con
  * @return signal with nullptr when something went wrong
  * @return signal with data when valid data returned
  */
-void ColnodAPI::downloadData(const qint64 &time)
+bool ColnodAPI::downloadData(const qint64 &time)
 {
     // Have to get Login
     auto login = requestLogin();
+    Q_ASSERT(login);
+    if (login->networkReply() == nullptr) {
+        qCCritical(colnod) << "Not possible to create login request";
+        return false;
+    }
     connect(login.get(), &serversdk::Request::finished, this, [=](){
         // Get login token
-        if (!checkRequest(login)) {
+        if (login->status() != 200) {
             emit downloadDataFinished(nullptr);
-            return;
+            return false;
         }
         AuthToken token;
+
+        if (checkResponse(login->responseData())) {
+            qCWarning(colnod) << "empty response data when logging in";
+            emit downloadDataFinished(nullptr);
+            return false;
+        }
+
         token.fromJson(login->responseData());
         authToken = token.id();
+        if (authToken.isEmpty()) {
+            qCCritical(colnod) << "Token uuid is empty";
+            emit downloadDataFinished(nullptr);
+            return false;
+        }
 
         auto data = std::make_shared<Data>();
-
-        auto errorHandler = [=](std::shared_ptr<serversdk::Request> request){
-            if (!checkRequest(request)) {
-                qWarning(colnod) << "ERROR during calling" << request->url() << ", request unsuccessful";
-                mValid = false;
-                emit downloadDataFinished(nullptr);  // TODO: think about it, will the other if passed?
-            }
-            else if (!checkResponse(request->responseData())) {
-                qWarning(colnod) << "Data from" << request->url() << "are invalid";
-                mValid = false;
-            }
-        };
-
-
-        // if I have all data emit downloadDataFinished
-        connect(this, &ColnodAPI::partOfDataReady, this, &ColnodAPI::areDataReady);
-
         Timestamp timestamp;
         timestamp.setTimestamp(time);
 
+        auto checkData = [=]() {
+            int dataCount = data->incrementCounter();
+            if ( dataCount > 5) {
+                qCCritical(colnod) << "check data cannnot be higher then 4";
+            }
+            Q_ASSERT(dataCount < 5);
+            if (dataCount == 4) {
+                qInfo(colnod) << tab << "- src col:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
+                                 "] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
+
+                if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
+                        !data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
+                    qInfo(colnod) << dash;
+                }
+                for (auto token : data->updatedTokens) {
+                    qInfo(colnod) << Message::massageTemplate("Download updated", "token", "colnod", token->name());
+                }
+                for (auto id : data->deletedTokens) {
+                    qInfo(colnod) << Message::massageTemplate("Download deleted", "token", "colnod", id);
+                }
+                for (auto subject : data->updatedSubjects) {
+                    qInfo(colnod) << Message::massageTemplate("Download updated", "subject", "colnod", subject->name());
+                }
+                for (auto id : data->deletedSubjects) {
+                    qInfo(colnod) << Message::massageTemplate("Download deleted", "token", "colnod", id);
+                }
+                if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
+                        !data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
+                    qInfo(colnod) << dash;
+                }
+                emit downloadDataFinished(data);
+            }
+        };
+
         auto tokensRequest = getTokensUpdated(timestamp);
-        connect(tokensRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
-            saveUpdatedTokens(data, tokensRequest->responseData());
+            if (!saveUpdatedTokens(data, tokensRequest->responseData())) {
-            emit partOfDataReady(data);
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
 
         auto deletedTokensRequest = getTokensDeleted(timestamp);
-        connect(deletedTokensRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(deletedTokensRequest.get(), &serversdk::Request::finished, [=](){
-            saveDeletedTokens(data, deletedTokensRequest->responseData());
+            if (!saveDeletedTokens(data, deletedTokensRequest->responseData())) {
-            emit partOfDataReady(data);
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
 
         auto subjectsRequest = getSubjectsUpdated(timestamp);
-        connect(subjectsRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(subjectsRequest.get(), &serversdk::Request::finished, [=](){
-            saveUpdatedSubjects(data, subjectsRequest->responseData());
+            if (!saveUpdatedSubjects(data, subjectsRequest->responseData())) {
-            emit partOfDataReady(data);
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
 
         auto deletedSubjectsRequest = getSubjectsDeleted(timestamp);
-        connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, [=](){
-            saveDeletedSubjects(data, deletedSubjectsRequest->responseData());
+            if (!saveDeletedSubjects(data, deletedSubjectsRequest->responseData())) {
-            emit partOfDataReady(data);
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
+        return true;
+
     });
+    return true;
 }
 
 void ColnodAPI::processData(const std::shared_ptr<Data> &data)
 {
-    for (const auto &token : data->updatedTokens) {
+    qInfo(colnod) << tab << "- push col:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
-        qInfo(colnod).noquote() << Message::massageTemplate("Updating", "token", "colnod", token->name());
+                     "] [ added/updated : deleted ]";
-    }
+
-    for (const auto &id : data->deletedTokens) {
+    connect(this, &ColnodAPI::partOfDataProcessFinished, this, &ColnodAPI::isDataProcessFinished);
-        qInfo(colnod).noquote() << Message::massageTemplate("Deleting", "token", "colnod", id);
+
-    }
     if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
         qInfo(colnod) << dash;
     }
-    qInfo(colnod) << tab << "-> DATA PROCESSED TO COLNOD:";
-    qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS UPDATED";
-    qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
-    qInfo(colnod) << dash;
-
-
-    connect(this, &ColnodAPI::partOfDataProcessFinished, this, &ColnodAPI::isDataProcessFinished);
     if ( !data->updatedTokens.isEmpty() && !mDryMode) {
         setTokens(data->updatedTokens);
     } else {
@@ -111,6 +150,9 @@ void ColnodAPI::processData(const std::shared_ptr<Data> &data)
     } else {
         emit partOfDataProcessFinished();
     }
+    if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
+        qInfo(colnod) << dash;
+    }
 }
 
 std::shared_ptr<serversdk::Request> ColnodAPI::requestLogin()
@@ -174,15 +216,17 @@ std::shared_ptr<serversdk::Request> ColnodAPI::setTokens(const QHash<QString, st
     connect(request.get(),  &serversdk::Request::finished, [=](){
         if (!checkRequest(request)) {
             qCritical(colnod) << "ERROR during calling /TokenManager/setTokens, request unsuccessful. EXIT";
-            emit error();
         }
         if (checkResponse(request->responseData())) {
+            for (const auto &token : tokens) {
+                qInfo(colnod).noquote() << Message::massageTemplate("Updated", "token", "colnod", token->name());
+            }
             emit partOfDataProcessFinished();
         }
         else {
             qWarning(colnod) << "Tokens wasn't updated";
             mValid = false;
-            emit partOfDataProcessFinished();
+            emit partOfDataProcessFinished(false);
         }
     });
     return request;
@@ -196,15 +240,17 @@ std::shared_ptr<serversdk::Request> ColnodAPI::deleteTokens(const QList<QString>
     connect(request.get(),  &serversdk::Request::finished, [=](){
         if (!checkRequest(request)) {
             qCritical(colnod) << "ERROR during calling /TokenManager/deleteTokens, request unsuccessful. EXIT";
-            emit error();
         }
         if (checkResponse(request->responseData())) {
+            for (const auto &id : ids) {
+                qInfo(colnod).noquote() << Message::massageTemplate("Deleted", "token", "colnod", id);
+            }
             emit partOfDataProcessFinished();
         }
         else {
             qWarning(colnod) << "Tokens wasn't deleted";
             mValid = false;
-            emit partOfDataProcessFinished();
+            emit partOfDataProcessFinished(false);
         }
     });
     return request;
@@ -218,10 +264,7 @@ std::shared_ptr<serversdk::Request> ColnodAPI::composeRequest(const QString &end
 
 bool ColnodAPI::checkRequest(const std::shared_ptr<serversdk::Request> &request)
 {
-    if (request->status() == 200) {
+    return request->status() == 200;
-        return true;
-    }
-    return false;
 }
 
 bool ColnodAPI::isValid()
@@ -239,17 +282,6 @@ void ColnodAPI::setPassword(const QString &password)
     mPassword = password;
 }
 
-qint64 ColnodAPI::lastSync() const
-{
-    return mLastSync.timestamp();
-}
-
-void ColnodAPI::setlastSync(const qint64 &lastSync)
-{
-    mLastSync.setTimestamp(lastSync);
-}
-
-
 QString ColnodAPI::userName() const
 {
     return mUserName;
@@ -260,60 +292,72 @@ void ColnodAPI::setUserName(const QString &userName)
     mUserName = userName;
 }
 
-void ColnodAPI::areDataReady(std::shared_ptr<Data> data)
+void ColnodAPI::areDataReady(const std::shared_ptr<Data> &data)
 {
     if (++amountData == 4) {
 
-        qInfo(colnod) << tab << "-> COLNOD DATA:";
+        // new
-        qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
+        qInfo(colnod) << "- src colnod:  tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
-        qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
+                         "] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
-        qInfo(colnod) << tab << tab << data->updatedSubjects.size() << "SUBJECTS WERE ADDED/UPDATED";
+        //OLD
-        qInfo(colnod) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
+//        qInfo(colnod) << tab << "-> COLNOD DATA:";
-        qInfo(colnod) << dash;
+//        qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
+//        qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
+//        qInfo(colnod) << tab << tab << data->updatedSubjects.size() << "SUBJECTS WERE ADDED/UPDATED";
+//        qInfo(colnod) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
+//        qInfo(colnod) << dash;
 
         amountData = 0;
         emit downloadDataFinished(data);
     }
 }
 
-void ColnodAPI::isDataProcessFinished()
+void ColnodAPI::isDataProcessFinished(bool success)
 {
+    if (!success) {
+        mSuccess = false;
+    }
     if (++amountProccessesFinished == 2) {
-        emit dataProcessFinished();
+        emit dataProcessFinished(mSuccess);
     }
 }
 
-void ColnodAPI::saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
+bool ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
-    data->loadTokensFromJson(responseData);
+    Q_ASSERT(data);
+    return data->loadTokensFromJson(responseData);
 }
 
-void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
+bool ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
+    Q_ASSERT(data);
+    if (responseData.isEmpty())
+        return false;
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();
     for (QJsonValueRef item : items) {
         data->deletedTokens.append(item.toString());
     }
+    return true;
 }
 
-void ColnodAPI::saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
+bool ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
-    data->loadSubjectsFormJson(responseData);
+    Q_ASSERT(data);
+    return data->loadSubjectsFormJson(responseData);
 }
 
-void ColnodAPI::saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
+bool ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
+    Q_ASSERT(data);
+    if (responseData.isEmpty())
+        return false;
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();
     for (QJsonValueRef item : items) {
         data->deletedSubjects.append(item.toString());
     }
-}
+    return true;
-
-void ColnodAPI::newData()
-{
-    mData = std::make_shared<Data>();
 }
 
 bool ColnodAPI::checkResponse(const QByteArray &responseData)

src/colnod/colnodapi.h

@@ -41,15 +41,13 @@ class ColnodAPI: public QObject
     Q_OBJECT
 public:
     ColnodAPI() = default;
-    ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, const QString &userName = "spaceti", const QString &password = "spaceti1");
+    ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, QString userName = "spaceti", QString password = "spaceti1");
 
-    void downloadData(const qint64 &time);
+    bool downloadData(const qint64 &time);
     void processData(const std::shared_ptr<Data> &data);
 
-    // New approach
     std::shared_ptr<serversdk::Request> requestLogin();
 
-
     std::shared_ptr<serversdk::Request> getTokensUpdated(const Timestamp &time);
     std::shared_ptr<serversdk::Request> getTokensDeleted(const Timestamp &time);
     std::shared_ptr<serversdk::Request> getSubjectsUpdated(const Timestamp &time);
@@ -63,26 +61,21 @@ public:
     void setUserName(const QString &userName);
     QString password() const;
     void setPassword(const QString &password);
-    qint64 lastSync() const;
-    void setlastSync(const qint64 &lastSync);
 
     bool isValid();
 
 private:
-    Q_SLOT void areDataReady(std::shared_ptr<Data> data);
+    Q_SLOT void areDataReady(const std::shared_ptr<Data>& data);
-    Q_SLOT void isDataProcessFinished();
+    Q_SLOT void isDataProcessFinished(bool success);
 
 private:
-    void saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
+    bool saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
+    bool saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
+    bool saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
+    bool saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-
-    void newData();
 
     bool checkResponse(const QByteArray &responseData);
 
-    QByteArray getTimestampJson(const qint64 &time);
     std::shared_ptr<serversdk::Request> composeRequest(const QString &endpoint, const QByteArray &data);
 
     bool checkRequest(const std::shared_ptr<serversdk::Request> &request);
@@ -91,8 +84,8 @@ private:
 signals:
     void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());
     void partOfDataReady(std::shared_ptr<Data> = std::shared_ptr<Data>());
-    void partOfDataProcessFinished();
+    void partOfDataProcessFinished(bool success = true);
-    void dataProcessFinished();
+    void dataProcessFinished(bool success = true);
 
     void error();
 
@@ -104,8 +97,7 @@ private:
     Timestamp mLastSync;
     bool mDryMode = false;
     bool mValid = true;
-
+    bool mSuccess = true;
-    std::shared_ptr<Data> mData;
 
     QString authToken;
     qint16 amountData = 0;

src/colnod/data.cpp

@@ -9,8 +9,11 @@ void Data::clear()
     deletedSubjects.clear();
 }
 
-void Data::loadTokensFromJson(const QByteArray &data)
+bool Data::loadTokensFromJson(const QByteArray &data)
 {
+    if (data.isEmpty())
+        return false;
+
     auto doc = QJsonDocument::fromJson(data);
     auto items = doc.object()["items"].toArray();
     for (auto item : items) {
@@ -19,10 +22,14 @@ void Data::loadTokensFromJson(const QByteArray &data)
         token->fromJson(doc.toJson());
         updatedTokens.insert(token->id(), token);
     }
+    return true;
 }
 
-void Data::loadSubjectsFormJson(const QByteArray &data)
+bool Data::loadSubjectsFormJson(const QByteArray &data)
 {
+    if (data.isEmpty())
+        return false;
+
     auto doc = QJsonDocument::fromJson(data);
     auto items = doc.object()["items"].toArray();
     for (auto item : items) {
@@ -31,4 +38,10 @@ void Data::loadSubjectsFormJson(const QByteArray &data)
         subject->fromJson(doc.toJson());
         updatedSubjects.insert(subject->id(), subject);
     }
+    return true;
+}
+
+int Data::incrementCounter()
+{
+    return ++counter;
 }

src/colnod/data.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "token.h"
 #include "subject.h"
 
@@ -13,7 +15,7 @@ constexpr auto tab = "\t";
 class Message
 {
 public:
-    static QString massageTemplate(QString action, QString item, QString source, QString itemInfo)
+    static QString massageTemplate(const QString& action, const QString& item, const QString& source, const QString& itemInfo)
     {
         return action + " " + item + " in " + source + ", " + item + ": '" + itemInfo + "'";
     }
@@ -28,13 +30,19 @@ public:
 
     void clear();
 
-    void loadTokensFromJson(const QByteArray &data);
+    bool loadTokensFromJson(const QByteArray &data);
-    void loadSubjectsFormJson(const QByteArray &data);
+    bool loadSubjectsFormJson(const QByteArray &data);
 
     QHash<QString, std::shared_ptr<Token>> updatedTokens;
     QList<QString> deletedTokens;
     QHash<QString, std::shared_ptr<Subject>> updatedSubjects;
     QList<QString> deletedSubjects;
+
+    int incrementCounter();
+
+
+private:
+    int counter = 0;
 };
 
 struct PreparedData
@@ -46,8 +54,8 @@ public:
     {
     }
 
-
     // TODO: make unique_ptr ( neeed because of ColnodAPI )
     std::shared_ptr<Data> databaseData;
     std::shared_ptr<Data> colnodData;
+
 };

src/colnod/databaseapi.cpp

@@ -12,7 +12,7 @@ DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode)
     mDbMan->setDryMode(dryMode);
 }
 
-bool DatabaseAPI::open(QString host, QString name, QString user, QString password)
+bool DatabaseAPI::open(const QString& host, const QString& name, const QString& user, const QString& password)
 {
     return mDbMan->openPostgres(host, name, user, password);
 }
@@ -46,32 +46,49 @@ std::shared_ptr<Data> DatabaseAPI::downloadData()
     }
 
     return composeData(updatedQuery, deletedQuery);
-    // TODO: why emiting signal??
-    // this can return Strucutre
-    //emit downloadDataFinished(composeData(updatedQuery, deletedQuery));
 }
 
 bool DatabaseAPI::processData(const std::shared_ptr<Data> &data)
 {
-    uploadTokens(data->updatedTokens);
+    bool res = true;
-    uploadSubjects(data->updatedSubjects);
+    if (!uploadTokens(data->updatedTokens)) {
-    deleteItems(data->deletedTokens, "colnod_token");
+        res = false;
-    deleteItems(data->deletedSubjects, "colnod_subject");
+    }
-    if ( !data->updatedTokens.isEmpty() ||
+    if (!uploadSubjects(data->updatedSubjects)) {
-         !data->updatedSubjects.isEmpty() ||
+        res = false;
-         !data->deletedTokens.isEmpty() ||
+    }
-         !data->deletedSubjects.isEmpty()) {
+    if (!deleteItems(data->deletedTokens, "colnod_token")) {
+        res = false;
+    }
+    if (!deleteItems(data->deletedSubjects, "colnod_subject")) {
+        res = false;
+    }
+
+    qInfo(database) << tab << "- push db:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
+                     "] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
+
+    if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
+            !data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
         qInfo(database) << dash;
     }
-    qInfo(database) << tab << "-> DATA PROCESSED TO DATABASE:";
+    for (auto token : data->updatedTokens) {
-    qInfo(database) << tab << tab << data->updatedTokens.size() << "TOKENS ADDED/UPDATED";
+        qInfo(database) << Message::massageTemplate("Updated", "token", "database", token->name());
-    qInfo(database) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
+    }
-    qInfo(database) << tab << tab << data->updatedSubjects.size() << "SUBJECTS ADDED/UPDATED";
+    for (auto id : data->deletedTokens) {
-    qInfo(database) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
+        qInfo(database) << Message::massageTemplate("Deleted", "token", "database", id);
+    }
+    for (auto subject : data->updatedSubjects) {
+        qInfo(database) << Message::massageTemplate("Updated", "subject", "database", subject->name());
+    }
+    for (auto id : data->deletedSubjects) {
+        qInfo(database) << Message::massageTemplate("Deleted", "token", "database", id);
+    }
+    if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
+            !data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
         qInfo(database) << dash;
+    }
 
-    // TODO: add error handling
+    return res;
-    return true;
 }
 
 
@@ -86,10 +103,21 @@ std::shared_ptr<Data> DatabaseAPI::composeData(const QSqlQuery &updatedQuery, QS
         data->deletedTokens.append(deletedQuery.value(0).toString());
     }
 
-    qInfo(database) << tab << "-> DATABASE DATA:";
+    qInfo(database) << tab << "- src db:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
-    qInfo(database) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
+                     "] [ added/updated : deleted ]";
-    qInfo(database) << tab << tab << data->deletedTokens.size() << "TOKENS MARKED FOR DELETION";
+
+    if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
         qInfo(database) << dash;
+    }
+    for (auto token : data->updatedTokens) {
+        qInfo(database) << Message::massageTemplate("Download updated", "token", "database", token->name());
+    }
+    for (auto id : data->deletedTokens) {
+        qInfo(database) << Message::massageTemplate("Download deleted", "token", "database", id);
+    }
+    if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
+        qInfo(database) << dash;
+    }
 
     return data;
 }
@@ -118,24 +146,7 @@ void DatabaseAPI::setLastSync(qint64 timestamp)
     }
 }
 
-void DatabaseAPI::reupdateUpdated(const QHash<QString, std::shared_ptr<Token>> &tokens)
+void DatabaseAPI::reupdateDeleted(const QList<QString>& ids)
-{
-    auto query = mDbMan->createQuery();
-    for (const auto &token : tokens){
-        query.prepare("UPDATE colnod_token SET last_update = :last_update WHERE id = :id");
-        query.bindValue(":last_update", token->lastUpdate());
-        query.bindValue(":id", token->id());
-        if (!executeQuery(query)) {
-            qWarning(database) << "ERROR during updating last update of token:" << token->name() << ", it will be synced from Colnod to db in next sync. Last modified will be invalid";
-        }
-    }
-
-    qInfo(database) << equals;
-    qInfo(database) << "Synchronize last update in database with colnod";
-    qInfo(database) << equals;
-}
-
-void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
 {
     auto query = mDbMan->createQuery();
     for (const auto &id : ids){
@@ -148,7 +159,6 @@ void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
             }
         }
     }
-
 }
 
 qint64 DatabaseAPI::getNow()
@@ -159,48 +169,19 @@ qint64 DatabaseAPI::getNow()
         return -1;
     }
     query.next();
-    qDebug() << "Database time:" << QDateTime::fromMSecsSinceEpoch(query.value(0).toLongLong()).toString("yyyy-MM-dd hh:mm:ss.zzz");
-    qDebug() << "Current time:" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
     return query.value(0).toLongLong();
 }
 
-void DatabaseAPI::initNewTokens()
+bool DatabaseAPI::uploadTokens(const QHash<QString, std::shared_ptr<Token>> &tokens, const QSet<QString> &filters)
 {
-    auto query = mDbMan->createQuery();
-    if (!executeQuery(query, "SELECT * FROM colnod_token WHERE name IS NULL")) {
-        qWarning(database) << "ERROR during getting uninitialized tokens";
-    }
-    QHash<QString, std::shared_ptr<Token>> tokensToInit;
-    auto list = utils->tableFromQuery<Token>(query);
-    for (const auto &token : list) {
-        qint16 num = getNumOfTokensOfSubject(token->subjectId());
-        token->setName(getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
-        token->setDescription("mobile");
-        token->setTokenData(token->tokenData().toUpper());
-        tokensToInit.insert(token->id(), token);
-
-        qInfo(database).noquote() << Message::massageTemplate("Inicializing new", "token", "database", token->name());
-    }
-    uploadTokens(tokensToInit);
-}
-
-bool DatabaseAPI::uploadTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
-{
-    // TODO: first check if OK, then message
-    // OK -> token was updated
-    // ERROR -> not possible to update
     auto query = mDbMan->createQuery();
     for (const auto &token : tokens) {
-        // Get token
-
         if (exists(token->id(), "colnod_token")) {
-            query = utils->updateTable(token.get(), "colnod_token");
+            query = utils->updateTable(token.get(), "colnod_token", filters);
+            if (filters.contains("last_modified"))
                 qInfo(database).noquote() << Message::massageTemplate("Updating", "token", "database", token->name());
         }
         else {
-            // TODO: first check if OK, then message
-            // OK -> token was updated
-            // ERROR -> not possible to update
             query = utils->insertIntoTable(token.get(), "colnod_token");
             qInfo(database).noquote() << Message::massageTemplate("Adding", "token", "database", token->name());
         }
@@ -251,6 +232,19 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
 {
     auto query = mDbMan->createQuery();
     QString nowString = QDateTime::fromMSecsSinceEpoch(getLastSync()).toString("yyyy-MM-dd hh:mm:ss.zzz");
+
+    if (tableName == "colnod_subject") {
+        for (const auto &id : ids) {
+            query.prepare("DELETE FROM colnod_subject_attribute WHERE subject_id = :id");
+            query.bindValue(":id", id);
+            if (!executeQuery(query)) {
+                qWarning(database) << "ERROR during marking as deleted:" << id;
+                mValid = false;
+                return false;
+            }
+        }
+    }
+
     for (const auto &id : ids) {
         qInfo(database).noquote() << Message::massageTemplate("Deleting", tableName.mid(tableName.indexOf("_") + 1, tableName.length() - 1), "database", id);
 
@@ -258,7 +252,8 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
         query.bindValue(":id", id);
         query.bindValue(":now", nowString);
         if (!executeQuery(query)) {
-            qWarning(database) << "ERROR during marking token as deleted:" << id;
+            qWarning(database) << "ERROR during marking as deleted:" << id;
+            mValid = false;
             return false;
         }
     }
@@ -268,35 +263,18 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
 std::shared_ptr<Token> DatabaseAPI::getToken(const QString &id)
 {
     auto query = mDbMan->createQuery();
-    query.prepare("SELECT * FROM colnod_token WHERE d = :id");
+    query.prepare("SELECT * FROM colnod_token WHERE id = :id");
     query.bindValue(":id", id);
     if (!executeQuery(query)) {
         qCritical(database) << "ERROR during accessing existing tokens. EXIT";
-        emit error();
         return nullptr;
     }
     auto list = utils->tableFromQuery<Token>(query);
     if (list.isEmpty())
-        return nullptr;
+        return std::make_shared<Token>();
     return list.at(0);
 }
 
-bool DatabaseAPI::isAlreadyDeleted(const QString &id)
-{
-    auto token = getToken(id);
-    if (!token) {
-        if (id.isEmpty()) {
-
-        }
-        qWarning(database) << "Token deleted in colnod doesn't exists in db, will be noted as already deleted in stats";
-        return true;
-    }
-    if (token->deleted())
-        return true;
-    return false;
-
-}
-
 bool DatabaseAPI::isValid()
 {
     return mValid;

src/colnod/databaseapi.h

@@ -20,10 +20,10 @@ class DatabaseAPI : public QObject
 public:
     explicit DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode);
 
-    bool open(QString host = "192.168.1.94",
+    bool open(const QString& host = "192.168.1.94",
-              QString name = "deloitte",
+              const QString& name = "deloitte",
-              QString user = "postgres",
+              const QString& user = "postgres",
-              QString password = "34rjkciea12");
+              const QString& password = "34rjkciea12");
 
     bool executeQuery(QSqlQuery &query, const QString &statement = QString());
 
@@ -31,21 +31,17 @@ public:
     bool processData(const std::shared_ptr<Data> &data);
     qint64 getLastSync();
     void setLastSync(qint64 timestamp);
-    void reupdateUpdated(const QHash<QString, std::shared_ptr<Token> > &tokens);
+    void reupdateDeleted(const QList<QString>& ids);
-    void reupdateDeleted(const QList<QString> ids);
     qint64 getNow();
 
-    void initNewTokens();
 
     // process data
-    bool uploadTokens(const QHash<QString, std::shared_ptr<Token> > &tokens);
+    bool uploadTokens(const QHash<QString, std::shared_ptr<Token> > &tokens, const QSet<QString> &filters  = {});
     bool uploadSubjects(const QHash<QString, std::shared_ptr<Subject> > &subjects);
     bool deleteItems(const QList<QString> &ids, const QString &tableName);
 
     std::shared_ptr<Token> getToken(const QString &id);
 
-    bool isAlreadyDeleted(const QString &id);
-
     bool isValid();
 
     qint16 getNumOfTokensOfSubject(const QString &id);
@@ -54,7 +50,6 @@ public:
 private:
     int exists(const QString &id, const QString &tableName);
 
-    QSqlQuery getUpdatedTokens();
     std::shared_ptr<Data> composeData(const QSqlQuery &updatedQuery, QSqlQuery &deletedQuery);
 
 signals:

src/colnod/subject.h

@@ -13,7 +13,6 @@ class SubjectAttribute : public serversdk::DatabaseTable {
     TABLE_PROPERTY(QString, subjectId, setSubjectId, "")
 };
 
-
 class Subject : public serversdk::DatabaseTable {
     Q_OBJECT
     TABLE_PROPERTY(QString, id, setId, QString())
@@ -24,7 +23,6 @@ class Subject : public serversdk::DatabaseTable {
     TABLE_PROPERTY(QDateTime, lastModified, setLastModified, QDateTime())
     TABLE_PROPERTY(bool, deleted, setDeleted, false)
 
-
 public:
     Subject() = default;
     explicit Subject(const QString& name);
@@ -32,7 +30,6 @@ public:
     bool fromJson(const QByteArray &data) override;
     QList<std::shared_ptr <SubjectAttribute>> getAttributes();
 
-
 private:
     QList<std::shared_ptr <SubjectAttribute>> attributes;
 };

src/colnod/syncmanager.cpp

@@ -43,14 +43,7 @@ bool SyncManager::startSynchronization()
         return false;
     }
 
-    qInfo(syncmanager) << equals;
+    qInfo(syncmanager) << tab << "- begin sync ( previous sync" << mlastSync.toDateString() << ")";
-    qInfo(syncmanager) << "SYNCHRONIZATION BEGIN";
-
-    qInfo(syncmanager) << equals;
-    qInfo(syncmanager) << "DOWNLOADING DATA -> BEGIN";
-    qInfo(syncmanager) << dash;
-    qInfo(syncmanager).noquote() << "Modified data since last synchronization (" << mlastSync.toDateString() << "):";
-    qInfo(syncmanager) << dash;
 
     // GETTING DATA FROM DATABASE
     auto databaseData = database->downloadData();
@@ -60,83 +53,69 @@ bool SyncManager::startSynchronization()
     }
     // NOW I HAVE DATA FROM DATABASE
 
-    colnod->downloadData(syncBegin);
+    colnod->downloadData(mlastSync.timestamp());
-    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> colnodData) {
+    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](const std::shared_ptr<Data> &colnodData) {
-        qInfo(syncmanager) << "DOWNLOADING DATA -> FINISHED";
-        qInfo(syncmanager) << equals;
-
         if (!colnodData) {
             qCritical(syncmanager) << "Not possible to get correct data from colnod";
             QCoreApplication::exit(-1);
             return;
         }
 
-        // NOW I SHOULD HAVE VALID DATA FROM COLNOD
-
-
         std::unique_ptr<PreparedData> preparedData = prepareDataNew(databaseData, colnodData);
         if (!preparedData) {
-            qCritical(syncmanager) << "Not possible to get correct data from colnod";
+            qCritical(syncmanager) << "Not possible to compose data";
             QCoreApplication::exit(-1);
             return;
         }
 
-        qInfo(syncmanager) << equals;
-        qInfo(syncmanager) << "PROCESSING DATA -> BEGIN";
-        qInfo(syncmanager) << dash;
-        qInfo(syncmanager) << "Push changes to both Colnod and Database:";
-        qInfo(syncmanager) << dash;
 
-        if (!database->processData(preparedData->databaseData)) {
+        if (!database->processData(preparedData->colnodData)) {
             qCritical(syncmanager) << "Not possible to upload data to database";
         }
 
         // data is processed to other sides
-        connect(colnod.get(), &ColnodAPI::dataProcessFinished, [&](){
+        connect(colnod.get(), &ColnodAPI::dataProcessFinished, [&,syncBegin](bool success){
-            qInfo(syncmanager) << "PROCESSING DATA -> FINISHED";
+            if (!success) {
-            qInfo(syncmanager) << equals;
+                qCritical(syncmanager) << "Not possible to upload data to colnod";
+            }
 
             // REUPDATE tokens pushed from database to colnod (cause of lastUpdate time)
             Timestamp time;
             time.setTimestamp(syncBegin);
 
-            database->reupdateDeleted(preparedData->databaseData->deletedTokens);
             // download data changes in this sync
-            colnod->getTokensUpdated(time);
+            auto tokensRequest = colnod->getTokensUpdated(time);
 
             // updated data are ready
-            connect(colnod.get(), &ColnodAPI::partOfDataReady, [=](const std::shared_ptr<Data> &uploadedData){
+            connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
+
+                auto uploadedData = std::make_shared<Data>();
+                uploadedData->loadTokensFromJson(tokensRequest->responseData());
+
                 if (!uploadedData) {
                     qCritical(syncmanager) << "Not possible to get correct data from colnod";
                     QCoreApplication::exit(-1);
                     return;
                 }
-                if (!database->uploadTokens(uploadedData->updatedTokens)) {
+                if (!database->uploadTokens(uploadedData->updatedTokens, {"lastModified"})) {
                     qCritical(syncmanager) << "Not possible to upload data to database";
+                    QCoreApplication::exit(-1);
+                    return;
                 }
-                database->reupdateDeleted(uploadedData->deletedTokens);
+                database->reupdateDeleted(databaseData->deletedTokens);
 
                 if (!database->isValid() || !colnod->isValid()) {
-                    qWarning(syncmanager) << "Synchronization was unsuccessful, next run of sync will be with same last sync time, check warnings";
+                    qWarning(syncmanager) << "Unsuccessful FINISH, check warnings";
                 }
                 else {
                     database->setLastSync(syncBegin);
-                    qInfo(syncmanager).noquote() << "Update last synchronization time to time of this sync ("
+                    qInfo(syncmanager) << "Successful FINISH";
-                                       <<  QDateTime::fromMSecsSinceEpoch(syncBegin).toString("yyyy-MM-dd hh:mm:ss.zzz")
-                                       << ")";
                 }
-
-                qInfo(syncmanager) << equals;
-                qInfo(syncmanager) << "SYNCHRONIZATION FINISHED";
-                qInfo(syncmanager) << equals;
-
                 QCoreApplication::exit();
             });
 
-
         });
-        colnod->processData(preparedData->colnodData);
+        colnod->processData(preparedData->databaseData);
-        //qCritical(syncmanager) << "Not possible to upload data to colnod";
     });
 
     return true;
@@ -151,48 +130,6 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
     QList<QString> conflicts;
     QList<QString> alreadySynced;
 
-    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;
-
-
-    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);
@@ -216,20 +153,67 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
         }
     }
 
-    qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
+    preparedDatabaseData->deletedTokens = databaseData->deletedTokens;
-    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) << tab << "- prep db:" << tab << "tokens [" << preparedDatabaseData->updatedTokens.size() << ":" << preparedDatabaseData->deletedTokens.size() <<
-    qInfo(syncmanager) << equals;
+                     "] [ added/updated : deleted ]";
+
+    // add all data which should be pushed to database
+    for (const auto &colnodToken : colnodData->updatedTokens) {
+
+        // not conflict so add to prepered tokens
+        if (!databaseData->updatedTokens.contains(colnodToken->id())) {
+            auto token = database->getToken(colnodToken->id());
+            if (!token) {
+                qCritical(syncmanager) << "Not possible to access database.";
+                return nullptr;
+            }
+            if ( token ) {
+                // alredy synced ( tokens are same )
+                if (token == colnodToken) {
+                    alreadySynced.append(colnodToken->id());
+                    continue;
+                }
+            }
+            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());
+        }
+    }
+
+    for (const auto &id : colnodData->deletedTokens) {
+        auto corespondingToken = database->getToken(id);
+        if ( !corespondingToken) {
+            qWarning(syncmanager) << "Token:" << id << ", deleted in colnod, but not exists in db";
+            continue;
+        }
+        if ( !corespondingToken->deleted()) {
+            preparedColnodData->deletedTokens.append(id);
+        }
+    }
+
+    preparedColnodData->updatedSubjects = colnodData->updatedSubjects;
+    preparedColnodData->deletedSubjects = colnodData->deletedSubjects;
+
+    qInfo(syncmanager) << tab << "- prep col:" << tab << "tokens [" << preparedColnodData->updatedTokens.size() << ":" << preparedColnodData->deletedTokens.size() <<
+                     "] subjects [" << preparedColnodData->updatedSubjects.size() << ":" << preparedColnodData->deletedSubjects.size() << "] [ added/updated : deleted ]";
 
 
     auto preparedData = std::make_unique<PreparedData>(preparedDatabaseData, preparedColnodData);
     return preparedData;
 }
 
-void SyncManager::initNewToken(std::shared_ptr<Token> token)
+void SyncManager::initNewToken(const std::shared_ptr<Token>& token)
 {
+    Q_ASSERT(database);
+    Q_ASSERT(token);
     qint16 num = database->getNumOfTokensOfSubject(token->subjectId());
     token->setName(database->getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
     token->setDescription("mobile");
@@ -237,102 +221,3 @@ 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;
-}

src/colnod/syncmanager.h

@@ -26,17 +26,9 @@ 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:
-    void initNewToken(std::shared_ptr<Token> token);
+    void initNewToken(const std::shared_ptr<Token>& token);
-
-    void updateLastUpdate(qint64 syncBegin);
-
-signals:
-    void syncFinished();
-
-    void error();
 
 private:
     std::shared_ptr<ColnodAPI> colnod;

src/colnod/token.cpp

@@ -45,6 +45,7 @@ QByteArray Token::jsonData(const QSet<QString> &filters) const
     QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
     return doc.toJson(QJsonDocument::Compact);
 }
+
 bool Token::fromJson(const QByteArray &data)
 {
     QJsonDocument doc = QJsonDocument::fromJson(data);
@@ -81,24 +82,3 @@ QByteArray Token::idsToJSON(const QList<QString> &ids)
     doc.setObject(items);
     return doc.toJson();
 }
-
-
-void Token::fromSQLRecord(const QSqlQuery& query)
-{
-    setId(query.value(0).toString());
-    a_authErrors = query.value(1).toInt();
-    setDescription(query.value(2).toString());
-    setNoValidity(query.value(6).toBool());
-    setEnabled(query.value(3).toBool());
-    QDateTime date = query.value(4).toDateTime();
-    setLastUpdate(date);
-    setName(query.value(5).toString());
-    a_timeToLive = query.value(7).toInt();
-    a_tokenBits = query.value(8).toInt();
-    a_tokenData = query.value(9).toString();
-    a_tokenType = query.value(10).toString();
-    a_subjectId = query.value(11).toString();
-    date = query.value(12).toDateTime();
-    setLastModified(date);
-    setDeleted(query.value(13).toBool());
-}

src/colnod/token.h

@@ -65,8 +65,6 @@ public:
                 lToken->subjectId() == rToken->subjectId();
     }
 
-    void fromSQLRecord(const QSqlQuery& query);
-
     static QByteArray tokensToColnodJson(const QHash<QString, std::shared_ptr<Token> > &tokens);
     static QByteArray idsToJSON(const QList<QString> &ids);
 

test/auto/colnod/tst_colnodapi.cpp

@@ -7,6 +7,7 @@
 Q_DECLARE_METATYPE(std::shared_ptr<Data>)
 Q_DECLARE_METATYPE(std::shared_ptr<serversdk::Request>);
 
+
 class ColnodTest : public QObject
 {
     Q_OBJECT
@@ -14,13 +15,13 @@ public:
     ColnodTest()
     {
         qRegisterMetaType<std::shared_ptr<Data>>();
-        qRegisterMetaType<std::shared_ptr<serversdk::Request>>();
+        qRegisterMetaType<std::shared_ptr<serversdk::Request>>("std::shared_ptr<Request>");
     }
 
 private slots:
     void login();
-    void getTokens();
     void download_data_test();
+    void download_data_test_now();
     void download_data_fail_test();
 
 private:
@@ -39,37 +40,29 @@ void ColnodTest::login()
     QVERIFY(login->responseData().contains("id"));
 }
 
-void ColnodTest::getTokens()
-{
-    serversdk::RequestManager reqMan;
-    ColnodAPI colnod(&reqMan);
-
-    // get login token
-    auto login = colnod.requestLogin();
-    QSignalSpy spy(login.get(), &serversdk::Request::finished);
-    spy.wait();
-    QString token = getLoginToken(colnod);
-    Timestamp time;
-    time.setTimestamp(QDateTime::currentMSecsSinceEpoch());
-    colnod.getTokensUpdated(time);
-}
-
 void ColnodTest::download_data_test()
 {
     serversdk::RequestManager reqMan;
+    //reqMan.setIgnoreSsl(true);
     ColnodAPI colnod(&reqMan);
-    {
+
     QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
+    QVERIFY(spy.isValid());
     colnod.downloadData(1570190399259);
     QVERIFY(spy.wait());
 
     auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
     QVERIFY(data);
 
-        QVERIFY(data->updatedTokens.size() > 0);
+    QVERIFY(! data->updatedTokens.isEmpty());
     QVERIFY(data->updatedTokens.contains("5e2f1260-da1c-441f-9644-24dfe3b97b2a"));
 }
+
+void ColnodTest::download_data_test_now()
 {
+    serversdk::RequestManager reqMan;
+    ColnodAPI colnod(&reqMan);
+
     colnod.downloadData(QDateTime::currentMSecsSinceEpoch());
     QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
     QVERIFY(spy.wait());
@@ -78,7 +71,6 @@ void ColnodTest::download_data_test()
 
     QVERIFY(data->updatedTokens.isEmpty());
 }
-}
 
 void ColnodTest::download_data_fail_test()
 {

test/auto/database/tst_databaseapi.cpp

@@ -2,6 +2,7 @@
 
 #include "databaseapi.h"
 // add necessary includes here
+#include "token.h"
 
 class DatabaseTest : public QObject
 {
@@ -14,6 +15,7 @@ private slots:
     void open_database_password_fail_test();
     void download_data_test();
     void download_data_fail_test();
+    void get_token_test();
 };
 
 void DatabaseTest::open_database_test()
@@ -76,6 +78,36 @@ void DatabaseTest::download_data_fail_test()
     QVERIFY(!db.downloadData());
 }
 
+void DatabaseTest::get_token_test()
+{
+    serversdk::DatabaseManager dbManager;
+    DatabaseAPI db(&dbManager, false);
+    {
+        QTest::ignoreMessage(QtWarningMsg, "QSqlQuery::prepare: database not open");
+        QTest::ignoreMessage(QtSystemMsg, "ERROR during accessing existing tokens. EXIT");
+        QVERIFY(!db.getToken("6c907a42-0401-4403-8af4-9d58eb35cddc"));
+    }
+
+    db.open();
+
+    auto token = db.getToken("6c907a42-0401-4403-8af4-9d58eb35cddc");
+    QVERIFY(token);
+    auto compareToken = std::make_shared<Token>();
+    compareToken->setId("6c907a42-0401-4403-8af4-9d58eb35cddc");
+    compareToken->setName("Losenicky");
+    compareToken->setDescription("");
+    compareToken->setLastUpdate(QDateTime::fromMSecsSinceEpoch(1543494713260));
+    compareToken->setTokenData("AB1EA4D4");
+    compareToken->setSubjectId("69c6e3b3-3f23-456f-a6c2-73ef08e589a4");
+    QCOMPARE(compareToken, token);
+
+    auto compareToken1 = std::make_shared<Token>();
+    auto token1 = db.getToken("non-existing-id");
+    QVERIFY(token1);
+    QCOMPARE(compareToken1, token1);
+
+}
+
 
 QTEST_APPLESS_MAIN(DatabaseTest)
 

test/auto/syncmanager/tst_syncmanager.cpp

@@ -6,29 +6,147 @@
 class SyncManagerTest : public QObject
 {
     Q_OBJECT
+private:
+    std::shared_ptr<Token> tokenFromString(const QString &text);
 private slots:
+    void tokenFromString_test();
     void sync_init_test();
     void prepareData_test();
+    void prepareData_tokens();
+    void prepareData_tokens_data();
 
 };
 
+std::shared_ptr<Token> SyncManagerTest::tokenFromString(const QString &text)
+{
+    auto split = text.split(",");
+    if (split.count() != 2)
+        return nullptr;
+
+    auto token = std::make_shared<Token>();
+    token->setId(split.first());
+    token->setDescription("mobile");
+    token->setLastUpdate(QDateTime::fromString(split.last(), "yyyyMMdd:HHmmss"));
+    return token;
+}
+
+void SyncManagerTest::tokenFromString_test()
+{
+    auto token = tokenFromString("id1,20191010:232300");
+    QCOMPARE(token->id(), QStringLiteral("id1"));
+    QCOMPARE(token->lastUpdate(), QDateTime::fromString("20191010:232300", "yyyyMMdd:HHmmss"));
+}
+
 void SyncManagerTest::sync_init_test()
 {
     SyncManager sync(true);
     QVERIFY(sync.databaseInitialization());
 }
 
+
 void SyncManagerTest::prepareData_test()
 {
     SyncManager sync(true);
+    QVERIFY(sync.databaseInitialization());
     auto dbData = std::make_shared<Data>();
     auto colnodData = std::make_shared<Data>();
 
-    auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
+    auto token = std::make_shared<Token>();
+    token->setDescription("mobile");
+    token->setId("id1");
+    dbData->updatedTokens.insert("id1", token);
+
+    auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
+    QVERIFY(newPreparedData->databaseData->updatedTokens.contains("id1"));
+    QVERIFY(newPreparedData->databaseData->updatedSubjects.isEmpty());
+    QVERIFY(newPreparedData->databaseData->deletedTokens.isEmpty());
+    QVERIFY(newPreparedData->databaseData->deletedSubjects.isEmpty());
+}
+
+void SyncManagerTest::prepareData_tokens()
+{
+    SyncManager sync(true);
+    QVERIFY(sync.databaseInitialization());
+
+
+
+    QFETCH(QString, db_token_updated);
+    QFETCH(QString, db_token_deleted);
+    QFETCH(QString, colnod_token_updated);
+    QFETCH(QString, colnod_token_deleted);
+    QFETCH(QString, expected_db_tokens_toupdate);
+    QFETCH(QString, expected_db_tokens_todelete);
+    QFETCH(QString, expected_colnod_tokens_toupdate);
+    QFETCH(QString, expected_colnod_tokens_todelete);
+
+    // fake data
+    auto dbData = std::make_shared<Data>();
+    auto colnodData = std::make_shared<Data>();
+
+    // Database
+    auto utoken = tokenFromString(db_token_updated);
+    if ( utoken )
+        dbData->updatedTokens.insert(utoken->id(), utoken);
+    auto dtoken = tokenFromString(db_token_deleted);
+    if ( dtoken )
+        dbData->deletedTokens.append(dtoken->id());
+
+    // Colnod
+    auto colnod_utoken = tokenFromString(colnod_token_updated);
+    if ( colnod_utoken )
+        colnodData->updatedTokens.insert(colnod_utoken->id(), colnod_utoken);
+    auto colnod_dtoken = tokenFromString(colnod_token_deleted);
+    if ( colnod_dtoken )
+        colnodData->deletedTokens.append(colnod_dtoken->id());
+
     auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
 
-    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
+
-    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
+    auto testTokens = [=](const QSet<QString> &set, const QString &expectedId) {
+        if (expectedId.isEmpty()) {
+            QVERIFY(set.isEmpty());
+        } else {
+            QVERIFY(set.contains(expectedId));
+        }
+    };
+
+    testTokens(newPreparedData->databaseData->updatedTokens.keys().toSet(), expected_db_tokens_toupdate);
+    testTokens(newPreparedData->databaseData->deletedTokens.toSet(), expected_db_tokens_todelete);
+
+    testTokens(newPreparedData->colnodData->updatedTokens.keys().toSet(), expected_colnod_tokens_toupdate);
+
+    // Can't work without access to database
+    //testTokens(newPreparedData->colnodData->deletedTokens.toSet(), expected_colnod_tokens_todelete);
+}
+
+void SyncManagerTest::prepareData_tokens_data()
+{
+    QTest::addColumn<QString>("db_token_updated");
+    QTest::addColumn<QString>("db_token_deleted");
+    QTest::addColumn<QString>("colnod_token_updated");
+    QTest::addColumn<QString>("colnod_token_deleted");
+    QTest::addColumn<QString>("expected_db_tokens_toupdate");
+    QTest::addColumn<QString>("expected_db_tokens_todelete");
+    QTest::addColumn<QString>("expected_colnod_tokens_toupdate");
+    QTest::addColumn<QString>("expected_colnod_tokens_todelete");
+
+    // in: db 1 new token
+    // out: 1 db token must be updated in colnod
+    QTest::newRow("db 1 update") << "id1,20191010:23:23:00" << ""
+                             << "" << ""
+                             // expected database: toupdate << todelete
+                             << "id1" << ""
+                             // expected colnod: toupdate << todelete
+                             << "" << "";
+    // in: id1 deleted in colnod
+    // out: 1 colnod token must be deleted from database
+    QEXPECT_FAIL("delete 1 existing token in database", "Rare case, not sure if handling is needed", Continue);
+    QTest::newRow("delete 1 existing token in database") << "" << ""
+                             << "" << "id1,20191010:23:23:00"
+                             // expected database: toupdate << todelete
+                             << "" << ""
+                             // expected colnod: toupdate << todelete
+                             << "" << "id1";
 }
 
 QTEST_MAIN(SyncManagerTest)