ondra/colnod-connector
1
0
Fork 1
mirror of https://gitlab.com/spaceti-app/integrations/acs/colnod-connector.git synced 2026-07-12 14:30:50 +02:00
Code Issues Projects Releases Wiki Activity

Change token and subject to inherit from databaseTable

Browse Source
This commit is contained in:
Ondřej Fischer 2019-11-18 17:07:39 +01:00
parent ee07e06032
commit fc52975b61
15 changed files with 264 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server-sdk

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

20
src/colnod/colnodapi.cpp
View File

@ -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);
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);
}
data->loadTokensFromJson(responseData);
}
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);
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);
}
data->loadSubjectsFormJson(responseData);
}
void ColnodAPI::saveDeletedSubjects(const QByteArray &responseData)

2
src/colnod/colnodapi.h
View File

@ -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

24
src/colnod/data.cpp
View File

@ -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);
}
}

6
src/colnod/data.h
View File

@ -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;
};

76
src/colnod/databaseapi.cpp
View File

@ -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);
deleteSubjects(data->deletedSubjects);
deleteItems(data->deletedTokens, "colnod_token");
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(":id", token->idToStringWithoutBraces());
query.bindValue(":last_update", token->lastUpdate());
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());
token->setName(getSubjectNameByTokenId(token->idToStringWithoutBraces()) + "_mobile_" + QString::number(num + 1));
qint16 num = getNumOfTokensOfSubject(token->subjectId());
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())

33
src/colnod/databaseapi.h
View File

@ -13,25 +13,7 @@
#include "data.h"
#include "serversdk/databasemanager.h"
#include "serversdk/databasetable.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)
};
#include "serversdk/databaseutils.h"
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 uploadSubjects(QHash<QUuid, std::shared_ptr<Subject>> subjects);
void deleteTokens(QList<QString> ids);
void deleteSubjects(QList<QString> ids);
void uploadTokens(QHash<QString, std::shared_ptr<Token> > tokens);
void uploadSubjects(QHash<QString, std::shared_ptr<Subject> > subjects);
void deleteItems(QList<QString> ids, const QString &tableName);
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;

2
src/colnod/requestmanager.cpp
View File

@ -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;

66
src/colnod/subject.cpp
View File

@ -9,53 +9,33 @@ Subject::Subject(const QString &name)
setName(name);
}
QString Subject::getEmail() const {
return attributes["email"].toString();
QByteArray Subject::jsonData() const
{
}
void Subject::fromJSON(const QJsonObject &json) {
Entity::fromJSON(json);
bool Subject::fromJson(const QByteArray &data)
{
attributes = json["attributes"].toObject()["items"].toObject();
for (const auto & attributeType : attributeTypes)
{
if (!attributes[attributeType].toString().isEmpty()){
atr.append(qMakePair(attributeType, attributes[attributeType].toString()));
}
}
const auto &tokenFlagsArray = json["tokenFlags"].toArray();
for(const auto &flag : tokenFlagsArray){
tokenFlags.insert(flag.toString());
QJsonDocument doc = QJsonDocument::fromJson(data);
QJsonObject attr = doc.object()["attributes"].toObject()["items"].toObject();
auto id = doc.object()["id"].toString();
for (auto key : attr.keys()) {
auto newAtr = std::make_shared<SubjectAttribute>();
newAtr->setSubjectId(id);
newAtr->setAttributeKey(key);
newAtr->setAttributeValue(attr.value(key).toString());
attributes.append(newAtr);
}
QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
pin = json["pin"].toString();
const auto &pinFlagsArray = json["pinFlags"].toArray();
for(const auto &flag : pinFlagsArray){
pinFlags.insert(flag.toString());
}
// Populate this object data
bool res = fromVariantMap(variant);
return res;
}
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;
}

34
src/colnod/subject.h
View File

@ -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"};

20
src/colnod/syncmanager.cpp
View File

@ -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)
idsToDelete.append(colnodToken->getId());
if (databaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken || databaseDataToProcess->updatedTokens.value(colnodToken->id()) == colnodToken)
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 (databaseToken > colnodDataToProcess->updatedTokens.value(databaseToken->getId()))
idsToDelete.append(databaseToken->getId());
if (colnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
if (databaseToken > colnodDataToProcess->updatedTokens.value(databaseToken->id()))
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();
}

166
src/colnod/token.cpp
View File

@ -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) {
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)
QByteArray Token::tokensToJSON(const QHash<QString, 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());
authErrors = query.value(1).toInt();
setId(query.value(0).toString());
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();
tokenBits = query.value(8).toInt();
tokenData = query.value(9).toString();
tokenType = query.value(10).toString();
subjectId = query.value(11).toUuid();
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.toMSecsSinceEpoch());
setLastModified(date);
setDeleted(query.value(13).toBool());
}
const QString &Token::getTokenType() const {
return tokenType;
}
//void Token::setFlags(const QSet<QString> &flags) {
// Token::flags = flags;
//}
void Token::setTokenType(const QString &tokenType) {
Token::tokenType = tokenType;
}
//QString Token::idToStringWithoutBraces()
//{
// return a_id.toString().mid(1, 36);
//}
int Token::getTokenBits() const {
return tokenBits;
}
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);
}
//QString Token::subjectIdToStringWithoutBraces(){
// return a_subjectId.toString().mid(1,36);
//}

81
src/colnod/token.h
View File

@ -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 Entity {
class Token : public serversdk::DatabaseTable {
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() &&
lToken.getName() == rToken.getName() &&
lToken.getDescription() == rToken.getDescription() &&
lToken.getLastUpdate() == rToken.getLastUpdate() &&
lToken.tokenType == rToken.tokenType &&
lToken.tokenBits == rToken.tokenBits &&
lToken.tokenData == rToken.tokenData &&
lToken.timeToLive == rToken.timeToLive &&
lToken.authErrors == rToken.authErrors &&
lToken.flags == rToken.flags &&
lToken.subjectId == rToken.subjectId;
return lToken.id() == rToken.id() &&
lToken.name() == rToken.name() &&
lToken.description() == rToken.description() &&
lToken.lastUpdate() == rToken.lastUpdate() &&
lToken.tokenType() == rToken.tokenType() &&
lToken.tokenBits() == rToken.tokenBits() &&
lToken.tokenData() == rToken.tokenData() &&
lToken.timeToLive() == rToken.timeToLive() &&
lToken.authErrors() == rToken.authErrors() &&
lToken.noValidity() == rToken.noValidity() &&
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;
QJsonObject toJSON() const override;
void fromJSON(const QJsonObject &json);
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";
int tokenBits = 32;
QString tokenData;
int timeToLive = 255;
int authErrors = 255;
QSet<QString> flags = {"NoValidity", "Enabled"};
QUuid subjectId;
//QSet<QString> flags = {"NoValidity", "Enabled"};
};

16
test/unitTests/UnitTest.cpp
View File

@ -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());
qDebug() << testSubject.getName() << " Size: " << arr.size();
QVERIFY(!testSubject.getName().isEmpty());
//testSubject.fromJSON(arr[1].toObject());
//qDebug() << testSubject.getName() << " Size: " << arr.size();
//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());
qDebug() << testToken.getName() << " Size: " << arr.size();
QVERIFY(!testToken.getName().isEmpty());
//testToken.fromJSON(arr[5].toObject());
//qDebug() << testToken.getName() << " Size: " << arr.size();
//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;
}

2
test/unitTests/complextest.cpp
View File

@ -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;
}