michalks/colnod-connector
1
0
Fork 0
forked from ondra/colnod-connector
Code Issues Pull Requests Projects Releases Wiki Activity

erase useless staff, also started adding output

Browse Source
This commit is contained in:
Ondřej Fischer 2019-11-20 16:02:23 +01:00
parent 3684e089f9
commit 0eafa20283
28 changed files with 113 additions and 2216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/app/main.cpp
View File

@ -1,13 +1,19 @@
#include <QCoreApplication> #include <QCoreApplication>
#include "datamanager.h"
#include "syncmanager.h" #include "syncmanager.h"
#include <QCommandLineParser> #include <QCommandLineParser>
#include "serversdk/requestmanager.h" #include "serversdk/requestmanager.h"
#include "serversdk/request.h" #include "serversdk/request.h"
#include "serversdk/logger.h"
#include "serversdk/core.h"
#include "colnodapi.h" #include "colnodapi.h"
constexpr auto equels = R"(==================================================================)";
constexpr auto underScore = R"(__________________________________________________________________)";
constexpr auto dash = R"(------------------------------------------------------------------)";
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
QCoreApplication app(argc, argv); QCoreApplication app(argc, argv);
@ -24,6 +30,15 @@ int main(int argc, char *argv[])
parser.process(app); parser.process(app);
// ======== LOGGER ==============
serversdk::initAppLogger(); // <-- then Logger::outputMessage will handle all messages
// Log messge Filtering
QStringList filters;
filters << "qt.*=false";
filters << "sdk.core.*=true";
//filters << "*=false";
QLoggingCategory::setFilterRules(filters.join(QStringLiteral("\n")));
SyncManager api; SyncManager api;
// TODO: handle error in init // TODO: handle error in init

10
src/colnod/colnod.pri
View File

@ -7,11 +7,6 @@ SOURCES += \
$$PWD/colnodapi.cpp \ $$PWD/colnodapi.cpp \
$$PWD/data.cpp \ $$PWD/data.cpp \
$$PWD/databaseapi.cpp \ $$PWD/databaseapi.cpp \
$$PWD/datamanager.cpp \
$$PWD/entity.cpp \
$$PWD/logger.cpp \
$$PWD/requestmanager.cpp \
$$PWD/response.cpp \
$$PWD/subject.cpp \ $$PWD/subject.cpp \
$$PWD/syncmanager.cpp \ $$PWD/syncmanager.cpp \
$$PWD/token.cpp $$PWD/token.cpp
@ -20,11 +15,6 @@ HEADERS += \
$$PWD/colnodapi.h \ $$PWD/colnodapi.h \
$$PWD/data.h \ $$PWD/data.h \
$$PWD/databaseapi.h \ $$PWD/databaseapi.h \
$$PWD/datamanager.h \
$$PWD/entity.h \
$$PWD/logger.h \
$$PWD/requestmanager.h \
$$PWD/response.h \
$$PWD/subject.h \ $$PWD/subject.h \
$$PWD/syncmanager.h \ $$PWD/syncmanager.h \
$$PWD/token.h $$PWD/token.h

10
src/colnod/colnodapi.cpp
View File

@ -1,5 +1,7 @@
#include "colnodapi.h" #include "colnodapi.h"
Q_LOGGING_CATEGORY(colnod, "colnod.api");
ColnodAPI::ColnodAPI() ColnodAPI::ColnodAPI()
{ {
} }
@ -185,6 +187,14 @@ void ColnodAPI::setUserName(const QString &userName)
void ColnodAPI::areDataReady() void ColnodAPI::areDataReady()
{ {
if (++amountData == 4) { if (++amountData == 4) {
qDebug(colnod) << "COLNOD DATA:";
qDebug(colnod) << TAB << data->updatedTokens.size() << "TOKENS TO UPDATE";
qDebug(colnod) << TAB << data->deletedTokens.size() << "TOKENS TO DELETE";
qDebug(colnod) << TAB << data->updatedSubjects.size() << "SUBJECTS TO UPDATE";
qDebug(colnod) << TAB << data->deletedSubjects.size() << "SUBJECTS TO DELETE";
qDebug(colnod) << UNDERSCORE << endl;
emit downloadDataFinished(data); emit downloadDataFinished(data);
newData(); newData();
} }

4
src/colnod/colnodapi.h
View File

@ -3,9 +3,11 @@
#include "serversdk/requestmanager.h" #include "serversdk/requestmanager.h"
#include "serversdk/request.h" #include "serversdk/request.h"
#include "serversdk/databasetable.h" #include "serversdk/databasetable.h"
#include "QDateTime" #include "serversdk/logger.h"
#include "data.h" #include "data.h"
Q_DECLARE_LOGGING_CATEGORY(colnod)
class LoginResp : public serversdk::DatabaseTable { class LoginResp : public serversdk::DatabaseTable {
Q_OBJECT Q_OBJECT
TABLE_PROPERTY(QString, username, set_username, "") TABLE_PROPERTY(QString, username, set_username, "")

2
src/colnod/data.cpp
View File

@ -21,7 +21,6 @@ void Data::loadTokensFromJson(const QByteArray &data)
auto token = std::make_shared<Token>(); auto token = std::make_shared<Token>();
doc.setObject(item.toObject()); doc.setObject(item.toObject());
token->fromJson(doc.toJson()); token->fromJson(doc.toJson());
//token->setDeleted(false);
updatedTokens.insert(token->id(), token); updatedTokens.insert(token->id(), token);
} }
} }
@ -34,7 +33,6 @@ void Data::loadSubjectsFormJson(const QByteArray &data)
auto subject = std::make_shared<Subject>(); auto subject = std::make_shared<Subject>();
doc.setObject(item.toObject()); doc.setObject(item.toObject());
subject->fromJson(doc.toJson()); subject->fromJson(doc.toJson());
subject->setDeleted(false);
updatedSubjects.insert(subject->id(), subject); updatedSubjects.insert(subject->id(), subject);
} }
} }

5
src/colnod/data.h
View File

