Change token and subject to inherit from databaseTable

server-sdk

@@ -1 +1 @@
-Subproject commit b92095a459ff5829f9e1cf9d119391ddcb99ac9c
+Subproject commit 7071d874b066b95f140ecece6609d21d4707fc98

src/colnod/colnodapi.cpp

@@ -100,7 +100,7 @@ void ColnodAPI::getSubjectsDeleted(const Timestamp &time)
     });
 }
 
-void ColnodAPI::setTokens(const QHash<QUuid, std::shared_ptr<Token>> &tokens)
+void ColnodAPI::setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
 {
     auto request = composeRequest("/TokenManager/setTokens", Token::tokensToJSON(tokens));
     request->setToken(authToken);
@@ -184,14 +184,7 @@ void ColnodAPI::isDataProcessFinished()
 
 void ColnodAPI::saveUpdatedTokens(const QByteArray &responseData)
 {
-    QJsonDocument doc = QJsonDocument::fromJson(responseData);
+    data->loadTokensFromJson(responseData);
-    QJsonArray items = doc.object()["items"].toArray();
-    for (QJsonValueRef item : items) {
-        auto token = std::make_shared<Token>();
-        token->fromJSON(item.toObject());
-        token->setDeleted(false);
-        data->updatedTokens.insert(token->getId(), token);
-    }
 }
 
 void ColnodAPI::saveDeletedTokens(const QByteArray &responseData)
@@ -205,14 +198,7 @@ void ColnodAPI::saveDeletedTokens(const QByteArray &responseData)
 
 void ColnodAPI::saveUpdatedSubjects(const QByteArray &responseData)
 {
-    QJsonDocument doc = QJsonDocument::fromJson(responseData);
+    data->loadSubjectsFormJson(responseData);
-    QJsonArray items = doc.object()["items"].toArray();
-    for (QJsonValueRef item : items) {
-        auto subject = std::make_shared<Subject>();
-        subject->fromJSON(item.toObject());
-        subject->setDeleted(false);
-        data->updatedSubjects.insert(subject->getId(), subject);
-    }
 }
 
 void ColnodAPI::saveDeletedSubjects(const QByteArray &responseData)

src/colnod/colnodapi.h

@@ -50,7 +50,7 @@ public:
     void getSubjectsUpdated(const Timestamp &time);
     void getSubjectsDeleted(const Timestamp &time);
 
-    void setTokens(const QHash<QUuid, std::shared_ptr<Token>> &tokens);
+    void setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens);
     void deleteTokens(const QList<QString> &tokenIds);
 
     // Attributes

src/colnod/data.cpp

@@ -12,3 +12,27 @@ void Data::clear()
     deletedTokens.clear();
     deletedSubjects.clear();
 }
+
+void Data::loadTokensFromJson(const QByteArray &data)
+{
+    auto doc = QJsonDocument::fromJson(data);
+    auto items = doc.object()["items"].toArray();
+    for (auto item : items) {
+        auto token = std::make_shared<Token>();
+        token->fromJson(item.toString().toUtf8());
+        token->setDeleted(false);
+        updatedTokens.insert(token->id(), token);
+    }
+}
+
+void Data::loadSubjectsFormJson(const QByteArray &data)
+{
+    auto doc = QJsonDocument::fromJson(data);
+    auto items = doc.object()["items"].toArray();
+    for (auto item : items) {
+        auto subject = std::make_shared<Subject>();
+        subject->fromJson(item.toString().toUtf8());
+        subject->setDeleted(false);
+        updatedSubjects.insert(subject->id(), subject);
+    }
+}

src/colnod/data.h

@@ -11,9 +11,11 @@ public:
 
     void clear();
 
-    QHash<QUuid, std::shared_ptr<Token>> updatedTokens;
+    void loadTokensFromJson(const QByteArray &data);
+    void loadSubjectsFormJson(const QByteArray &data);
+    QHash<QString, std::shared_ptr<Token>> updatedTokens;
     QList<QString> deletedTokens;
-    QHash<QUuid, std::shared_ptr<Subject>> updatedSubjects;
+    QHash<QString, std::shared_ptr<Subject>> updatedSubjects;
     QList<QString> deletedSubjects;
 };
 

src/colnod/databaseapi.cpp