@ -3,6 +3,11 @@
#include "token.h" #include "token.h"
#include "subject.h" #include "subject.h"
// constants for output design
#define EQUALS "=================================================================="
#define UNDERSCORE "__________________________________________________________________"
#define DASH "------------------------------------------------------------------"
#define TAB "\t"
class Data class Data
{ {

331
src/colnod/databaseapi.cpp
View File

@ -1,6 +1,8 @@
#include "databaseapi.h" #include "databaseapi.h"
#include "logger.h"
Q_LOGGING_CATEGORY(database, "db.api");
#define STH 803
DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan) DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan)
:mDbMan(dbMan), utils(std::make_unique<serversdk::DatabaseUtils>(dbMan)) :mDbMan(dbMan), utils(std::make_unique<serversdk::DatabaseUtils>(dbMan))
@ -34,10 +36,6 @@ void DatabaseAPI::processData(std::shared_ptr<Data> data)
deleteItems(data->deletedSubjects, "colnod_subject"); deleteItems(data->deletedSubjects, "colnod_subject");
} }
std::shared_ptr<Data> DatabaseAPI::composeData(QSqlQuery updatedQuery, QSqlQuery deletedQuery) std::shared_ptr<Data> DatabaseAPI::composeData(QSqlQuery updatedQuery, QSqlQuery deletedQuery)
{ {
auto data = std::make_shared<Data>(); auto data = std::make_shared<Data>();
@ -49,6 +47,13 @@ std::shared_ptr<Data> DatabaseAPI::composeData(QSqlQuery updatedQuery, QSqlQuery
while (deletedQuery.next()) { while (deletedQuery.next()) {
data->deletedTokens.append(deletedQuery.value(0).toString()); data->deletedTokens.append(deletedQuery.value(0).toString());
} }
qDebug(database) << "DATABASE DATA:";
qDebug(database) << TAB << data->updatedTokens.size() << "TOKENS TO UPDATE";
qDebug(database) << TAB << data->deletedTokens.size() << "TOKENS TO DELETE";
qDebug(database) << DASH ;
return data; return data;
} }
@ -125,6 +130,8 @@ void DatabaseAPI::uploadSubjects(QHash<QString, std::shared_ptr<Subject>> subjec
// TODO: // TODO:
auto query = mDbMan->createQuery(); auto query = mDbMan->createQuery();
for (const auto &subject : subjects) { for (const auto &subject : subjects) {
// TODO: attributes
// NOTE: about actions
if (exists(subject->id(), "colnod_subject")) { if (exists(subject->id(), "colnod_subject")) {
query = utils->updateTable(subject.get(), "colnod_subject"); query = utils->updateTable(subject.get(), "colnod_subject");
} }
@ -172,11 +179,6 @@ bool DatabaseAPI::exists(const QString &id, const QString &tableName)
return query.next(); return query.next();
} }
qint16 DatabaseAPI::getNumOfTokensOfSubject(const QString &id) qint16 DatabaseAPI::getNumOfTokensOfSubject(const QString &id)
{ {
auto query = mDbMan->createQuery(); auto query = mDbMan->createQuery();
@ -195,312 +197,3 @@ QString DatabaseAPI::getSubjectNameByTokenId(const QString &tokenId)
qWarning() << "Token:" << tokenId << "is not assigned to any subject"; qWarning() << "Token:" << tokenId << "is not assigned to any subject";
return "(No subject)"; return "(No subject)";
} }
// OLD
//DatabaseAPI::DatabaseAPI(const QString& host, const QString& dbName, const QString& user, const QString& password, const bool &dryMode)
// :dryMode(dryMode)
//{
// db = QSqlDatabase::addDatabase("QPSQL");
// db.setDatabaseName(dbName);
// db.setHostName(host);
// db.setUserName(user); // home-office stuff -->> db.setPort(80);
// db.setPassword(password);
// if (!db.open())
// {
// opened = false;
// Logger::log("Opening error" + db.lastError().text());
// emit error();
// }
// else{
// opened = true;
// }
//}
//// add or update subject to db
//int DatabaseAPI::saveSubject(const std::shared_ptr<Subject>& subject, const QString& table)
//{
// QSqlQuery query;
// QString id = subject->idToStringWithoutBraces();
// int rtn;
// if (checkIfExists(id, table)){
// query.prepare(QString("UPDATE %1 SET id = :id, description = :description, last_update = :last_update, name = :name, pin = :pin, last_modified = :last_modified, deleted = :deleted "
// "WHERE id = :id").arg(table));
// rtn = -1;
// }else{
// query.prepare(QString("INSERT INTO %1 (id, description, last_update, name, pin, last_modified, deleted) "
// "VALUES (:id, :description, :last_update, :name, :pin, :last_modified, :deleted)").arg(table));
// rtn = 1;
// }
// query.bindValue(":id", id);
// query.bindValue(":description", subject->getDescription());
// query.bindValue(":name", subject->getName());
// query.bindValue(":last_update", QDateTime::fromMSecsSinceEpoch(subject->getLastUpdate()).toString("yyyy-MM-dd hh:mm:ss.zzz"));
// query.bindValue(":pin", subject->getPin());
// query.bindValue(":last_modified", QDateTime::fromMSecsSinceEpoch(subject->getLastUpdate()).toString("yyyy-MM-dd hh:mm:ss.zzz"));
// query.bindValue(":deleted", subject->getDeleted());
// executeQuery(query);
// return rtn;
//}
//QSqlQuery DatabaseAPI::getUpdatedTokens()
//{
// QSqlQuery query;
// executeQuery(query, "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 EXTRACT(EPOCH FROM last_modified) * 1000 > EXTRACT(EPOCH FROM last_update) * 1000 AND deleted = false");
// return query;
//}
//// add or update token to DB
//int DatabaseAPI::saveToken(const std::shared_ptr<Token>& token, const QString& table)
//{
// QSqlQuery query;
// QString id = token->idToStringWithoutBraces();
// int rtn;
// if (checkIfExists(id, table)){
// query.prepare(QString("UPDATE %1 SET id = :id, auth_errors = :auth_errors, description = :description, enabled = :enabled, last_update = :last_update, name = :name, no_validity = :no_validity, time_to_live = :time_to_live, token_bits = :token_bits, token_data = :token_data, token_type = :token_type, subject_id = :subject_id, last_modified = :last_modified, deleted = :deleted "
// "WHERE id = :id").arg(table));
// rtn = -1;
// }else{
// query.prepare(QString("INSERT INTO %1 (id, auth_errors, description, enabled, last_update, name, no_validity, time_to_live, token_bits, token_data, token_type, subject_id, last_modified, deleted) "
// "VALUES (:id, :auth_errors, :description, :enabled, :last_update, :name, :no_validity, :time_to_live, :token_bits, :token_data, :token_type, :subject_id, :last_modified, :deleted)").arg(table));
// rtn = 1;
// }
// query.bindValue(":id", id);
// query.bindValue(":auth_errors", token->getAuthErrors());
// query.bindValue(":description", token->getDescription());
// query.bindValue(":enabled", token->getFlags().contains("Enabled"));
// query.bindValue(":last_update", QDateTime::fromMSecsSinceEpoch(token->getLastUpdate()).toString("yyyy-MM-dd hh:mm:ss.zzz"));
// query.bindValue(":name", token->getName());
// query.bindValue(":no_validity", token->getFlags().contains("NoValidity"));
// query.bindValue(":time_to_live", token->getTimeToLive());
// query.bindValue(":token_bits", token->getTokenBits());
// query.bindValue(":token_data", token->getTokenData());
// query.bindValue(":token_type", token->getTokenType());
// query.bindValue(":subject_id", token->subjectIdToStringWithoutBraces());
// query.bindValue(":last_modified", QDateTime::fromMSecsSinceEpoch(token->getLastUpdate()).toString("yyyy-MM-dd hh:mm:ss.zzz"));
// query.bindValue(":deleted", token->getDeleted());
// executeQuery(query);
// return rtn;
//}
//// add of update subject attributes
//void DatabaseAPI::saveSubjectAttributes(const std::shared_ptr<Subject>& subject, const QString& table)
//{
// QSqlQuery query;
// auto attributes = subject->getAtr();
// for (const auto& attribute : attributes){
// QString id = subject->idToStringWithoutBraces() + " " + attribute.first;
// if (checkIfExists(id, table)){
// query.prepare(QString("UPDATE %1 SET id = :id, attribute_key = :key, attribute_value = :value, subject_id = :subject_id) "
// "WHERE id = :id").arg(table));
// }else{
// query.prepare(QString("INSERT INTO %1 (id, attribute_key, attribute_value, subject_id)"
// "VALUES (:id, :key, :value, :subject_id)").arg(table));
// }
// query.bindValue(":id", id);
// query.bindValue(":key", attribute.first);
// query.bindValue(":value", attribute.second);
// query.bindValue(":subject_id", subject->idToStringWithoutBraces());
// executeQuery(query);
// }
//}
//// "delete" tokens from DB -> set deleted true
//void DatabaseAPI::setDeleted(const QString& id, const QString& table, quint64 time)
//{
// QSqlQuery query;
// QString nowString = QDateTime::fromMSecsSinceEpoch(time).toString("yyyy-MM-dd hh:mm:ss.zzz");
// query.prepare(QString("UPDATE %1 SET deleted = true, last_update = :now, last_modified = :now WHERE id = :id").arg(table));
// query.bindValue(":id", id);
// query.bindValue(":now", nowString);
// executeQuery(query);
//}
//bool DatabaseAPI::checkIfExists(const QString& id, const QString& table)
//{
// QSqlQuery query;
// query.prepare(QString("SELECT EXISTS(SELECT 1 FROM %1 WHERE id = :id)").arg(table));
// query.bindValue(":id", id);
// executeQuery(query);
// query.first();
// return query.value(0).toBool();
//}
//QString DatabaseAPI::getLastQuery(const QSqlQuery& query) const
//{
// QString str = query.lastQuery();
// QMapIterator<QString, QVariant> it(query.boundValues());
// while (it.hasNext())
// {
// it.next();
// str.replace(it.key(),it.value().toString());
// }
// return str;
//}
//bool DatabaseAPI::executeQuery(QSqlQuery &query, const QString &statement)
//{
// if (statement.isEmpty()){
// if (dryMode){
// QString sqlStatement = getLastQuery(query);
// qDebug() << sqlStatement;
// }
// if (!dryMode || getLastQuery(query).startsWith("SELECT")){
// if (!query.exec()){
// QString msg = QString("Source: Database Manager, Error: %1").arg(query.lastError().text());
// Logger::logToDb(QString(msg));
// emit error();
// }
// }
// return true;
// }
// if (dryMode){
// qDebug() << statement;
// }
// if (!dryMode || statement.startsWith("SELECT")){
// if (!query.exec(statement)){
// QString msg = QString("Source: Database Manager, Error: %1").arg(query.lastError().text());
// Logger::logToDb(QString(msg));
// emit error();
// }
// }
// return true;
//}
//void DatabaseAPI::dropTables()
//{
// QSqlQuery query;
// executeQuery(query, "DROP TABLE IF EXISTS colnod_token, colnod_subject, colnod_subject_attribute");
//}
//// create table after deleting, it is used for full sync
//void DatabaseAPI::createTables()
//{
// QSqlQuery query;
// executeQuery(query, "CREATE TABLE colnod_subject ("
// "id character(36) primary key NOT NULL,"
// "description character varying(255),"
// "last_update timestamp NOT NULL,"
// "name character varying(255),"
// "pin character varying(255),"
// "last_modified timestamp,"
// "deleted BOOLEAN)");
// executeQuery(query, "CREATE TABLE colnod_token ("
// "id CHAR(36) primary key NOT NULL,"
// "auth_errors INTEGER DEFAULT 255,"
// "description VARCHAR(255),"
// "enabled BOOLEAN DEFAULT true,"
// "last_update timestamp DEFAULT '1970-01-01 00:00:00'::timestamp without time zone,"
// "name VARCHAR(255),"
// "no_validity BOOLEAN DEFAULT true,"
// "time_to_live INTEGER DEFAULT 255,"
// "token_bits INTEGER DEFAULT 32,"
// "token_data VARCHAR(255),"
// "token_type VARCHAR(255) DEFAULT 'Token'::character varying,"
// "subject_id CHAR(36),"
// "last_modified timestamp NOT NULL,"
// "deleted BOOLEAN DEFAULT false)");
// executeQuery(query, "CREATE TABLE colnod_subject_attribute ("
// "id VARCHAR(255) primary key,"
// "attribute_key VARCHAR(255),"
// "attribute_value VARCHAR(255),"
// "subject_id CHAR(36))");
//}
//// on the very end of sync set new Last_sync time (begin of this sync)
//// return set of tokens to update form DB
//QSqlQuery DatabaseAPI::getToken(const QString& id)
//{
// QSqlQuery query;
// query.prepare("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 id = :id");
// query.bindValue(":id", id);
// executeQuery(query);
// query.next();
// return query;
//}
//// sync last update back to DB from Colnod after changes made to Colnod
//void DatabaseAPI::log(const QString &msg)
//{
// QSqlQuery query;
// query.prepare("INSERT INTO logs (log_time, msg) VALUES (NOW(), :msg)");
// query.bindValue(":msg", msg);
// query.exec();
//}
//QString DatabaseAPI::getSubjectNameByTokenId(const QString &tokenId)
//{
// QSqlQuery query;
// query.prepare("SELECT name FROM colnod_subject WHERE id = (SELECT subject_id FROM colnod_token WHERE id = :tokenId)");
// query.bindValue(":tokenId", tokenId);
// executeQuery(query);
// if (query.next())
// return query.value(0).toString();
// qWarning() << "Token:" << tokenId << "is not assigned to any subject";
// return "(No subject)";
//}
//QString DatabaseAPI::getSubjectNameById(const QString &id)
//{
// QSqlQuery query;
// query.prepare("SELECT name FROM colnod_subject WHERE id = :id");
// query.bindValue(":id", id);
// executeQuery(query);
// if (query.next())
// return query.value(0).toString();
// qWarning() << "Subject:" << id << "doesn't exists";
// return "(No subject)";
//}
//bool DatabaseAPI::checkDeletedToken(const QString &id)
//{
// QSqlQuery query;
// query.prepare("SELECT deleted FROM colnod_token WHERE id = :id");
// query.bindValue(":id", id);
// executeQuery(query);
// query.next();
// return query.value(0).toBool();
//}
//bool DatabaseAPI::isOpen()
//{
// return opened;
//}

58
src/colnod/databaseapi.h
View File

@ -1,19 +1,15 @@
#pragma once #pragma once
#include <QSql> #include <QSql>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QVariant>
#include <QDebug>
#include "subject.h"
#include "token.h"
#include <QDateTime>
#include "data.h" #include "data.h"
#include "serversdk/databasemanager.h" #include "serversdk/databasemanager.h"
#include "serversdk/databasetable.h" #include "serversdk/databasetable.h"
#include "serversdk/databaseutils.h" #include "serversdk/databaseutils.h"
#include "serversdk/logger.h"
Q_DECLARE_LOGGING_CATEGORY(database)
class DatabaseAPI : public QObject class DatabaseAPI : public QObject
{ {
@ -50,53 +46,7 @@ private:
signals: signals:
void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>()); void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());
private: private:
serversdk::DatabaseManager *mDbMan = nullptr; serversdk::DatabaseManager *mDbMan = nullptr;
std::unique_ptr<serversdk::DatabaseUtils> utils; std::unique_ptr<serversdk::DatabaseUtils> utils;
// old
// DatabaseAPI(const QString& host, const QString& dbName, const QString& user, const QString& password, const bool& dryMode = false);
// int saveSubject(const std::shared_ptr<Subject>& subject, const QString& table);
// int saveToken(const std::shared_ptr<Token>& token, const QString& table);
// void saveSubjectAttributes(const std::shared_ptr<Subject>& subject, const QString& table);
// void setDeleted(const QString& id, const QString& table, quint64 time);
// void dropTables();
// void createTables();
// void updateLastSync(quint64 lastSync);
// QSqlQuery getToken(const QString& id);
// void setLastUpdate(const QString& id, quint64 lastUpdate);
// void log(const QString &msg);
// QString getSubjectNameById(const QString &id);
// bool checkDeletedToken(const QString &id);
// bool isOpen();
//private:
// bool checkIfExists(const QString& id, const QString& table);
// bool executeQuery(QSqlQuery &query, const QString &statement = QString());
// QString getLastQuery(const QSqlQuery &query) const;
//signals:
// void error();
//private:
// QSqlDatabase db;
// bool dryMode = false;
// bool opened = false;
}; };

372
src/colnod/datamanager.cpp
View File

@ -1,372 +0,0 @@
#include "datamanager.h"
//DataManager::DataManager(const bool &dryMode) :
// db(std::make_shared<DatabaseAPI>("192.168.1.94", "deloitte", "postgres", "34rjkciea12", dryMode)),
// dryMode(dryMode)
//{
// if (db->isOpen()){
// Logger::setDBMan(db);
// nextLastSync = db->getNow();
// lastSync = db->getLastSync();
// }
// connect(db.get(), &DatabaseAPI::error, this, &DataManager::error, Qt::QueuedConnection);
//}
//// load all tokens from colnod to comparing with working set from DB
//void DataManager::fillFullTokensColnod(const QString& response)
//{
// QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
// QJsonArray items = doc.object()["items"].toArray();
// if (!items.empty())
// {
// for (QJsonValueRef item : items){
// auto token = std::make_shared<Token>();
// token->fromJSON(item.toObject());
// allTokensFromColnodById.insert(token->idToStringWithoutBraces(), token);
// allTokensFromColnodByName.insert(token->getName(), token);
// }
// }
// else{
// qCritical() << "Colnod is Empty";
// }
//}
//// load working set with updated tokens from Colnod
//void DataManager::fillTokensToUpdateColnod(const QString& response)
//{
// QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
// QJsonArray items = doc.object()["items"].toArray();
// if (!items.empty())
// {
// for (QJsonValueRef item : items)
// {
// auto token = std::make_shared<Token>();
// token->fromJSON(item.toObject());
// token->setDeleted(false);
// tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
// }
// qInfo() << "Colnod:" << tokensToUpdateFromColnodToDB.size() << "tokens to update";
// }
// else
// {
// qInfo() << "Colnod: 0 tokens to update";
// }
//}
//// load working set with updated subjects from Colnod
//void DataManager::fillSubjectsToUpdateColnod(const QString& response)
//{
// QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
// QJsonArray items = doc.object()["items"].toArray();
// if (!items.empty())
// {
// for (QJsonValueRef item : items)
// {
// auto subject = std::make_shared<Subject>();
// subject->fromJSON(item.toObject());
// subject->setDeleted(false);
// subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
// }
// qInfo() << "Colnod:" << subjectsToUpdateFromColnodToDB.size() << "subjects to update";
// }
// else
// {
// qInfo() << "Colnod:" << "0 subjects to update";
// }
//}
//// load working sets with updated/deleted tokens from DB
//void DataManager::fillTokensToChangeDB()
//{
// if (db->isOpen()){
// QSqlQuery query = db->getUpdatedTokens();
// while (query.next())
// {
// auto token = std::make_shared<Token>();
// token->fromSQLRecord(query);
// if (token->getName() == NULL){
// qint16 num = db->getNumOfTokensOfSubject(token->subjectIdToStringWithoutBraces());
// token->setName(db->getSubjectNameByTokenId(token->idToStringWithoutBraces()) + "_mobile_" + QString::number(num + 1));
// token->setDescription("mobile");
// token->setLastUpdate(token->getLastModified());
// db->saveToken(token, "colnod_token");
// }
// if (token->getDeleted()){ // sort to delete / to update
// tokensFromDBToDeleteFromColnod.append(token->idToStringWithoutBraces());
// }
// else{
// tokensToUpdateFromDBToColnod.insert(token->idToStringWithoutBraces(), token);
// }
// }
// qDebug() << "DB:" << tokensToUpdateFromDBToColnod.size() << "tokens to update";
// qDebug() << "DB:" << tokensFromDBToDeleteFromColnod.size() << "tokens to delete";
// }
// else
// emit error();
//}
//void DataManager::fillSubjectsToUpdateDB()
//{
// // Not needed yet
//}
//// load working set with subjest to delete from Colnod
//void DataManager::fillSubjectsToDeleteColnod(const QString& json)
//{
// QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
// QJsonArray items = doc.object()["items"].toArray();
// if (!items.empty())
// {
// for (QJsonValueRef item : items) {
// subjectsFromColnodToDeleteFromDB.append(item.toString());
// }
// qInfo() << "Colnod:" << subjectsFromColnodToDeleteFromDB.size() << "subjects to delete";
// }
// else {
// qInfo() << "Colnod: 0 subjects to delete";
// }
//}
//// load working set with tokens to delete from DB
//void DataManager::fillTokensToDeleteColnod(const QString& json)
//{
// QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
// QJsonArray items = doc.object()["items"].toArray();
// if (!items.empty())
// {
// for (QJsonValueRef item : items) {
// tokensFromColnodToDeleteFromDB.append(item.toString());
// }
// qInfo() << "Colnod:" << tokensFromColnodToDeleteFromDB.size() << "tokens to delete";
// }
// else {
// qInfo() << "Colnod: 0 tokens to delete";
// }
//}
//void DataManager::fillSubjectsToDeleteDB()
//{
// // Not needed yet
//}
//// update subjects from colnod to DB
//void DataManager::pushSubjectsToDB()
//{
// if (subjectsToUpdateFromColnodToDB.isEmpty()) {
// qInfo() << "DB: 0 subjects added";
// qInfo() << "DB: 0 subjects updated";
// return;
// }
// int updated = 0;
// int added = 0;
// for (const auto& subject : subjectsToUpdateFromColnodToDB)
// {
// if (db->saveSubject(subject, "colnod_subject") > 0){
// added++;
// if (dryMode)
// qInfo() << "Adding subject:" << subject->idToStringWithoutBraces() << "to DB";
// else
// Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"added", "DB"));
// }
// else{
// updated++;
// if (dryMode)
// qInfo() << "Updating subject:" << subject->idToStringWithoutBraces() << "to DB";
// else
// Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"updated", "DB"));
// }
// db->saveSubjectAttributes(subject, "colnod_subject_attribute");
// }
// qInfo() << "DB:" << added << "subjects added";
// qInfo() << "DB:" << updated << "subjects updated";
//}
//// update tokens from colnod to DB
//void DataManager::pushTokensToDB()
//{
// if (tokensToUpdateFromColnodToDB.isEmpty()){
// qInfo() << "DB: 0 tokens added";
// qInfo() << "DB: 0 tokens updated";
// return;
// }
// filterTokensColnod();
// int updated = 0;
// int added = 0;
// for (const auto& token : tokensToUpdateFromColnodToDB)
// {
// QString text;
// // 1 = adding token
// // -1 = updating token
// if (db->saveToken(token, "colnod_token") == 1){
// added++;
// text = "Added";
// }
// else {
// updated++;
// text = "Updating";
// }
// if (dryMode)
// qInfo() << text << "token:" << token->idToStringWithoutBraces() << "to DB";
// else
// Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), text, "DB"));
// }
// qInfo() << "DB:" << added << "tokens added/edited";
// qInfo() << "DB:" << updated << "tokens updated";
//}
//void DataManager::deleteSubjectsFromDB()
//{
// if (subjectsFromColnodToDeleteFromDB.isEmpty())
// {
// qInfo() << "DB: 0 subjects deleted";
// return;
// }
// for (const auto& subjectId : subjectsFromColnodToDeleteFromDB)
// {
// db->setDeleted(subjectId, "colnod_subject", nextLastSync);
// if (dryMode)
// qInfo() << "Deleting subject:" << subjectId << "from DB";
// else
// Logger::logToDb(Logger::makeSubjectMsg(subjectId, "deleted", "DB"));
// }
// qInfo() << "DB:" << subjectsFromColnodToDeleteFromDB.size() << " subject deleted";
//}
//// "delete" (set deleted true) tokens in DB depends on Colnod
//void DataManager::setDeletedToTokensFromDB()
//{
// if (tokensFromColnodToDeleteFromDB.isEmpty())
// {
// qDebug() << "DB: 0 tokens deleted";
// return;
// }
// int alreadyDeleted = 0;
// for (const auto& tokenId : tokensFromColnodToDeleteFromDB)
// {
// if (!db->checkDeletedToken(tokenId)){
// db->setDeleted(tokenId, "colnod_token", nextLastSync);
// if (dryMode)
// qInfo() << "Deleting token:" << tokenId << "from DB";
// else
// Logger::logToDb(Logger::makeTokenMsg(tokenId, "deleted", "DB"));
// }
// else
// alreadyDeleted++;
// }
// qDebug() << "DB:" << tokensFromColnodToDeleteFromDB.size() - alreadyDeleted << "tokens deleted";
//}
//// recreate working tables
//void DataManager::dropTables()
//{
// if (db->isOpen()){
// db->dropTables();
// }
// else{
// emit error();
// }
//}
//void DataManager::createTables()
//{
// if (db->isOpen()){
// db->createTables();
// db->updateLastSync(0);
// }
// else{
// emit error();
// }
//}
//quint64 DataManager::getLastModifiedOfToken(const QString &id)
//{
// auto record = db->getToken(id);
// auto token = std::make_shared<Token>();
// token->fromSQLRecord(record);
// return token->getLastModified();
//}
////clear all structures
//void DataManager::clear()
//{
// subjectsToUpdateFromColnodToDB.clear();
// subjectsFromColnodToDeleteFromDB.clear();
// tokensToUpdateFromColnodToDB.clear();
// tokensFromColnodToDeleteFromDB.clear();
// //subjectsDB.clear(); // not need yet
// // subjectsToDeleteDB.clear(); // not need yet
// tokensToUpdateFromDBToColnod.clear();
// tokensFromDBToDeleteFromColnod.clear();
// allTokensFromColnodById.clear();
//}
//// on the very end of sync update last sync time to begin time of this sync
//void DataManager::updateLastSync()
//{
// if (db->isOpen())
// db->updateLastSync(nextLastSync);
//}
//// these to filter functions solve colision tokens -> remove when change on this token is earlier then change on the same token on the other side (Colnod/DB)
//void DataManager::filterTokensDB()
//{
// QList<QString> idsToDelete;
// for (const auto& token : tokensToUpdateFromDBToColnod)
// {
// QString id = token->idToStringWithoutBraces();
// Q_ASSERT(token != allTokensFromColnodById.value(id)); // if working sets are loading correctly equels should never happend
// if (allTokensFromColnodById.contains(id) && *token < *allTokensFromColnodById.value(id))
// idsToDelete.append(id);
// if (allTokensFromColnodById.contains(id) && token->getLastModified() == allTokensFromColnodById.value(id)->getLastUpdate()){
// idsToDelete.append(id);
// qWarning() << "Same token has been edited in colnod and db in same time. Change from Colnod has been used";
// }
// if (allTokensFromColnodByName.contains(token->getName())){
// qWarning() << "Token:" << token->idToStringWithoutBraces() << "won't be added to Colnod, because token with the same name already exists, please change it manually";
// if (!dryMode){
// QString message = QString("Error: Token: %1 won't be added to Colnod, because token with the same name already exists, please change it manually").arg(token->idToStringWithoutBraces());
// Logger::logToDb(Logger::makeErrorMsg("Db", message));
// }
// }
// }
// for (const auto &id : idsToDelete)
// tokensToUpdateFromDBToColnod.remove(id);
//}
//void DataManager::filterTokensColnod()
//{
// QList<QString> idsToDelete;
// for (const auto &token : tokensToUpdateFromColnodToDB)
// {
// QString id = token->idToStringWithoutBraces();
// auto record = db->getToken(id);
// if (!record.isValid())
// continue;
// auto tokenDB = std::make_shared<Token>();
// tokenDB->fromSQLRecord(record);
// if (*tokenDB == *token || *tokenDB > *token){
// idsToDelete.append(id);
// }
// }
// for (const auto &id : idsToDelete)
// tokensToUpdateFromColnodToDB.remove(id);
//}
//// sync last update from colnod to DB
//void DataManager::setLastUpdate()
//{
// if (!tokensToUpdateFromColnodToDB.isEmpty())
// for (const auto &token : tokensToUpdateFromColnodToDB)
// db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
//}
//void DataManager::setLastUpdate(const QString &id)
//{
// db->setLastUpdate(id, nextLastSync);
//}