@@ -5,12 +5,12 @@
 DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan)
     :mDbMan(dbMan)
 {
-
+    utils = std::make_unique<serversdk::DatabaseUtils>(dbMan);
 }
 
 bool DatabaseAPI::open()
 {
-    return mDbMan->openPostgres(QStringLiteral("192.168.1.94"), // move to databaseAPi
+    return mDbMan->openPostgres(QStringLiteral("192.168.1.94"),
                                 QStringLiteral("deloitte"),
                                 QStringLiteral("postgres"),
                                 QStringLiteral("34rjkciea12"),
@@ -30,20 +30,21 @@ void DatabaseAPI::processData(std::shared_ptr<Data> data)
 {
     uploadTokens(data->updatedTokens);
     uploadSubjects(data->updatedSubjects);
-    deleteTokens(data->deletedTokens);
+    deleteItems(data->deletedTokens, "colnod_token");
-    deleteSubjects(data->deletedSubjects);
+    deleteItems(data->deletedSubjects, "colnod_subject");
 }
 
 
 
 
+
 std::shared_ptr<Data> DatabaseAPI::composeData(QSqlQuery updatedQuery, QSqlQuery deletedQuery)
 {
     auto data = std::make_shared<Data>();
     while (updatedQuery.next()) {
         auto token = std::make_shared<Token>();
         token->fromSQLRecord(updatedQuery);
-        data->updatedTokens.insert(token->getId(), token);
+        data->updatedTokens.insert(token->id(), token);
     }
     while (deletedQuery.next()) {
         data->deletedTokens.append(deletedQuery.value(0).toString());
@@ -64,19 +65,19 @@ qint64 DatabaseAPI::getLastSync()
 
 void DatabaseAPI::setLastSync(qint64 timestamp)
 {
-    QSqlQuery query;
+    QSqlQuery query("test", mDbMan->database());
     query.prepare("UPDATE config SET last_sync = :last_sync");
     query.bindValue(":last_sync", timestamp);
     mDbMan->executeQuery(query);
 }
 
-void DatabaseAPI::setLastUpdate(QHash<QUuid, std::shared_ptr<Token>> tokens)
+void DatabaseAPI::setLastUpdate(QHash<QString, std::shared_ptr<Token>> tokens)
 {
-    QSqlQuery query;
+    QSqlQuery query("test", mDbMan->database());
     for (const auto &token : tokens){
         query.prepare("UPDATE colnod_token SET last_update = :last_update WHERE id = :id");
-        query.bindValue(":last_update", QDateTime::fromMSecsSinceEpoch(token->getLastUpdate()).toString("yyyy-MM-dd hh:mm:ss.zzz"));
+        query.bindValue(":last_update", token->lastUpdate());
-        query.bindValue(":id", token->idToStringWithoutBraces());
+        query.bindValue(":id", token->id());
         mDbMan->executeQuery(query);
     }
 }
@@ -92,36 +93,69 @@ void DatabaseAPI::initNewTokens()
 {
     QSqlQuery query = mDbMan->execPlainSql("SELECT id, auth_errors, description, enabled, last_update, name, no_validity, time_to_live, token_bits, token_data, token_type, subject_id, last_modified, deleted "
                                            "FROM colnod_token WHERE name IS NULL");
-    QHash<QUuid, std::shared_ptr<Token>> tokensToInit;
+    QHash<QString, std::shared_ptr<Token>> tokensToInit;
     while (query.next()){
         auto token = std::make_shared<Token>();
         token->fromSQLRecord(query);
-        qint16 num = getNumOfTokensOfSubject(token->subjectIdToStringWithoutBraces());
+        qint16 num = getNumOfTokensOfSubject(token->subjectId());
-        token->setName(getSubjectNameByTokenId(token->idToStringWithoutBraces()) + "_mobile_" + QString::number(num + 1));
+        token->setName(getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
         token->setDescription("mobile");
-        tokensToInit.insert(token->getId(), token);
+        tokensToInit.insert(token->id(), token);
     }
     uploadTokens(tokensToInit);
 }
 
-void DatabaseAPI::uploadTokens(QHash<QUuid, std::shared_ptr<Token>> tokens)
+void DatabaseAPI::uploadTokens(QHash<QString, std::shared_ptr<Token>> tokens)
 {
     // TODO:
+    QSqlQuery query("test", mDbMan->database());
+    for (const auto &token : tokens) {
+        if (exists(token->id(), "colnod_token")) {
+            query = utils->updateTable(token.get(), "colnod_token");
+        }
+        else {
+            query = utils->insertIntoTable(token.get(), "colnod_token");
+        }
+        query = mDbMan->executeQuery(query);
+    }
 }
 
-void DatabaseAPI::uploadSubjects(QHash<QUuid, std::shared_ptr<Subject>> subjects)
+void DatabaseAPI::uploadSubjects(QHash<QString, std::shared_ptr<Subject>> subjects)
 {
     // TODO:
+    QSqlQuery query("test", mDbMan->database());
+    for (const auto &subject : subjects) {
+        if (exists(subject->id(), "colnod_subject")) {
+            query = utils->updateTable(subject.get(), "colnod_subject");
+        }
+        else {
+            query = utils->insertIntoTable(subject.get(), "colnod_subject");
+        }
+        query = mDbMan->executeQuery(query);
+    }
 }
 
-void DatabaseAPI::deleteTokens(QList<QString> ids)
+void DatabaseAPI::deleteItems(QList<QString> ids, const QString &tableName)
 {
     // TODO:
+    QSqlQuery query("test", mDbMan->database());
+    QString nowString = QDateTime::fromMSecsSinceEpoch(getLastSync()).toString("yyyy-MM-dd hh:mm:ss.zzz");
+    for (const auto &id : ids) {
+        query.prepare(QString("UPDATE %1 SET deleted = true, last_update = :now, last_modified = :now WHERE id = :id").arg(tableName));
+        query.bindValue(":id", id);
+        query.bindValue(":now", nowString);
+        mDbMan->executeQuery(query);
+    }
 }
 
-void DatabaseAPI::deleteSubjects(QList<QString> ids)
+bool DatabaseAPI::exists(const QString &id, const QString &tableName)
 {
-    // TODO:
+
+    QSqlQuery query("test", mDbMan->database());
+    query.prepare(QString("SELECT 1 FROM %1 WHERE id = :id").arg(tableName));
+    query.bindValue(":id", id);
+    query = mDbMan->executeQuery(query);
+    return query.next();
 }
 
 
@@ -131,7 +165,7 @@ void DatabaseAPI::deleteSubjects(QList<QString> ids)
 
 qint16 DatabaseAPI::getNumOfTokensOfSubject(const QString &id)
 {
-    QSqlQuery query;
+    QSqlQuery query("test", mDbMan->database());
     query.prepare("SELECT 1 FROM colnod_token WHERE subject_id = :id AND deleted = false");
     query.bindValue(":id", id);
     return static_cast<qint16>(mDbMan->executeQuery(query).size());
@@ -139,7 +173,7 @@ qint16 DatabaseAPI::getNumOfTokensOfSubject(const QString &id)
 
 QString DatabaseAPI::getSubjectNameByTokenId(const QString &tokenId)
 {
-    QSqlQuery query;
+    QSqlQuery query("test", mDbMan->database());
     query.prepare("SELECT name FROM colnod_subject WHERE id = (SELECT subject_id FROM colnod_token WHERE id = :tokenId)");
     query.bindValue(":tokenId", tokenId);
     if (mDbMan->executeQuery(query).next())

src/colnod/databaseapi.h

@@ -13,25 +13,7 @@
 #include "data.h"
 #include "serversdk/databasemanager.h"
 #include "serversdk/databasetable.h"
-
+#include "serversdk/databaseutils.h"
-
-// TODO: move to token class
-class TokenTable : public serversdk::DatabaseTable {
-    Q_OBJECT
-    TABLE_PROPERTY(QUuid, id, setId, QUuid())
-    TABLE_PROPERTY(int, authErorrs, setAuthErrors, 255)
-    TABLE_PROPERTY(QString, description, setDescription, "")
-    TABLE_PROPERTY(bool, enabled, setEnabled, true)
-    TABLE_PROPERTY(QDateTime, lastUpdate, setLastUpdate, QDateTime())
-    TABLE_PROPERTY(QString, name, setName, "")
-    TABLE_PROPERTY(bool, noValidity, setNoValidity, true)
-    TABLE_PROPERTY(int, timeToLive, setTimeToLive, 255)
-    TABLE_PROPERTY(int, tokenBits, setTokenBits, 32)
-    TABLE_PROPERTY(QString, tokenType, setTokenType, "Token")
-    TABLE_PROPERTY(QUuid, subjectId, setSubjectId, QUuid())
-    TABLE_PROPERTY(QDateTime, lastModified, setLastModified, QDateTime())
-    TABLE_PROPERTY(bool, deleted, setDeleted, false)
-};
 
 class DatabaseAPI : public QObject
 {
@@ -45,18 +27,19 @@ public:
     void processData(std::shared_ptr<Data> data);
     qint64 getLastSync();
     void setLastSync(qint64 timestamp);
-    void setLastUpdate(QHash<QUuid, std::shared_ptr<Token> > tokens);
+    void setLastUpdate(QHash<QString, std::shared_ptr<Token> > tokens);
     qint64 getNow();
 
     void initNewTokens();
 
     // process data
-    void uploadTokens(QHash<QUuid, std::shared_ptr<Token>> tokens);
+    void uploadTokens(QHash<QString, std::shared_ptr<Token> > tokens);
-    void uploadSubjects(QHash<QUuid, std::shared_ptr<Subject>> subjects);
+    void uploadSubjects(QHash<QString, std::shared_ptr<Subject> > subjects);
-    void deleteTokens(QList<QString> ids);
+    void deleteItems(QList<QString> ids, const QString &tableName);
-    void deleteSubjects(QList<QString> ids);
 
 private:
+    bool exists(const QString &id, const QString &tableName);
+
     QSqlQuery getUpdatedTokens();
     std::shared_ptr<Data> composeData(QSqlQuery updatedQuery, QSqlQuery deletedQuery);
     qint16 getNumOfTokensOfSubject(const QString &id);
@@ -69,7 +52,7 @@ signals:
 
 private:
     serversdk::DatabaseManager *mDbMan = nullptr;
-
+    std::unique_ptr<serversdk::DatabaseUtils> utils;
 
 
 

src/colnod/requestmanager.cpp

@@ -150,7 +150,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, std::shared_ptr<T
     QJsonArray jsonTokens;
     for (const auto& token : tokens)
     {
-        jsonTokens.push_back(token->toJSON());
+        //jsonTokens.push_back(token->toJSON());
     }
     items.insert("items", jsonTokens);
     QJsonDocument doc;

src/colnod/subject.cpp

@@ -9,53 +9,33 @@ Subject::Subject(const QString &name)
     setName(name);
 }
 
-QString Subject::getEmail() const {
+QByteArray Subject::jsonData() const
-    return attributes["email"].toString();
+{
+
 }
 
-void Subject::fromJSON(const QJsonObject &json) {
+bool Subject::fromJson(const QByteArray &data)
-    Entity::fromJSON(json);
+{
 
-    attributes = json["attributes"].toObject()["items"].toObject();
+    QJsonDocument doc = QJsonDocument::fromJson(data);
-    for (const auto & attributeType : attributeTypes)
+    QJsonObject attr = doc.object()["attributes"].toObject()["items"].toObject();
-    {
+    auto id = doc.object()["id"].toString();
-        if (!attributes[attributeType].toString().isEmpty()){
+
-            atr.append(qMakePair(attributeType, attributes[attributeType].toString()));
+    for (auto key : attr.keys()) {
-        }
+        auto newAtr = std::make_shared<SubjectAttribute>();
-    }
+        newAtr->setSubjectId(id);
-    const auto &tokenFlagsArray = json["tokenFlags"].toArray();
+        newAtr->setAttributeKey(key);
-    for(const auto &flag : tokenFlagsArray){
+        newAtr->setAttributeValue(attr.value(key).toString());
-        tokenFlags.insert(flag.toString());
+        attributes.append(newAtr);
     }
+    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
 
-    pin = json["pin"].toString();
+    // Populate this object data
-
+    bool res = fromVariantMap(variant);
-    const auto &pinFlagsArray = json["pinFlags"].toArray();
+    return res;
-    for(const auto &flag : pinFlagsArray){
-        pinFlags.insert(flag.toString());
-    }
 
 }
 
-QJsonObject Subject::toJSON() const {
-    QJsonObject json = Entity::toJSON();
-
-    QJsonObject items({{"items", attributes}});
-    json["atributes"] = items;
-    json["tokenFlags"] = QJsonArray::fromStringList(tokenFlags.toList());
-    json["pin"] = pin;
-    json["pinFlags"] = QJsonArray::fromStringList(pinFlags.toList());
-
-    return json;
-}
-
-const QJsonObject &Subject::getAttributes() const {
-    return attributes;
-}
-
-void Subject::setAttributes(const QJsonObject &attributes) {
-    Subject::attributes = attributes;
-}
 
 const QSet<QString> &Subject::getTokenFlags() const {
     return tokenFlags;
@@ -65,14 +45,6 @@ void Subject::setTokenFlags(const QSet<QString> &tokenFlags) {
     Subject::tokenFlags = tokenFlags;
 }
 
-const QString &Subject::getPin() const {
-    return pin;
-}
-
-void Subject::setPin(const QString &pin) {
-    Subject::pin = pin;
-}
-
 const QSet<QString> &Subject::getPinFlags() const {
     return pinFlags;
 }

src/colnod/subject.h

@@ -6,17 +6,36 @@
 #include <QDebug>
 #include <QPointer>
 #include <QPair>
+#include <QDateTime>
+#include "serversdk/databasetable.h"
+#include <qjsondocument.h>
+
+class SubjectAttribute : public serversdk::DatabaseTable {
+    Q_OBJECT
+    TABLE_PROPERTY(QString, id, setId, "")
+    TABLE_PROPERTY(QString, attributeKey, setAttributeKey, "")
+    TABLE_PROPERTY(QString, attributeValue, setAttributeValue, "")
+    TABLE_PROPERTY(QString, subjectId, setSubjectId, "")
+};
+
+
+class Subject : public serversdk::DatabaseTable {
+    Q_OBJECT
+    TABLE_PROPERTY(QString, id, setId, QString())
+    TABLE_PROPERTY(QString, description, setDescription, "")
+    TABLE_PROPERTY(QDateTime, lastUpdate, setLastUpdate, QDateTime())
+    TABLE_PROPERTY(QString, name, setName, "")
+    TABLE_PROPERTY(QString, pin, setP, "")
+    TABLE_PROPERTY(QDateTime, lastModified, setLastModified, QDateTime())
+    TABLE_PROPERTY(bool, deleted, setDeleted, false)
 
 
-// TODO: make it inherited from serversdk::databaseTable
-class Subject : public Entity {
-// TODO: add all properties
 public:
-    using Entity::Entity;
     Subject() = default;
     explicit Subject(const QString& name);
 
-    QString getEmail() const;
+    QByteArray jsonData() const override;
+    bool fromJson(const QByteArray &data) override;
 
     const QJsonObject &getAttributes() const;
     void setAttributes(const QJsonObject &attributes);
@@ -30,12 +49,9 @@ public:
     const QList<QPair<QString, QString>> &getAtr() const;
     void setAtr(const QList<QPair<QString, QString>> &atr);
 
-    void fromJSON(const QJsonObject &json) override;
-    QJsonObject toJSON() const override;
 private:
-    QJsonObject attributes;
+    QList<std::shared_ptr <SubjectAttribute>> attributes;
     QSet<QString> tokenFlags;
-    QString pin;
     QSet<QString> pinFlags;
     QList<QPair<QString, QString>> atr;
     const QList<QString> attributeTypes = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"};

src/colnod/syncmanager.cpp

@@ -2,14 +2,14 @@
 
 bool SyncManager::init()
 {
+    database = std::make_shared<DatabaseAPI>(&dbMan);
 
     if (database->open()){
         mlastSync.set_timestamp(database->getLastSync());
 
         colnod = std::make_shared<ColnodAPI>(&reqMan, mlastSync.timestamp());
-        database = std::make_shared<DatabaseAPI>(&dbMan);
-        // -1 --> some error with getting data from DB
 
+        // -1 --> some error with getting data from DB
         if (mlastSync.timestamp() >= 0){
             return true;
         }
@@ -51,13 +51,13 @@ void SyncManager::prepareData()
     colnodDataToProcess = std::make_shared<Data>(*colnodData);
     databaseDataToProcess = std::make_shared<Data>(*databaseData);
 
-    QList<QUuid> idsToDelete;
+    QList<QString> idsToDelete;
 
     for (const auto &colnodToken : colnodDataToProcess->updatedTokens) {
-        if (databaseDataToProcess->updatedTokens.contains(colnodToken->getId())) {
+        if (databaseDataToProcess->updatedTokens.contains(colnodToken->id())) {
                         // which change was later                                                           // if last_update in Colnod and DB equels -> already synced
-            if (databaseDataToProcess->updatedTokens.value(colnodToken->getId()) > colnodToken || databaseDataToProcess->updatedTokens.value(colnodToken->getId()) == colnodToken)
+            if (databaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken || databaseDataToProcess->updatedTokens.value(colnodToken->id()) == colnodToken)
-                idsToDelete.append(colnodToken->getId());
+                idsToDelete.append(colnodToken->id());
         }
     }
     for (const auto &id : idsToDelete)
@@ -65,9 +65,9 @@ void SyncManager::prepareData()
     idsToDelete.clear();
 
     for (const auto &databaseToken : databaseDataToProcess->updatedTokens) {
-        if (colnodDataToProcess->updatedTokens.contains(databaseToken->getId())) {
+        if (colnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
-            if (databaseToken > colnodDataToProcess->updatedTokens.value(databaseToken->getId()))
+            if (databaseToken > colnodDataToProcess->updatedTokens.value(databaseToken->id()))
-                idsToDelete.append(databaseToken->getId());
+                idsToDelete.append(databaseToken->id());
         }
     }
     for (const auto &id : idsToDelete)
@@ -94,7 +94,7 @@ void SyncManager::updateLastUpdate(qint64 syncBegin)
 
 void SyncManager::areDataReady()
 {
-    if (++dataAmount)
+    if (++dataAmount == 2)
         emit dataReady();
 }
 

src/colnod/token.cpp

@@ -8,9 +8,9 @@
 Token::Token(const QString& name, QString tokenData, const QString& decription)
 {
     this->setName(name);
-    this->tokenData = std::move(tokenData);
+    this->setTokenData(tokenData);
     this->setDescription(decription);
-    this->setId(QUuid::createUuid());
+    this->setId(QUuid::createUuid().toString().mid(1, 36));
 }
 
 Token::Token(const QString &name)
@@ -22,44 +22,13 @@ Token::~Token()
 = default;
 
 
-void Token::fromJSON(const QJsonObject &json) {
+QByteArray Token::tokensToJSON(const QHash<QString, std::shared_ptr<Token>> &tokens)
-    Entity::fromJSON(json);
-
-    tokenType = json["tokenType"].toString();
-    tokenBits = json["tokenBits"].toInt();
-    tokenData = json["tokenData"].toString();
-    timeToLive = json["timeToLive"].toInt();
-    authErrors = json["authErrors"].toInt();
-    const auto &flagsArray = json["flags"].toArray();
-    flags.clear();
-    for(const auto &flag : flagsArray){
-        flags.insert(flag.toString());
-    }
-    subjectId = json["subjectId"].toString();
-}
-
-QJsonObject Token::toJSON() const {
-    QJsonObject json = Entity::toJSON();
-    json.insert("tokenType", tokenType);
-    json["tokenBits"] = tokenBits;
-    json["tokenType"] = tokenType;
-    json["tokenBits"] = tokenBits;
-    json["tokenData"] = tokenData;
-    json["timeToLive"] = timeToLive;
-    json["authErrors"] = authErrors;
-    json["flags"] = QJsonArray::fromStringList(flags.toList());
-    json["subjectId"] = subjectId.toString().mid(1,36);
-
-    return json;
-}
-
-QByteArray Token::tokensToJSON(const QHash<QUuid, std::shared_ptr<Token>> &tokens)
 {
     QJsonObject items;
     QJsonArray jsonTokens;
     for (const auto& token : tokens)
     {
-        jsonTokens.push_back(token->toJSON());
+        //jsonTokens.push_back(token->toJSON());
     }
     items.insert("items", jsonTokens);
     QJsonDocument doc;
@@ -67,6 +36,46 @@ QByteArray Token::tokensToJSON(const QHash<QUuid, std::shared_ptr<Token>> &token
     return doc.toJson();
 }
 
+QByteArray Token::jsonData() const
+{
+    auto variantMap = this->toVariantMap();
+    auto enabled = variantMap["enabled"].toBool();
+    auto noValidity = variantMap["noValidity"].toBool();
+    variantMap.remove("enabled");
+    variantMap.remove("noValidity");
+    QVariantList flags;
+    if ( enabled ) {
+        flags << "Enabled";
+    }
+    if ( noValidity ) {
+        flags << "NoValidity";
+    }
+    variantMap.insert("flags", flags);
+
+    QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
+    return doc.toJson(QJsonDocument::Compact);
+}
+bool Token::fromJson(const QByteArray &data)
+{
+    QJsonDocument doc = QJsonDocument::fromJson(data);
+    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
+
+    QVariantList flags = variant["flags"].toList();
+    for (auto value : flags) {
+        if ( value.toString() == "Enabled") {
+            variant.insert("enabled", true);
+        }
+        if ( value.toString() == "NoValidity") {
+            variant.insert("noValidity", true);
+        }
+    }
+    variant.remove("flags");
+
+    // Populate this object data
+    bool res = fromVariantMap(variant);
+    return res;
+}
+
 QByteArray Token::idsToJSON(const QList<QString> &ids)
 {
     QJsonArray jsonIds;
@@ -83,84 +92,37 @@ QByteArray Token::idsToJSON(const QList<QString> &ids)
 
 void Token::fromSQLRecord(const QSqlQuery& query)
 {
-    setId(query.value(0).toUuid());
+    setId(query.value(0).toString());
-    authErrors = query.value(1).toInt();
+    a_authErrors = query.value(1).toInt();
     setDescription(query.value(2).toString());
     QSet<QString> flags;
     if (query.value(6).toBool())
         flags.insert("NoValidity");
     if (query.value(3).toBool())
         flags.insert("Enabled");
-    this->flags = flags;
+    //this->flags = flags;
     QDateTime date = query.value(4).toDateTime();
-    setLastUpdate(date.toMSecsSinceEpoch());
+    setLastUpdate(date);          // WARNING: resolve how lastUpdate should me stored
     setName(query.value(5).toString());
-    timeToLive = query.value(7).toInt();
+    a_timeToLive = query.value(7).toInt();
-    tokenBits = query.value(8).toInt();
+    a_tokenBits = query.value(8).toInt();
-    tokenData = query.value(9).toString();
+    a_tokenData = query.value(9).toString();
-    tokenType = query.value(10).toString();
+    a_tokenType = query.value(10).toString();
-    subjectId = query.value(11).toUuid();
+    a_subjectId = query.value(11).toString();
     date = query.value(12).toDateTime();
-    setLastModified(date.toMSecsSinceEpoch());
+    setLastModified(date);
     setDeleted(query.value(13).toBool());
 }
 
-const QString &Token::getTokenType() const {
+//void Token::setFlags(const QSet<QString> &flags) {
-    return tokenType;
+//    Token::flags = flags;
-}
+//}
 
-void Token::setTokenType(const QString &tokenType) {
+//QString Token::idToStringWithoutBraces()
-    Token::tokenType = tokenType;
+//{
-}
+//    return a_id.toString().mid(1, 36);
+//}
 
-int Token::getTokenBits() const {
+//QString Token::subjectIdToStringWithoutBraces(){
-    return tokenBits;
+//    return a_subjectId.toString().mid(1,36);
-}
+//}
-
-void Token::setTokenBits(int tokenBits) {
-    Token::tokenBits = tokenBits;
-}
-
-const QString &Token::getTokenData() const {
-    return tokenData;
-}
-
-void Token::setTokenData(const QString &tokenData) {
-    Token::tokenData = tokenData;
-}
-
-int Token::getTimeToLive() const {
-    return timeToLive;
-}
-
-void Token::setTimeToLive(int timeToLive) {
-    Token::timeToLive = timeToLive;
-}
-
-int Token::getAuthErrors() const {
-    return authErrors;
-}
-
-void Token::setAuthErrors(int authErrors) {
-    Token::authErrors = authErrors;
-}
-
-const QSet<QString> &Token::getFlags() const {
-    return flags;
-}
-
-void Token::setFlags(const QSet<QString> &flags) {
-    Token::flags = flags;
-}
-
-const QUuid &Token::getSubjectId() const {
-    return subjectId;
-}
-
-void Token::setSubjectId(const QUuid &subjectId) {
-    Token::subjectId = subjectId;
-}
-
-QString Token::subjectIdToStringWithoutBraces(){
-    return subjectId.toString().mid(1,36);
-}

src/colnod/token.h

@@ -6,15 +6,28 @@
 #include <QVariant>
 #include <QDebug>
 #include <QDateTime>
+#include "serversdk/databasetable.h"
+#include <QJsonArray>
 
 
-// TODO: make it inherited from serversdk::databaseTable
+class Token : public serversdk::DatabaseTable {
-class Token : public Entity {
+    Q_OBJECT
+    TABLE_PROPERTY(QString, id, setId, QString())
+    TABLE_PROPERTY(int, authErrors, setAuthErrors, 255)
+    TABLE_PROPERTY(QString, description, setDescription, "")
+    TABLE_PROPERTY(bool, enabled, setEnabled, true)
+    TABLE_PROPERTY(QDateTime, lastUpdate, setLastUpdate, QDateTime())
+    TABLE_PROPERTY(QString, name, setName, "")
+    TABLE_PROPERTY(bool, noValidity, setNoValidity, true)
+    TABLE_PROPERTY(int, timeToLive, setTimeToLive, 255)
+    TABLE_PROPERTY(int, tokenBits, setTokenBits, 32)
+    TABLE_PROPERTY(QString, tokenData, setTokenData, QString())
+    TABLE_PROPERTY(QString, tokenType, setTokenType, "Token")
+    TABLE_PROPERTY(QString, subjectId, setSubjectId, QString())
+    TABLE_PROPERTY(QDateTime, lastModified, setLastModified, QDateTime())
+    TABLE_PROPERTY(bool, deleted, setDeleted, false)
 
-    // TODO: add all properties
 public:
-    // using Entity::Entity;
-
     /**
         * # Needed values to proper sync
         *
@@ -30,58 +43,44 @@ public:
     explicit Token(const QString& name);
     ~Token() override;
 
+    QByteArray jsonData() const override;
+    bool fromJson(const QByteArray &data) override;
+
     friend bool operator<(const Token &lToken, const Token &rToken){
-        return lToken.getLastModified() < rToken.getLastUpdate();
+        return lToken.lastModified() < rToken.lastUpdate();
     }
     friend bool operator>(const Token &lToken, const Token &rToken){
-        return lToken.getLastModified() > rToken.getLastUpdate();
+        return lToken.lastModified() > rToken.lastUpdate();
     }
     friend bool operator==(const Token &lToken, const Token &rToken){
-        return lToken.getId() == rToken.getId() &&
+        return lToken.id() == rToken.id() &&
-                lToken.getName() == rToken.getName() &&
+                lToken.name() == rToken.name() &&
-                lToken.getDescription() == rToken.getDescription() &&
+                lToken.description() == rToken.description() &&
-                lToken.getLastUpdate() == rToken.getLastUpdate() &&
+                lToken.lastUpdate() == rToken.lastUpdate() &&
-                lToken.tokenType == rToken.tokenType &&
+                lToken.tokenType() == rToken.tokenType() &&
-                lToken.tokenBits == rToken.tokenBits &&
+                lToken.tokenBits() == rToken.tokenBits() &&
-                lToken.tokenData == rToken.tokenData &&
+                lToken.tokenData() == rToken.tokenData() &&
-                lToken.timeToLive == rToken.timeToLive &&
+                lToken.timeToLive() == rToken.timeToLive() &&
-                lToken.authErrors == rToken.authErrors &&
+                lToken.authErrors() == rToken.authErrors() &&
-                lToken.flags == rToken.flags &&
+                lToken.noValidity() == rToken.noValidity() &&
-                lToken.subjectId == rToken.subjectId;
+                lToken.enabled() == rToken.enabled() &&
+                lToken.subjectId() == rToken.subjectId();
     }
 
 
-    const QString &getTokenType() const;
-    void setTokenType(const QString &tokenType);
-    int getTokenBits() const;
-    void setTokenBits(int tokenBits);
-    const QString &getTokenData() const;
-    void setTokenData(const QString &tokenData);
-    int getTimeToLive() const;
-    void setTimeToLive(int timeToLive);
-    int getAuthErrors() const;
-    void setAuthErrors(int authErrors);
     const QSet<QString> &getFlags() const;
     void setFlags(const QSet<QString> &flags);
-    const QUuid &getSubjectId() const;
-    void setSubjectId(const QUuid &subjectId);
-
 
+    QString idToStringWithoutBraces();
     QString subjectIdToStringWithoutBraces();
 
     void fromSQLRecord(const QSqlQuery& query);
-    void fromJSON(const QJsonObject &json) override;
+    void fromJSON(const QJsonObject &json);
-    QJsonObject toJSON() const override;
+    QJsonObject toJSON() const;
 
-    static QByteArray tokensToJSON(const QHash<QUuid, std::shared_ptr<Token> > &tokens);
+    static QByteArray tokensToJSON(const QHash<QString, std::shared_ptr<Token> > &tokens);
     static QByteArray idsToJSON(const QList<QString> &ids);
 
 private:
-    QString tokenType = "Token";
+    //QSet<QString> flags = {"NoValidity", "Enabled"};
-    int tokenBits = 32;
-    QString tokenData;
-    int timeToLive = 255;
-    int authErrors = 255;
-    QSet<QString> flags = {"NoValidity", "Enabled"};
-    QUuid subjectId;
 };

test/unitTests/UnitTest.cpp

@@ -217,7 +217,7 @@ void UnitTest::setTokens()
 
     QHash<QString, std::shared_ptr<Token>> tokens;
     auto token = getTestToken();
-    tokens.insert(token->idToStringWithoutBraces(), token);
+    tokens.insert(token->id(), token);
     RequestManager testAccess;
     QSignalSpy spy(&testAccess, &RequestManager::responseReady);
     Response* response = testAccess.setTokens(tokens);
@@ -257,9 +257,9 @@ void UnitTest::subjectJSONParser()
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray arr = doc.object()["items"].toArray();
     Subject testSubject;
-    testSubject.fromJSON(arr[1].toObject());
+    //testSubject.fromJSON(arr[1].toObject());
-    qDebug() << testSubject.getName() << " Size:  " << arr.size();
+    //qDebug() << testSubject.getName() << " Size:  " << arr.size();
-    QVERIFY(!testSubject.getName().isEmpty());
+    //QVERIFY(!testSubject.getName().isEmpty());
     response->deleteLater();
 }
 
@@ -273,9 +273,9 @@ void UnitTest::tokenJSONParser()
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray arr = doc.object()["items"].toArray();
     Token testToken;
-    testToken.fromJSON(arr[5].toObject());
+    //testToken.fromJSON(arr[5].toObject());
-    qDebug() << testToken.getName() << " Size:  " << arr.size();
+    //qDebug() << testToken.getName() << " Size:  " << arr.size();
-    QVERIFY(!testToken.getName().isEmpty());
+    //QVERIFY(!testToken.getName().isEmpty());
     response->deleteLater();
 }
 
@@ -296,7 +296,7 @@ std::shared_ptr<Token> UnitTest::getTestToken()
     jsonToken.insert("flags", flags);
     jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904");
     auto token = std::make_shared<Token>();
-    token->fromJSON(jsonToken);
+   //token->fromJSON(jsonToken);
     return token;
 }
 

test/unitTests/complextest.cpp

@@ -195,7 +195,7 @@ std::shared_ptr<Token> ComplexTest::getTestToken()
     jsonToken.insert("flags", flags);
     jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904");
     auto token = std::shared_ptr<Token>();
-    token->fromJSON(jsonToken);
+    //token->fromJSON(jsonToken);
     return token;
 }