84
src/colnod/datamanager.h
View File

@ -1,84 +0,0 @@
#pragma once
#include "token.h"
#include "subject.h"
#include "requestmanager.h"
#include "databaseapi.h"
#include <QJsonDocument>
#include <qjsonarray.h>
#include <logger.h>
class DataManager : public QObject
{
Q_OBJECT
public:
explicit DataManager(const bool& dryMode = false);
void fillFullTokensColnod(const QString& jsonResponse);
void fillTokensToUpdateColnod(const QString& jsonResponse);
void fillSubjectsToUpdateColnod(const QString& jsonResponse);
void fillSubjectsToDeleteColnod(const QString& jsonResponse);
void fillTokensToDeleteColnod(const QString& jsonResponse);
void fillTokensToChangeDB();
void fillSubjectsToUpdateDB();
void fillSubjectsToDeleteDB();
void filterTokensDB();
void filterTokensColnod();
void pushSubjectsToDB();
void pushTokensToDB();
void deleteSubjectsFromDB();
void setDeletedToTokensFromDB();
void updateLastSync();
void dropTables();
void createTables();
quint64 getLastModifiedOfToken(const QString &id);
QHash<QString, std::shared_ptr<Token>> getTokensToUpdateFromColnod() {return tokensToUpdateFromColnodToDB;}
QList<QString> getTokensToDeleteColnod() {return tokensFromColnodToDeleteFromDB;}
QHash<QString, std::shared_ptr<Token>> getTokensToUpdateFromDB() {return tokensToUpdateFromDBToColnod;}
QList<QString> getTokensToDeleteDB() {return tokensFromDBToDeleteFromColnod;}
const quint64 &getLastSync() {return lastSync;}
const quint64 &getCurrentSync() {return nextLastSync;}
public slots:
// void clear();
// void setLastUpdate();
// void setLastUpdate(const QString &id);
signals:
// void error();
private:
std::shared_ptr<DatabaseAPI> db;
quint64 lastSync; // time of last run
quint64 nextLastSync; // time of begin of this run
QHash<QString, std::shared_ptr<Token>> allTokensFromColnodById;
QHash<QString, std::shared_ptr<Token>> allTokensFromColnodByName;
QHash<QString, std::shared_ptr<Subject>> subjectsToUpdateFromColnodToDB;
QHash<QString, std::shared_ptr<Token>> tokensToUpdateFromColnodToDB;
QHash<QString, std::shared_ptr<Subject>> subjectsDB; // in future
QHash<QString, std::shared_ptr<Token>> tokensToUpdateFromDBToColnod;
QList<QString> subjectsFromColnodToDeleteFromDB;
QList<QString> tokensFromColnodToDeleteFromDB;
QList<QString> subjectsToDeleteDB;
QList<QString> tokensFromDBToDeleteFromColnod;
bool dryMode = false;
};

76
src/colnod/entity.cpp
View File

@ -1,76 +0,0 @@
#include <QJsonObject>
#include "entity.h"
const QUuid &Entity::getId() const {
return id;
}
void Entity::setId(const QUuid &id) {
Entity::id = id;
}
const QString &Entity::getName() const {
return name;
}
void Entity::setName(const QString &name) {
Entity::name = name;
}
const QString &Entity::getDescription() const {
return description;
}
void Entity::setDescription(const QString &description) {
Entity::description = description;
}
qint64 Entity::getLastUpdate() const {
return lastUpdate;
}
void Entity::setLastUpdate(qint64 lastUpdate) {
this->lastUpdate = lastUpdate;
}
qint64 Entity::getLastModified() const {
return lastModified;
}
void Entity::setLastModified(const qint64 &lastModified) {
this->lastModified = lastModified;
}
bool Entity::getDeleted() const
{
return deleted;
}
void Entity::setDeleted(const bool &deleted)
{
this->deleted = deleted;
}
QString Entity::idToStringWithoutBraces() const
{
const qint8 lengthOfUuid = 36;
return id.toString().mid(1, lengthOfUuid);
}
void Entity::fromJSON(const QJsonObject &json) {
id = json["id"].toString();
name = json["name"].toString();
description = json["description"].toString();
lastUpdate = json["lastUpdate"].toDouble();
}
QJsonObject Entity::toJSON() const {
QJsonObject json;
json["id"] = this->idToStringWithoutBraces();
json["name"] = name;
json["description"] = description;
json["lastUpdate"] = lastUpdate;
return json;
}

48
src/colnod/entity.h
View File

@ -1,48 +0,0 @@
#pragma once
#include <QtCore/QObject>
#include <QtCore/QUuid>
#include <QtCore/QJsonObject>
#include <QDebug>
#include <memory>
// NOTE: it will be no longer useful
class Entity : public QObject {
Q_OBJECT
public:
explicit Entity() = default;
using QObject::QObject;
const QUuid &getId() const;
void setId(const QUuid &id);
const QString &getName() const;
void setName(const QString &name);
const QString &getDescription() const;
void setDescription(const QString &description);
qint64 getLastUpdate() const;
void setLastUpdate(qint64 lastUpdate);
qint64 getLastModified() const;
void setLastModified(const qint64 &lastModified);
bool getDeleted() const;
void setDeleted(const bool &deleted);
QString idToStringWithoutBraces() const;
virtual void fromJSON(const QJsonObject &json);
virtual QJsonObject toJSON() const;
private:
QUuid id;
QString name;
QString description;
qint64 lastUpdate{};
qint64 lastModified{};
bool deleted{};
};

54
src/colnod/logger.cpp
View File

@ -1,54 +0,0 @@
#include "logger.h"
#include "databaseapi.h"
#include <utility>
std::shared_ptr<DatabaseAPI> Logger::dbMan = nullptr;
Logger *Logger::logger = nullptr;
//Logger::Logger()
//{
// dbMan = nullptr;
//}
//Logger *Logger::getLogger()
//{
// if (!logger)
// logger = new Logger;
// return logger;
//}
//void Logger::log(const QString& msg)
//{
// qDebug() << msg;
//}
//void Logger::logToDb(const QString &msg)
//{
// if (dbMan)
// // Logger::dbMan->log(msg);
//}
//void Logger::setDBMan(std::shared_ptr<DatabaseAPI> dbMan)
//{
// Logger::dbMan = std::move(dbMan);
//}
//QString Logger::makeTokenMsg(const QString &tokenId, const QString &action, const QString &source)
//{
// return QString("Token: %1 of subject: %2 %3. Source: %4").arg(tokenId,dbMan->getSubjectNameByTokenId(tokenId), action, source);
//}
//QString Logger::makeSubjectMsg(const QString &subjectId, const QString &action, const QString &source)
//{
// return QString("Subject: %1 %2. Source: %3").arg(dbMan->getSubjectNameById(subjectId), action, source);
//}
//QString Logger::makeErrorMsg(const QString &source, const QString &errMsg)
//{
// return QString("Source: %1, Error: %2").arg(source, errMsg);
//}

33
src/colnod/logger.h
View File

@ -1,33 +0,0 @@
#pragma once
#include <QString>
#include <QDebug>
#include <QSqlDatabase>
#include <memory>
class DatabaseAPI;
class Logger
{
static Logger *logger;
Logger();
static std::shared_ptr<DatabaseAPI> dbMan;
public:
static Logger *getLogger();
static void log(const QString& msg);
static void logToDb(const QString& msg);
static void setDBMan(std::shared_ptr<DatabaseAPI> dbMan);
static QString makeTokenMsg(const QString& tokenId, const QString& action, const QString& source);
static QString makeSubjectMsg(const QString& subjectId, const QString& action, const QString& source);
static QString makeErrorMsg(const QString& source, const QString& errMsg);
private:
};

248
src/colnod/requestmanager.cpp
View File

@ -1,248 +0,0 @@
#include "requestmanager.h"
RequestManager::RequestManager()
: manager(std::make_unique<QNetworkAccessManager>())
{
connect(manager.get(), &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
}
std::shared_ptr<Response> RequestManager::login()
{
Q_ASSERT(!loginResponse);
loginResponse = std::make_shared<Response>();
QNetworkRequest request;
QString hash = encryptedPassword(this->password);
authHeader = getLoginHeader(this->user, hash);
QJsonObject reqBody = {
{"password", hash},
{"username", this->user}
};
request.setUrl(this->host + "/AaaManager/authSession");
qDebug() << authHeader.toLocal8Bit();
request.setRawHeader("Authorization", authHeader.toLocal8Bit());
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
QJsonDocument jsonDocument;
jsonDocument.setObject(reqBody);
QNetworkReply* reply = manager->post(request, jsonDocument.toJson());
loginResponse->setReply(reply);
connect(reply, &QNetworkReply::finished, [=]() {
if (reply->error())
{
//Logger::logToDb(Logger::makeErrorMsg("Request Manager", reply->errorString()));
loginStatus = false;
reply->deleteLater();
emit error();
return;
}
loginStatus = true;
emit successLogin();
reply->deleteLater();
});
connect(this, &RequestManager::successLogin, loginResponse.get(), &Response::ready);
connect(this, &RequestManager::successLogin, this, &RequestManager::prepareAuthHeader);
return loginResponse;
}
QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
{
QNetworkRequest request;
request.setUrl(host + endpoint);
request.setRawHeader("Authorization", authHeader.toLocal8Bit());
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
QNetworkReply* reply = manager->post(request, json);
QObject::connect(reply, &QNetworkReply::finished, [=]() {
if (reply->error())
{
//Logger::logToDb(Logger::makeErrorMsg("Request Manager", reply->errorString()));
loginStatus = false;
reply->deleteLater();
emit error();
return;
}
emit responseReady();
reply->deleteLater();
});
return reply;
}
// This will ensure login is called only once
std::shared_ptr<Response> RequestManager::getLoginResponse() {
if (!loginResponse){
loginResponse = login();
}
return loginResponse;
}
Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
{
auto loginResponse = getLoginResponse();
Q_ASSERT(loginResponse);
auto response = new Response;
if (!loginStatus){
connect(this, &RequestManager::successLogin, [=](){
response->setReply(postRequest(endpoint, data));
connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
});
}
else
{
response->setReply(postRequest(endpoint, data));
connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
}
return response;
}
// get value of member in json
QString RequestManager::getFromJson(const QString& json, const QString &member)
{
QJsonParseError err{};
QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
if (err.error != 0)
{
qDebug() << err.errorString();
}
return document.object().value(member).toString();
}
QString RequestManager::encryptedPassword(const QString& password)
{
return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
}
QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
{
QString authValue = username + ":" + hash;
return "Basic " + authValue.toLocal8Bit().toBase64();
}
void RequestManager::prepareAuthHeader()
{
jsonResponse = loginResponse->getJson();
QString token = getFromJson(jsonResponse, "id");
QString authValue = token + ":";
authHeader = "Basic " + authValue.toLocal8Bit().toBase64();
}
void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &errors)
{
//qDebug() << "Network SSL errors";
for (const auto &error : errors)
{
if (error.error() == QSslError::SelfSignedCertificate)
reply->ignoreSslErrors(errors);
//qDebug() << error.errorString();
}
}
QByteArray RequestManager::makeTimestampJson(uint64_t time)
{
QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }};
QJsonDocument doc;
doc.setObject(reqBody);
return doc.toJson();
}
QByteArray RequestManager::makeTokensJson(const QHash<QString, std::shared_ptr<Token>> &tokens)
{
QJsonObject items;
QJsonArray jsonTokens;
for (const auto& token : tokens)
{
//jsonTokens.push_back(token->toJSON());
}
items.insert("items", jsonTokens);
QJsonDocument doc;
doc.setObject(items);
return doc.toJson();
}
QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
{
QJsonArray jsonIds;
for (const auto& id : ids)
{
jsonIds.push_back(id);
}
QJsonObject items;
items.insert("items", jsonIds);
QJsonDocument doc;
doc.setObject(items);
return doc.toJson();
}
Response* RequestManager::getSubjects()
{
return postRequestReturnLogic("/SubjectManager/getSubjects");
}
Response* RequestManager::getTokens()
{
return postRequestReturnLogic("/TokenManager/getTokens");
}
Response* RequestManager::getTokenSubject()
{
return postRequestReturnLogic("/OpenManager/getTokenSubject");
}
Response* RequestManager::getSubjectsUpdated(uint64_t time)
{
return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(time));
}
Response* RequestManager::getSubjectsDeleted(uint64_t time)
{
return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimestampJson(time));
}
Response* RequestManager::getTokensUpdated(uint64_t time)
{
return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
}
Response* RequestManager::getTokensDeleted(uint64_t time)
{
return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroups()
{
return postRequestReturnLogic("/AccessManager/getAccessGroups");
}
Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroupMembership()
{
return postRequestReturnLogic("/AccessManager/getAccessGroupMembership");
}
Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimestampJson(time));
}
Response* RequestManager::setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
{
return postRequestReturnLogic("/TokenManager/setTokens", makeTokensJson(tokens));
}
Response* RequestManager::deleteTokens(const QList<QString> &ids)
{
return postRequestReturnLogic("/TokenManager/deleteTokens", makeIdsJson(ids));
}

100
src/colnod/requestmanager.h
View File

@ -1,100 +0,0 @@
#pragma once
#include <QObject>
#include <QNetworkReply>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QJsonDocument>
#include <QJsonObject>
#include <qcoreapplication.h>
#include <qnetworkreply.h>
#include <QByteArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonParseError>
#include <QFile>
#include <QString>
#include <QMultiMap>
#include <QPointer>
#include <QDir>
#include <QSslError>
#include <QPair>
#include "token.h"
#include "response.h"
#include "logger.h"
class RequestManager : public QObject
{
Q_OBJECT
public:
friend class UnitTest;
friend class ComplexTest;
RequestManager();
// this should be in ColnodAPI class BEGIN
Response* getSubjects();
Response* getTokens();
Response* getTokenSubject();
Response* getSubjectsUpdated(uint64_t time);
Response* getSubjectsDeleted(uint64_t time);
Response* getTokensUpdated(uint64_t time);
Response* getTokensDeleted(uint64_t time);
Response* getAccessGroups();
Response* getAccessGroupsUpdated(uint64_t time);
Response* getAccessGroupsDeleted(uint64_t time);
Response* getAccessGroupMembership();
Response* getAccessGroupMembershipUpdated(uint64_t time);
Response* getAccessGroupMembershipDeleted(uint64_t time);
Response* setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens);
Response* deleteTokens(const QList<QString> &ids);
// END
private:
// should be public
QNetworkReply* postRequest(const QString& endpoint, const QByteArray& json = QByteArray());
Response* postRequestReturnLogic(const QString& endpoint, const QByteArray& data = QByteArray());
std::shared_ptr<Response> login();
std::shared_ptr<Response> getLoginResponse();
QString getFromJson(const QString& json, const QString &member);
QString encryptedPassword(const QString& password);
QString getLoginHeader(const QString& username, const QString& hash);
// in colnod api as well
QByteArray makeTimestampJson(uint64_t time);
QByteArray makeTokensJson(const QHash<QString, std::shared_ptr<Token>> &tokens); // maybe better to be in Token class
QByteArray makeIdsJson(const QList<QString> &ids); // Entity class
private slots:
void onSSLError(QNetworkReply *reply, const QList<QSslError> &errors);
//void onReplyFinished(QNetworkReply *reply);
void prepareAuthHeader();
signals:
void successLogin();
void responseReady();
void error();
private:
std::unique_ptr<QNetworkAccessManager> manager;
std::shared_ptr<Response> loginResponse;
QJsonDocument config;
QString authHeader;
const QString host = "https://192.168.1.3:8443";
//QString host = "https://localhost:8080";
const QString password = "spaceti1";
const QString user = "spaceti";
QString jsonResponse;
bool loginStatus = false;
};

11
src/colnod/response.cpp
View File

@ -1,11 +0,0 @@
#include "response.h"
Response::Response()
{
connect(this, &Response::ready, this, &Response::setJson);
}
int Response::getStatusCode()
{
return reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
}

32
src/colnod/response.h
View File

@ -1,32 +0,0 @@
#pragma once
#include <QObject>
#include <qnetworkreply.h>
class Response : public QObject
{
Q_OBJECT
public:
Response();
int getStatusCode();
QString getJson() {return json;}
void setReply(QNetworkReply* rpl) {reply = rpl;}
QNetworkReply* getReply() {return reply;}
public:
signals:
void ready();
private slots:
void setJson() {json = reply->readAll();}
private:
QString json;
QNetworkReply *reply = nullptr;
};

30
src/colnod/subject.cpp
View File

@ -1,9 +1,5 @@
#include <utility>
#include "subject.h" #include "subject.h"
#include <QJsonArray>
Subject::Subject(const QString &name) Subject::Subject(const QString &name)
{ {
setName(name); setName(name);
@ -28,30 +24,4 @@ bool Subject::fromJson(const QByteArray &data)
// Populate this object data // Populate this object data
bool res = fromVariantMap(variant); bool res = fromVariantMap(variant);
return res; return res;
} }
//const QSet<QString> &Subject::getTokenFlags() const {
// return tokenFlags;
//}
//void Subject::setTokenFlags(const QSet<QString> &tokenFlags) {
// Subject::tokenFlags = tokenFlags;
//}
//const QSet<QString> &Subject::getPinFlags() const {
// return pinFlags;
//}
//void Subject::setPinFlags(const QSet<QString> &pinFlags) {
// Subject::pinFlags = pinFlags;
//}
//const QList<QPair<QString, QString>> &Subject::getAtr() const {
// return atr;
//}
//void Subject::setAtr(const QList<QPair<QString, QString>> &atr) {
// this->atr = atr;
//}

26
src/colnod/subject.h
View File

@ -1,14 +1,9 @@
#pragma once #pragma once
#include <QSet>
#include "entity.h"
#include <QDebug>
#include <QPointer>
#include <QPair>
#include <QDateTime> #include <QDateTime>
#include "serversdk/databasetable.h" #include "serversdk/databasetable.h"
#include <qjsondocument.h> #include <qjsondocument.h>
#include <QJsonObject>
class SubjectAttribute : public serversdk::DatabaseTable { class SubjectAttribute : public serversdk::DatabaseTable {
Q_OBJECT Q_OBJECT
@ -36,25 +31,6 @@ public:
bool fromJson(const QByteArray &data) override; bool fromJson(const QByteArray &data) override;
// const QJsonObject &getAttributes() const;
// void setAttributes(const QJsonObject &attributes);
// const QSet<QString> &getTokenFlags() const;
// void setTokenFlags(const QSet<QString> &tokenFlags);
// const QString &getPin() const;
// void setPin(const QString &pin);
// const QSet<QString> &getPinFlags() const;
// void setPinFlags(const QSet<QString> &pinFlags);
// const QList<QPair<QString, QString>> &getAtr() const;
// void setAtr(const QList<QPair<QString, QString>> &atr);
private: private:
QList<std::shared_ptr <SubjectAttribute>> attributes; QList<std::shared_ptr <SubjectAttribute>> attributes;
QSet<QString> tokenFlags;
QSet<QString> pinFlags;
QList<QPair<QString, QString>> atr;
const QList<QString> attributeTypes = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"};
}; };

268
src/colnod/syncmanager.cpp
View File

@ -1,5 +1,10 @@
#include "syncmanager.h" #include "syncmanager.h"
Q_LOGGING_CATEGORY(syncmanager, "sync.manager");
bool SyncManager::init() bool SyncManager::init()
{ {
database = std::make_shared<DatabaseAPI>(&dbMan); database = std::make_shared<DatabaseAPI>(&dbMan);
@ -21,8 +26,10 @@ void SyncManager::run()
{ {
qint64 syncBegin = database->getNow(); qint64 syncBegin = database->getNow();
database->initNewTokens(); database->initNewTokens();
downloadData(); downloadData();
connect(this, &SyncManager::dataReady, [=](){ connect(this, &SyncManager::dataReady, [=](){
qDebug(syncmanager) << "FINISH";
prepareData(); prepareData();
connect(this, &SyncManager::dataProcessFinished, [=](){ connect(this, &SyncManager::dataProcessFinished, [=](){
@ -39,12 +46,14 @@ void SyncManager::run()
void SyncManager::downloadData() void SyncManager::downloadData()
{ {
qInfo(syncmanager) << EQUALS << endl;
qInfo(syncmanager) << "DOWNLOADING DATA -> BEGIN" << endl;
qInfo(syncmanager) << UNDERSCORE;
connect(colnod.get(), &ColnodAPI::downloadDataFinished, this, &SyncManager::saveColnodData); connect(colnod.get(), &ColnodAPI::downloadDataFinished, this, &SyncManager::saveColnodData);
connect(colnod.get(), &ColnodAPI::downloadDataFinished, this, &SyncManager::areDataReady);
connect(database.get(), &DatabaseAPI::downloadDataFinished, this, &SyncManager::saveDatabaseData); connect(database.get(), &DatabaseAPI::downloadDataFinished, this, &SyncManager::saveDatabaseData);
connect(database.get(), &DatabaseAPI::downloadDataFinished, this, &SyncManager::areDataReady);
colnod->downloadData();
database->downloadData(); database->downloadData();
colnod->downloadData();
} }
// finds conflicts -> changes on both sides (colnod and DB), apply newer change // finds conflicts -> changes on both sides (colnod and DB), apply newer change
@ -104,261 +113,22 @@ void SyncManager::updateLastUpdate(qint64 syncBegin)
void SyncManager::areDataReady() void SyncManager::areDataReady()
{ {
if (++dataAmount == 2) if (++dataAmount == 2)
qDebug(syncmanager) << "DOWNLOADING DATA -> FINISHED" << endl << endl;
qDebug(syncmanager) << EQUALS;
qDebug(syncmanager) << EQUALS << endl << endl;
emit dataReady(); emit dataReady();
} }
void SyncManager::saveColnodData(const std::shared_ptr<Data> &data) void SyncManager::saveColnodData(const std::shared_ptr<Data> &data)
{ {
colnodData = data; colnodData = data;
areDataReady();
} }
void SyncManager::saveDatabaseData(const std::shared_ptr<Data> &data) void SyncManager::saveDatabaseData(const std::shared_ptr<Data> &data)
{ {
databaseData = data; databaseData = data;
areDataReady();
} }
//SyncManager::SyncManager(bool dryMode) :
// reqMan(std::make_unique<RequestManager>()),
// dataMan( std::make_unique<DataManager>(dryMode)),
// dryMode(dryMode)
//{
// connect(reqMan.get(), &RequestManager::error, this, &SyncManager::error, Qt::QueuedConnection);
// connect(dataMan.get(), &DataManager::error, this, &SyncManager::error, Qt::QueuedConnection);
//}
//void SyncManager::loadDataFromColnod()
//{
// loadTokensFromColnod();
// loadUpdatedDataFromColnod();
// loadDeletedDataFromColnod();
//}
//// download all tokens form colnod for comparing with tokens to update from DB
//void SyncManager::loadTokensFromColnod()
//{
// Response* resp = reqMan->getTokens();
// connect(resp, &Response::ready, [=](){
// dataMan->fillFullTokensColnod(resp->getJson());
// areChangedDataReady();
// resp->deleteLater();
// });
//}
//// fill tokens/subjects to update in data manager
//void SyncManager::loadUpdatedDataFromColnod()
//{
// uint64_t lastUpdate = dataMan->getLastSync();
// Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate);
// connect(resp0, &Response::ready, [=](){
// dataMan->fillSubjectsToUpdateColnod(resp0->getJson());
// areChangedDataReady();
// resp0->deleteLater();
// });
// Response* resp1 = reqMan->getTokensUpdated(lastUpdate);
// connect(resp1, &Response::ready, [=](){
// dataMan->fillTokensToUpdateColnod(resp1->getJson());
// areChangedDataReady();
// resp1->deleteLater();
// });
//}
//// fill tokens/subjects to delete in data manager
//void SyncManager::loadDeletedDataFromColnod()
//{
// uint64_t lastUpdate = dataMan->getLastSync();
// Response* resp2 = reqMan->getSubjectsDeleted(lastUpdate);
// connect(resp2, &Response::ready, [=](){
// dataMan->fillSubjectsToDeleteColnod(resp2->getJson());
// areChangedDataReady();
// resp2->deleteLater();
// });
// Response* resp3 = reqMan->getTokensDeleted(lastUpdate);
// connect(resp3, &Response::ready, [=](){
// dataMan->fillTokensToDeleteColnod(resp3->getJson());
// areChangedDataReady();
// resp3->deleteLater();
// });
//}
//// fill structures in data manager (tokens to updata/to delte)
//void SyncManager::loadDataFromDB()
//{
// dataMan->fillTokensToChangeDB();
//}
//void SyncManager::syncDataFromColnodToDB()
//{
// syncUpdatedDataFromColnodToDB();
// if (dataMan->getLastSync() != 0)
// syncDeletedDataFromColnodToDB();
//}
//// push data from colnod to DB
//void SyncManager::syncUpdatedDataFromColnodToDB()
//{
// dataMan->pushSubjectsToDB();
// dataMan->pushTokensToDB();
//}
//// set deleted tokens from Colnod, delete subject
//void SyncManager::syncDeletedDataFromColnodToDB()
//{
// dataMan->deleteSubjectsFromDB();
// dataMan->setDeletedToTokensFromDB();
//}
//// push changes form DB to Colnod
//void SyncManager::syncDataFromDBToColnod()
//{
// connect(this, &SyncManager::dataUpdatedToColnod, dataMan.get(), &DataManager::clear);
// //connect(this, &SyncManager::dataUpdatedToColnod, dataMan.get(), &DataManager::setLastSync);
// if (!dryMode)
// connect(this, &SyncManager::dataUpdatedToColnod, [=](){
// auto resp = reqMan->getTokensUpdated(dataMan->getCurrentSync());
// connect(resp, &Response::ready, [=](){
// dataMan->fillTokensToUpdateColnod(resp->getJson());
// dataMan->setLastUpdate();
// dataMan->clear();
// dataMan->updateLastSync();
// emit syncFinished();
// resp->deleteLater();
// });
// });
// else
// connect(this, &SyncManager::dataUpdatedToColnod, [=](){
// dataMan->updateLastSync();
// emit syncFinished();
// });
// if (!dataMan->getTokensToUpdateFromDB().isEmpty()){
// syncUpdatedDataFromDBToColnod();
// }
// else
// updateFinished = true;
// if (!dataMan->getTokensToDeleteDB().isEmpty()){
// syncDeletedDataFromDBToColnod();
// }
// else{
// deleteFinished = true;
// areDataUpdatedToColnod();
// }
//}
//// add or update tokens to Colnod
//void SyncManager::syncUpdatedDataFromDBToColnod()
//{
// dataMan->filterTokensDB();
// auto tokensToUpdate = dataMan->getTokensToUpdateFromDB();
// if (dryMode){
// for (const auto &token : tokensToUpdate)
// qInfo() << "Updating token:" << token->idToStringWithoutBraces() << "to Colnod";
// updateFinished = true;
// areDataUpdatedToColnod();
// }
// else {
// Response* resp0 = reqMan->setTokens(tokensToUpdate);
// connect(resp0, &Response::ready, [=](){
// qInfo() << "Colnod:" << tokensToUpdate.size() << "tokens updated";
// for(const auto &token : tokensToUpdate)
// Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "updated", "Colnod"));
// updateFinished = true;
// areDataUpdatedToColnod();
// resp0->deleteLater();
// });
// }
//}
//// delete tokens in Colnod
//void SyncManager::syncDeletedDataFromDBToColnod()
//{
// auto tokensToDelete = dataMan->getTokensToDeleteDB();
// if (dryMode){
// for (const auto &token : tokensToDelete)
// qInfo() << "Deleting token:" << token << "from Colnod";
// deleteFinished = true;
// areDataUpdatedToColnod();
// }
// else {
// Response* resp1 = reqMan.deleteTokens(tokensToDelete);
// connect(resp1, &Response::ready, [=](){
// qInfo() << "Colnod:" << tokensToDelete.size() << "tokens deleted";
// for (const auto &id : tokensToDelete){
// dataMan->setLastUpdate(id);
// Logger::logToDb(Logger::makeTokenMsg(id, "deleted", "Colnod"));
// }
// deleteFinished = true;
// areDataUpdatedToColnod();
// resp1->deleteLater();
// });
// }
//}
//// For full sync
//void SyncManager::dropTables()
//{
// dataMan->dropTables();
//}
//void SyncManager::createTables()
//{
// dataMan->createTables();
//}
//bool SyncManager::isValid()
//{
// return dataMan->isDBOpened();
//}
//// emit signal when all data is downloaded from Colnod
//void SyncManager::areChangedDataReady()
//{
// if (++dataCounter == 5)
// emit dataReady();
//}
//// emit signal when writing to Colnod is finised
//void SyncManager::areDataUpdatedToColnod()
//{
// if (deleteFinished && updateFinished)
// {
// emit dataUpdatedToColnod();
// }
//}

69
src/colnod/syncmanager.h
View File

@ -2,17 +2,13 @@
#include "colnodapi.h" #include "colnodapi.h"
#include "databaseapi.h" #include "databaseapi.h"
#include "requestmanager.h"
#include "datamanager.h" Q_DECLARE_LOGGING_CATEGORY(syncmanager)
#include "logger.h"
#include "colnodapi.h"
#include "serversdk/databasemanager.h"
class SyncManager : public QObject class SyncManager : public QObject
{ {
Q_OBJECT Q_OBJECT
// NEW
public: public:
bool init(); bool init();
void run(); void run();
@ -48,65 +44,4 @@ private:
std::shared_ptr<Data> databaseDataToProcess; std::shared_ptr<Data> databaseDataToProcess;
int dataAmount = 0; int dataAmount = 0;
// OLD
//public:
// explicit SyncManager(bool dryMode = false);
// void syncDataFromColnodToDB();
// void syncDataFromDBToColnod();
// void dropTables();
// void createTables();
// bool isValid();
//public slots:
// void loadDataFromColnod();
// void loadDataFromDB();
//signals:
// void dataUpdatedToColnod();
// void error();
//private slots:
//private:
// void loadTokensFromColnod();
// void loadUpdatedDataFromColnod();
// void loadDeletedDataFromColnod();
// void loadUpdatedDataFromDB();
// void loadDeletedDataFromDB();
// void syncUpdatedDataFromColnodToDB();
// void syncDeletedDataFromColnodToDB();
// void syncUpdatedDataFromDBToColnod();
// void syncDeletedDataFromDBToColnod();
// void areChangedDataReady();
// void areDataUpdatedToColnod();
//private:
// // std::unique_ptr<RequestManager> reqMan;
// std::unique_ptr<DataManager> dataMan;
// bool dryMode = false;
// bool updateFinished = false;
// bool deleteFinished = false;
// int dataCounter = 0;
}; };

32
src/colnod/token.cpp
View File

@ -4,20 +4,6 @@
#include <qjsondocument.h> #include <qjsondocument.h>
#include <utility> #include <utility>
Token::Token(const QString& name, QString tokenData, const QString& decription)
{
this->setName(name);
this->setTokenData(tokenData);
this->setDescription(decription);
this->setId(QUuid::createUuid().toString().mid(1, 36));
}
Token::Token(const QString &name)
{
this->setName(name);
}
Token::~Token() Token::~Token()
= default; = default;
@ -29,8 +15,6 @@ QByteArray Token::tokensToColnodJson(const QHash<QString, std::shared_ptr<Token>
for (const auto& token : tokens) for (const auto& token : tokens)
{ {
jsonTokens.push_back(QJsonValue(QJsonDocument::fromJson(token->jsonData()).object())); jsonTokens.push_back(QJsonValue(QJsonDocument::fromJson(token->jsonData()).object()));
//jsonTokens.append(QJsonValue::fromVariant(token->jsonData()));
//jsonTokens.push_back(QJsonValue::fromVariant(token->jsonData()));
} }
items.insert("items", jsonTokens); items.insert("items", jsonTokens);
QJsonDocument doc; QJsonDocument doc;
@ -98,8 +82,11 @@ QByteArray Token::idsToJSON(const QList<QString> &ids)
return doc.toJson(); return doc.toJson();
} }
#include <qsqlrecord.h>
void Token::fromSQLRecord(const QSqlQuery& query) void Token::fromSQLRecord(const QSqlQuery& query)
{ {
auto rec = query.record();
setId(query.value(0).toString()); setId(query.value(0).toString());
a_authErrors = query.value(1).toInt(); a_authErrors = query.value(1).toInt();
setDescription(query.value(2).toString()); setDescription(query.value(2).toString());
@ -117,16 +104,3 @@ void Token::fromSQLRecord(const QSqlQuery& query)
setLastModified(date); setLastModified(date);
setDeleted(query.value(13).toBool()); setDeleted(query.value(13).toBool());
} }
//void Token::setFlags(const QSet<QString> &flags) {
// Token::flags = flags;
//}
//QString Token::idToStringWithoutBraces()
//{
// return a_id.toString().mid(1, 36);
//}
//QString Token::subjectIdToStringWithoutBraces(){
// return a_subjectId.toString().mid(1,36);
//}

22
src/colnod/token.h
View File

@ -1,16 +1,12 @@
#pragma once #pragma once
#include "entity.h"
#include <QSet>
#include <qsqlquery.h>
#include <QVariant>
#include <QDebug>
#include <QDateTime> #include <QDateTime>
#include "serversdk/databasetable.h" #include "serversdk/databasetable.h"
#include <QSqlQuery>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray> #include <QJsonArray>
class Token : public serversdk::DatabaseTable { class Token : public serversdk::DatabaseTable {
Q_OBJECT Q_OBJECT
TABLE_PROPERTY(QString, id, setId, QString()) TABLE_PROPERTY(QString, id, setId, QString())
@ -42,8 +38,6 @@ public:
*/ */
explicit Token() = default; explicit Token() = default;
Token(const QString& name, QString tokenData, const QString& decription = "mobile");
explicit Token(const QString& name);
~Token() override; ~Token() override;
QByteArray jsonData(const QSet<QString> &filters = {}) const override; QByteArray jsonData(const QSet<QString> &filters = {}) const override;
@ -71,20 +65,10 @@ public:
lToken.subjectId() == rToken.subjectId(); lToken.subjectId() == rToken.subjectId();
} }
const QSet<QString> &getFlags() const;
void setFlags(const QSet<QString> &flags);
QString idToStringWithoutBraces();
QString subjectIdToStringWithoutBraces();
void fromSQLRecord(const QSqlQuery& query); void fromSQLRecord(const QSqlQuery& query);
void fromJSON(const QJsonObject &json);
QJsonObject toJSON() const;
static QByteArray tokensToColnodJson(const QHash<QString, std::shared_ptr<Token> > &tokens); static QByteArray tokensToColnodJson(const QHash<QString, std::shared_ptr<Token> > &tokens);
static QByteArray idsToJSON(const QList<QString> &ids); static QByteArray idsToJSON(const QList<QString> &ids);
private: private:
//QSet<QString> flags = {"NoValidity", "Enabled"};
}; };

293
test/unitTests/UnitTest.cpp
View File

@ -5,299 +5,6 @@ void UnitTest::initTestCase()
} }
void UnitTest::loginSuccessfully()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::successLogin);
QVERIFY(spy.isValid());
testAccess.login();
spy.wait(timeout);
QCOMPARE(spy.count(), 1);
QString json = testAccess.jsonResponse;
qDebug() << json;
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QVERIFY2(doc.object().value("id").isString(), "No parameter 'id' in response");
}
//POST request w/o datas
void UnitTest::getSubjects()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
QVERIFY(spy.isValid());
Response* response = testAccess.getSubjects();
QSignalSpy spy1(response, &Response::ready);
spy.wait(timeout);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy1.count(), 1);
QString json = response->getJson();
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QVERIFY(doc.isObject());
QVERIFY2(doc.object().value("items").isArray(), "No parameter 'id' in response");
qDebug() << doc.object().value("items").toArray()[0].toObject()["id"].toString();
QVERIFY2(doc.object().value("items").toArray()[0].toObject()["id"].isString(), "ada");
response->deleteLater();
}
void UnitTest::getTokens()
{
RequestManager testAccess;
Response* response = testAccess.getTokens();
QSignalSpy spy(response, &Response::ready);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QVERIFY(doc.isObject());
QVERIFY2(doc.object().value("items").isArray(), "No parameter 'id' in response");
qDebug() << doc.object().value("items").toArray()[0].toObject()["id"].toString();
QVERIFY2(doc.object().value("items").toArray()[0].toObject()["id"].isString(), "ada");
response->deleteLater();
}
void UnitTest::getTokenSubject()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getTokenSubject();
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getSubjectsUpdated()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getSubjectsUpdated(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getSubjectsDeleted()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getSubjectsDeleted(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getTokensUpdated()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getTokensUpdated(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getTokensDeleted()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getTokensDeleted(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroups()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroups();
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroupsUpdated()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroupsUpdated(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroupsDeleted()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroupsDeleted(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroupMembership()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroupMembership();
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroupMembershipUpdated()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroupMembershipUpdated(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::getAccessGroupMembershipDeleted()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getAccessGroupMembershipDeleted(epochMS);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::setTokens()
{
QHash<QString, std::shared_ptr<Token>> tokens;
auto token = getTestToken();
tokens.insert(token->id(), token);
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.setTokens(tokens);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::deleteTokens()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
QList<QString> ids;
ids.append("582c982d-6fd7-4856-8548-7ce542791c7a");
ids.append("3ff23b41-3da3-4b33-82ce-d8e2d8c9a546");
Response* response = testAccess.deleteTokens(ids);
QCOMPARE(spy.count(), 0);
spy.wait(timeout);
QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1);
QString json = response->getJson();
QVERIFY(!json.isEmpty());
response->deleteLater();
}
void UnitTest::subjectJSONParser()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getSubjects();
spy.wait(timeout);
QString json = response->getJson();
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());
response->deleteLater();
}
void UnitTest::tokenJSONParser()
{
RequestManager testAccess;
QSignalSpy spy(&testAccess, &RequestManager::responseReady);
Response* response = testAccess.getTokens();
spy.wait(timeout);
QString json = response->getJson();
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());
response->deleteLater();
}
std::shared_ptr<Token> UnitTest::getTestToken()
{
QJsonObject jsonToken;
jsonToken.insert("id", "062c93f6-ba3e-46af-a3a6-7a2988d1f0e9");
jsonToken.insert("name", "test");
jsonToken.insert("description", "mobile");
jsonToken.insert("tokenType", "Token");
jsonToken.insert("tokenBits", 32);
jsonToken.insert("tokenData", "7B9D32");
jsonToken.insert("timeToLive", 255);
jsonToken.insert("authErrors", 255);
QJsonArray flags;
flags.push_back("Enabled");
flags.push_back("NoValidity");
jsonToken.insert("flags", flags);
jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904");
auto token = std::make_shared<Token>();
//token->fromJSON(jsonToken);
return token;
}
QTEST_MAIN(UnitTest) QTEST_MAIN(UnitTest)

24
test/unitTests/complextest.cpp
View File

@ -167,22 +167,22 @@ void ComplexTest::testingStuff()
// HELPFUL_FUNCTIONS // HELPFUL_FUNCTIONS
int ComplexTest::getNumOfSubjects() int ComplexTest::getNumOfSubjects()
{ {
auto reqMan = new RequestManager; // auto reqMan = new RequestManager;
Response* subjectsResp = reqMan->getSubjects(); // Response* subjectsResp = reqMan->getSubjects();
QSignalSpy subjectsRespSpy(subjectsResp, &Response::ready); // QSignalSpy subjectsRespSpy(subjectsResp, &Response::ready);
subjectsRespSpy.wait(timeout); // subjectsRespSpy.wait(timeout);
auto doc = getJsonDoc(subjectsResp->getJson()); // auto doc = getJsonDoc(subjectsResp->getJson());
return doc.object()["items"].toArray().size(); // return doc.object()["items"].toArray().size();
} }
int ComplexTest::getNumOfTokens() int ComplexTest::getNumOfTokens()
{ {
auto reqMan = new RequestManager; // auto reqMan = new RequestManager;
Response* tokensResp = reqMan->getTokens(); // Response* tokensResp = reqMan->getTokens();
QSignalSpy tokensRespSpy(tokensResp, &Response::ready); // QSignalSpy tokensRespSpy(tokensResp, &Response::ready);
tokensRespSpy.wait(timeout); // tokensRespSpy.wait(timeout);
auto doc = getJsonDoc(tokensResp->getJson()); // auto doc = getJsonDoc(tokensResp->getJson());
return doc.object()["items"].toArray().size(); // return doc.object()["items"].toArray().size();
} }
QJsonDocument ComplexTest::getJsonDoc(const QString &json) QJsonDocument ComplexTest::getJsonDoc(const QString &json)

3
test/unitTests/complextest.h
View File

@ -3,10 +3,7 @@
#include <QObject> #include <QObject>
#include <QtTest/QtTest> #include <QtTest/QtTest>
#include "response.h"
#include "requestmanager.h"
#include "syncmanager.h" #include "syncmanager.h"
#include "logger.h"
class ComplexTest : public QObject class ComplexTest : public QObject
{ {

23
test/unitTests/unittest.h
View File

@ -3,13 +3,9 @@
#include <QtTest/QtTest> #include <QtTest/QtTest>
#include <QSignalSpy> #include <QSignalSpy>
#include <requestmanager.h>
#include "subject.h" #include "subject.h"
#include "databaseapi.h" #include "databaseapi.h"
#include <QSslSocket> #include <QSslSocket>
#include "datamanager.h"
#include "response.h"
class UnitTest : public QObject class UnitTest : public QObject
{ {
@ -19,24 +15,7 @@ private slots:
void initTestCase(); void initTestCase();
void loginSuccessfully(); // /AaaManager/authSession
void getSubjects(); // /SubjectManager/getSubjects
void getTokens(); // /TokenManager/getTokens
void getTokenSubject(); // /OpenManager/getTokenSubject
void getSubjectsUpdated();
void getSubjectsDeleted();
void getTokensUpdated();
void getTokensDeleted();
void getAccessGroups();
void getAccessGroupsUpdated();
void getAccessGroupsDeleted();
void getAccessGroupMembership();
void getAccessGroupMembershipUpdated();
void getAccessGroupMembershipDeleted();
void setTokens();
void deleteTokens();
void subjectJSONParser();
void tokenJSONParser();
private: private:
std::shared_ptr<Token> getTestToken(); std::shared_ptr<Token> getTestToken();