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

Add comments to code, also make changes according to Clang-Tidy and Clazy analyze

Browse Source
This commit is contained in:
Ondřej Fischer 2019-10-23 15:05:27 +02:00
parent 6ad24c6c6e
commit 4d30dcc9f4
18 changed files with 337 additions and 491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/app/main.cpp
View File

@ -6,7 +6,7 @@
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
QCoreApplication a(argc, argv); QCoreApplication a(argc, argv);
ColnodAPI *api = new ColnodAPI(); auto *api = new ColnodAPI();
/*api->downloadData(); // this will start downloading data /*api->downloadData(); // this will start downloading data
@ -31,5 +31,5 @@ int main(int argc, char *argv[])
api->loadDataFromDB(); api->loadDataFromDB();
return a.exec(); return QCoreApplication::exec();
} }

144
src/colnod/colnodapi.cpp
View File

@ -7,33 +7,6 @@ ColnodAPI::ColnodAPI(bool debug)
debugMode = debug; debugMode = debug;
} }
// PUBLIC FUNCTIONS
//void ColnodAPI::downloadData()
//{
// Response* resp0 = reqMan->getSubjects();
// connect(resp0, &Response::ready, [=](){
// dataMan->localSaveSubjects(resp0->getJson());
// areDataReady();
// resp0->deleteLater();
// });
// Response* resp1 = reqMan->getTokens();
// connect(resp1, &Response::ready, [=](){
// dataMan->localSaveTokens(resp1->getJson());
// areDataReady();
// resp1->deleteLater();
// });
// /*
// QNetworkReply* reply2 = reqMan->getTokens();
// connect(reply2, &QNetworkReply::finished, [=](){
// data->saveTokens(reply2->readAll());
// });
// */
//}
void ColnodAPI::loadDataFromColnod() void ColnodAPI::loadDataFromColnod()
{ {
loadTokensFromColnod(); loadTokensFromColnod();
@ -41,6 +14,7 @@ void ColnodAPI::loadDataFromColnod()
loadDeletedDataFromColnod(); loadDeletedDataFromColnod();
} }
// download all tokens form colnod for comparing with tokens to update from DB
void ColnodAPI::loadTokensFromColnod() void ColnodAPI::loadTokensFromColnod()
{ {
Response* resp = reqMan->getTokens(); Response* resp = reqMan->getTokens();
@ -51,24 +25,26 @@ void ColnodAPI::loadTokensFromColnod()
}); });
} }
// fill tokens/subjects to update in data manager
void ColnodAPI::loadUpdatedDataFromColnod() void ColnodAPI::loadUpdatedDataFromColnod()
{ {
uint64_t lastUpdate = dataMan->getLastSync(); uint64_t lastUpdate = dataMan->getLastSync();
Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate); Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate);
connect(resp0, &Response::ready, [=](){ connect(resp0, &Response::ready, [=](){
dataMan->fillSubjectsColnod(resp0->getJson()); dataMan->fillSubjectsToUpdateColnod(resp0->getJson());
areChangedDataReady(); areChangedDataReady();
resp0->deleteLater(); resp0->deleteLater();
}); });
Response* resp1 = reqMan->getTokensUpdated(lastUpdate); Response* resp1 = reqMan->getTokensUpdated(lastUpdate);
connect(resp1, &Response::ready, [=](){ connect(resp1, &Response::ready, [=](){
dataMan->fillTokensColnod(resp1->getJson()); dataMan->fillTokensToUpdateColnod(resp1->getJson());
areChangedDataReady(); areChangedDataReady();
resp1->deleteLater(); resp1->deleteLater();
}); });
} }
// fill tokens/subjects to delete in data manager
void ColnodAPI::loadDeletedDataFromColnod() void ColnodAPI::loadDeletedDataFromColnod()
{ {
uint64_t lastUpdate = dataMan->getLastSync(); uint64_t lastUpdate = dataMan->getLastSync();
@ -88,134 +64,102 @@ void ColnodAPI::loadDeletedDataFromColnod()
} }
// fill structures in data manager (tokens to updata/to delte)
void ColnodAPI::loadDataFromDB() void ColnodAPI::loadDataFromDB()
{ {
dataMan->fillTokensDB(); dataMan->fillTokensToUpdateDB();
} }
//void ColnodAPI::syncDataFromColnod()
//{
// dataMan->pushTokensToDB();
// dataMan->pushSubjectsToDB();
// dataMan->updateLastSync();
// dataMan->clear();
//}
void ColnodAPI::syncDataFromColnod() void ColnodAPI::syncDataFromColnod()
{ {
dataMan->filterTokensColnod(); dataMan->filterTokensColnod();
syncUpdatedDataFromColnod(); syncUpdatedDataFromColnodToDB();
if (dataMan->getLastSync() != 0) if (dataMan->getLastSync() != 0)
syncDeletedDataFromColnod(); syncDeletedDataFromColnodToDB();
//dataMan->updateLastSync();
// dataMan->clear();
} }
void ColnodAPI::syncUpdatedDataFromColnod() // push data from colnod to DB
void ColnodAPI::syncUpdatedDataFromColnodToDB()
{ {
dataMan->pushSubjectsToDB(); dataMan->pushSubjectsToDB();
dataMan->pushTokensToDB(); dataMan->pushTokensToDB();
} }
// set deleted tokens from Colnod, delete subject
void ColnodAPI::syncDeletedDataFromColnod() void ColnodAPI::syncDeletedDataFromColnodToDB()
{ {
dataMan->deleteSubjectsFromDB(); dataMan->deleteSubjectsFromDB();
dataMan->deleteTokensFromDB(); dataMan->setDeletedToTokensFromDB();
} }
void ColnodAPI::syncDataFromDB() // push changes form DB to Colnod
void ColnodAPI::syncDataFromDBToColnod()
{ {
// TODO
dataMan->filterTokensDB(); dataMan->filterTokensDB();
processDataToColnod(); if (!dataMan->getTokensToUpdateDB().contains("empty")){
connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::clear); syncDeletedDataFromDBToColnod();
connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::setLastSync); }
connect(this, &ColnodAPI::dataProcessed, [=](){ if (!dataMan->getTokensToDeleteDB().contains("empty")){
syncUpdatedDataFromDBToColnod();
}
connect(this, &ColnodAPI::dataUpdatedToColnod, dataMan, &DataManager::clear);
connect(this, &ColnodAPI::dataUpdatedToColnod, dataMan, &DataManager::setLastSync);
connect(this, &ColnodAPI::dataUpdatedToColnod, [=](){
auto resp = reqMan->getTokensUpdated(dataMan->getActualSync()); auto resp = reqMan->getTokensUpdated(dataMan->getActualSync());
connect(resp, &Response::ready, [=](){ connect(resp, &Response::ready, [=](){
dataMan->fillTokensColnod(resp->getJson()); dataMan->fillTokensToUpdateColnod(resp->getJson());
dataMan->setLastUpdate(); dataMan->setLastUpdate();
dataMan->clear(); dataMan->clear();
dataMan->updateLastSync();
emit syncFinished(); emit syncFinished();
resp->deleteLater(); resp->deleteLater();
}); });
}); });
} }
void ColnodAPI::processDataToColnod() // add or update tokens to Colnod
void ColnodAPI::syncUpdatedDataFromDBToColnod()
{ {
auto tokensToUpdate = dataMan->getTokensToUpdateDB(); auto tokensToUpdate = dataMan->getTokensToUpdateDB();
Response* resp0 = reqMan->setTokens(tokensToUpdate);
if (tokensToUpdate.contains("empty")){
qDebug() << "No tokens to be modified.";
return;
}
auto tokensToDelete = dataMan->getTokensToDeleteDB();
auto resp0 = reqMan->setTokens(tokensToUpdate);
auto resp1 = reqMan->deleteTokens(tokensToDelete);
connect(resp0, &Response::ready, [=](){ connect(resp0, &Response::ready, [=](){
updateFinished = true; updateFinished = true;
areDataProcessed(); areDataUpdatedToColnod();
resp0->deleteLater(); resp0->deleteLater();
}); });
}
// delete tokens in Colnod
void ColnodAPI::syncDeletedDataFromDBToColnod()
{
auto tokensToDelete = dataMan->getTokensToDeleteDB();
Response* resp1 = reqMan->deleteTokens(tokensToDelete);
connect(resp1, &Response::ready, [=](){ connect(resp1, &Response::ready, [=](){
deleteFinished = true; deleteFinished = true;
areDataProcessed(); areDataUpdatedToColnod();
resp1->deleteLater(); resp1->deleteLater();
}); });
} }
// old version
//void ColnodAPI::processDataToColnod()
//{
// QList<QString>* tokensToDelete = dataMan->getTokensToDelete();
// if ((*tokensToDelete)[0] != "empty")
// {
// Response* resp0 = reqMan->deleteTokens(tokensToDelete);
// connect(resp0, &Response::ready, [=](){
// isProcessDone();
// resp0->deleteLater();
// });
// }
// QHash<QString, QPointer<Token>>* tokens = dataMan->getTokens();
// if (!tokens[0].contains("empty"))
// {
// Response* resp1 = reqMan->setTokens(tokens);
// connect(resp1, &Response::ready, [=](){
// isProcessDone();
// resp1->deleteLater();
// });
// }
// dataMan->clear();
// connect(this, &ColnodAPI::dataProcessed, this, &ColnodAPI::loadDataFromColnod);
//}
// For full sync // For full sync
void ColnodAPI::prepareDatabase() void ColnodAPI::prepareDatabase()
{ {
dataMan->emptyDatabase(); dataMan->emptyDatabase();
} }
// PRIVATE FUNCTIONS // emit signal when all data is downloaded from Colnod
void ColnodAPI::areDataReady()
{
if (dataMan->haveData())
emit dataDownloaded();
}
void ColnodAPI::areChangedDataReady() void ColnodAPI::areChangedDataReady()
{ {
if (dataMan->haveChangedData()) if (dataMan->haveChangedData())
emit dataDownloaded(); emit dataDownloaded();
} }
// emit signal when writing to Colnod is finised
void ColnodAPI::areDataProcessed() void ColnodAPI::areDataUpdatedToColnod()
{ {
if (deleteFinished && updateFinished) if (deleteFinished && updateFinished)
{ {
emit dataProcessed(); emit dataUpdatedToColnod();
} }
} }

20
src/colnod/colnodapi.h
View File

@ -16,7 +16,7 @@ public:
ColnodAPI(bool debugMode = false); ColnodAPI(bool debugMode = false);
void syncDataFromColnod(); void syncDataFromColnod();
void syncDataFromDB(); void syncDataFromDBToColnod();
void prepareDatabase(); void prepareDatabase();
@ -24,10 +24,9 @@ public slots:
void loadDataFromColnod(); void loadDataFromColnod();
void loadDataFromDB(); void loadDataFromDB();
signals: signals:
void dataDownloaded(); void dataDownloaded();
void dataProcessed(); void dataUpdatedToColnod();
void syncFinished(); void syncFinished();
private slots: private slots:
@ -40,22 +39,21 @@ private:
void loadUpdatedDataFromDB(); void loadUpdatedDataFromDB();
void loadDeletedDataFromDB(); void loadDeletedDataFromDB();
void syncUpdatedDataFromColnodToDB();
void syncDeletedDataFromColnodToDB();
void syncUpdatedDataFromDBToColnod();
void syncDeletedDataFromDBToColnod();
void syncUpdatedDataFromColnod();
void syncDeletedDataFromColnod();
void areDataReady();
void areChangedDataReady(); void areChangedDataReady();
void areDataProcessed(); void areDataUpdatedToColnod();
void processDataToColnod();
private:
RequestManager* reqMan = nullptr; RequestManager* reqMan = nullptr;
DataManager* dataMan = nullptr; DataManager* dataMan = nullptr;
bool debugMode = false; bool debugMode = false;
bool updateFinished = false; bool updateFinished = false;
bool deleteFinished = false; bool deleteFinished = false;
}; };
#endif // COLNODAPI_H #endif // COLNODAPI_H

99
src/colnod/databasemanager.cpp
View File

@ -1,6 +1,6 @@
#include "databasemanager.h" #include "databasemanager.h"
DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QString password) DatabaseManager::DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password)
{ {
db = QSqlDatabase::addDatabase("QPSQL"); db = QSqlDatabase::addDatabase("QPSQL");
@ -12,15 +12,16 @@ DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QSt
//db.setPort(80); //db.setPort(80);
// //
db.setPassword(password); db.setPassword(password);
opened = db.open();
if (!opened) if (!db.open())
{ {
qDebug() << "Opening error" + db.lastError().text(); qDebug() << "Opening error" + db.lastError().text();
} }
query = QSqlQuery("query", db); query = QSqlQuery("query", db);
} }
void DatabaseManager::saveSubject(Subject* subject, QString table) // add or update subject to db
void DatabaseManager::saveSubject(Subject* subject, const QString& table)
{ {
QString id = subject->idToStringWithoutBraces(); QString id = subject->idToStringWithoutBraces();
if (checkIfExists(id, table)) if (checkIfExists(id, table))
@ -47,7 +48,8 @@ void DatabaseManager::saveSubject(Subject* subject, QString table)
} }
} }
void DatabaseManager::saveToken(Token* token, QString table) // add or update token to DB
void DatabaseManager::saveToken(Token* token, const QString& table)
{ {
QString id = token->idToStringWithoutBraces(); QString id = token->idToStringWithoutBraces();
if (checkIfExists(id, table)) if (checkIfExists(id, table))
@ -91,13 +93,13 @@ void DatabaseManager::saveToken(Token* token, QString table)
} }
} }
void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table) // add of update subject attributes
void DatabaseManager::saveSubjectAttributes(Subject *subject, const QString& table)
{ {
auto attributes = subject->getAtr(); auto attributes = subject->getAtr();
for (auto attribute : attributes){ for (const auto& attribute : attributes){
QString id = subject->idToStringWithoutBraces() + " " + attribute.first; QString id = subject->idToStringWithoutBraces() + " " + attribute.first;
if (checkIfExists(id, table)) if (checkIfExists(id, table)){
{
query.prepare(QString("UPDATE %1 SET id = :id, attribute_key = :key, attribute_value = :value, subject_id = :subject_id) " query.prepare(QString("UPDATE %1 SET id = :id, attribute_key = :key, attribute_value = :value, subject_id = :subject_id) "
"WHERE id = :id").arg(table)); "WHERE id = :id").arg(table));
query.bindValue(":id", id); query.bindValue(":id", id);
@ -106,8 +108,7 @@ void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
query.bindValue(":subject_id", subject->idToStringWithoutBraces()); query.bindValue(":subject_id", subject->idToStringWithoutBraces());
query.exec(); query.exec();
} }
else else{
{
query.prepare(QString("INSERT INTO %1 (id, attribute_key, attribute_value, subject_id)" query.prepare(QString("INSERT INTO %1 (id, attribute_key, attribute_value, subject_id)"
"VALUES (:id, :key, :value, :subject_id)").arg(table)); "VALUES (:id, :key, :value, :subject_id)").arg(table));
query.bindValue(":id", id); query.bindValue(":id", id);
@ -119,7 +120,8 @@ void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
} }
} }
void DatabaseManager::setDeleted(QString id, QString table) // "delete" tokens from DB -> set deleted true
void DatabaseManager::setDeleted(const QString& id, const QString& table)
{ {
quint64 now = getNow(); quint64 now = getNow();
QString nowString = QDateTime::fromMSecsSinceEpoch(now).toString("yyyy-MM-dd hh:mm:ss.zzz"); QString nowString = QDateTime::fromMSecsSinceEpoch(now).toString("yyyy-MM-dd hh:mm:ss.zzz");
@ -129,29 +131,7 @@ void DatabaseManager::setDeleted(QString id, QString table)
query.exec(); query.exec();
} }
QString DatabaseManager::getTestMessage(int id) bool DatabaseManager::checkIfExists(const QString& id, const QString& table)
{
query.prepare("SELECT message FROM test WHERE id = :id");
query.bindValue(":id", id);
query.exec();
query.next();
return query.value(0).toString();
}
int DatabaseManager::createTestRecord(QString msg)
{
query.exec("SELECT MAX(id) FROM test");
query.next();
int id = query.value(0).toInt() + 1;
query.prepare("INSERT INTO test (id, message) VALUES (:id, :msg)");
query.bindValue(":id", id);
query.bindValue(":msg", msg);
query.exec();
qDebug() << "U inserted new row, id: " << id << "msg: " << getTestMessage(id);
return id;
}
bool DatabaseManager::checkIfExists(QString id, QString table)
{ {
query.prepare(QString("SELECT EXISTS(SELECT 1 FROM %1 WHERE id = :id)").arg(table)); query.prepare(QString("SELECT EXISTS(SELECT 1 FROM %1 WHERE id = :id)").arg(table));
query.bindValue(":id", id); query.bindValue(":id", id);
@ -160,16 +140,23 @@ bool DatabaseManager::checkIfExists(QString id, QString table)
return query.value(0).toBool(); return query.value(0).toBool();
} }
bool DatabaseManager::executeQuery(QSqlQuery &query) const
{
bool res = query.exec();
return res;
}
void DatabaseManager::dropTables() void DatabaseManager::dropTables()
{ {
query.exec("DROP TABLE IF EXISTS colnod_token, colnod_subject, colnod_subject_attribute"); query.exec("DROP TABLE IF EXISTS colnod_token, colnod_subject, colnod_subject_attribute");
} }
// create table after deleting, it is used for full sync
void DatabaseManager::createTables() void DatabaseManager::createTables()
{ {
query.exec("CREATE TABLE colnod_subject (" query.exec("CREATE TABLE colnod_subject ("
"id character(36) primary key NOT NULL," "id character(36) primary key NOT NULL,"
//"access_pin smallint,"
"description character varying(255)," "description character varying(255),"
"last_update timestamp NOT NULL," "last_update timestamp NOT NULL,"
"name character varying(255)," "name character varying(255),"
@ -198,6 +185,7 @@ void DatabaseManager::createTables()
"subject_id CHAR(36))"); "subject_id CHAR(36))");
} }
// return last_sync time
uint64_t DatabaseManager::getLastSync() uint64_t DatabaseManager::getLastSync()
{ {
query.exec("SELECT last_sync FROM config"); query.exec("SELECT last_sync FROM config");
@ -206,6 +194,7 @@ uint64_t DatabaseManager::getLastSync()
return temp; return temp;
} }
// on the very end of sync set new Last_sync time (begin of this sync)
void DatabaseManager::updateLastSync(quint64 lastSync) void DatabaseManager::updateLastSync(quint64 lastSync)
{ {
query.prepare("UPDATE config SET last_sync = :last_sync"); query.prepare("UPDATE config SET last_sync = :last_sync");
@ -213,37 +202,8 @@ void DatabaseManager::updateLastSync(quint64 lastSync)
query.exec(); query.exec();
} }
void DatabaseManager::makeTestingLast_sync()
{
query.prepare("INSERT INTO last_changes (last_sync) "
"VALUES (:time)");
query.bindValue(":time", QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz"));
query.exec();
}
QSqlQuery* DatabaseManager::getTokensToAdd()
{
QSqlQuery* qry = new QSqlQuery;
qry->exec("SELECT name, token_data FROM changes WHERE status = 'toBeAdd'");
return qry;
}
QSqlQuery* DatabaseManager::getTokensToDelete()
{
QSqlQuery* qry = new QSqlQuery;
qry->exec("SELECT id FROM changes WHERE status = 'toBeDeleted'");
return qry;
}
QUuid DatabaseManager::getId(QString name)
{
query.prepare("SELECT id FROM colnod_subject WHERE name = :name");
query.bindValue(":name", name);
query.exec();
query.next();
return query.value(0).toUuid();
}
// return set of tokens to update form DB
QSqlQuery* DatabaseManager::getUpdatedTokens() QSqlQuery* DatabaseManager::getUpdatedTokens()
{ {
QSqlQuery* qry = new QSqlQuery; QSqlQuery* qry = new QSqlQuery;
@ -252,7 +212,7 @@ QSqlQuery* DatabaseManager::getUpdatedTokens()
return qry; return qry;
} }
QSqlQuery* DatabaseManager::getToken(QString id) QSqlQuery* DatabaseManager::getToken(const QString& id)
{ {
QSqlQuery* qry = new QSqlQuery; QSqlQuery* qry = new QSqlQuery;
qry->prepare("SELECT 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 " qry->prepare("SELECT 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 "
@ -262,10 +222,8 @@ QSqlQuery* DatabaseManager::getToken(QString id)
if (qry->next()){ if (qry->next()){
return qry; return qry;
} }
else {
return nullptr; return nullptr;
} }
}
quint64 DatabaseManager::getNow() quint64 DatabaseManager::getNow()
{ {
@ -274,7 +232,8 @@ quint64 DatabaseManager::getNow()
return query.value(0).toULongLong(); return query.value(0).toULongLong();
} }
void DatabaseManager::setLastUpdate(QString id, quint64 lastUpdate) // sync last update back to DB from Colnod after changes made to Colnod
void DatabaseManager::setLastUpdate(const QString& id, quint64 lastUpdate)
{ {
query.prepare("UPDATE colnod_token SET last_update = :lastUpdate WHERE id = :id"); query.prepare("UPDATE colnod_token SET last_update = :lastUpdate WHERE id = :id");
query.bindValue(":id", id); query.bindValue(":id", id);

39
src/colnod/databasemanager.h
View File

@ -16,53 +16,32 @@ class DatabaseManager : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
DatabaseManager(QString host, QString dbName, QString user, QString password); DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password);
void saveSubject(Subject* subject, const QString& table);
void saveToken(Token* token, const QString& table);
void saveSubject(Subject* subject, QString table); void saveSubjectAttributes(Subject* subject, const QString& table);
void saveToken(Token* token, QString table); void setDeleted(const QString& id, const QString& table);
void saveSubjectAttribute(Subject* subject, QString table);
void setDeleted(QString id, QString table);
QString getTestMessage(int id);
int createTestRecord(QString msg);
//
void makeTestingLast_sync();
//
void dropTables(); void dropTables();
void createTables(); void createTables();
bool getOpened() {return opened;}
quint64 getLastSync(); quint64 getLastSync();
void updateLastSync(quint64 lastSync); void updateLastSync(quint64 lastSync);
quint64 getNow(); quint64 getNow();
QSqlQuery* getUpdatedTokens(); QSqlQuery* getUpdatedTokens();
QSqlQuery* getToken(QString id); QSqlQuery* getToken(const QString& id);
// Old version
QSqlQuery* getTokensToAdd();
QSqlQuery* getTokensToDelete();
void setLastUpdate(QString id, quint64 lastUpdate);
QUuid getId(QString name);
void setLastUpdate(const QString& id, quint64 lastUpdate);
private: private:
bool checkIfExists(QString id, QString table); bool checkIfExists(const QString& id, const QString& table);
bool executeQuery(QSqlQuery &query) const;
private: private:
QSqlDatabase db; QSqlDatabase db;
QSqlQuery query; QSqlQuery query;
bool opened;
}; };
#endif // DATABASEMANAGER_H #endif // DATABASEMANAGER_H

183
src/colnod/datamanager.cpp
View File

@ -9,113 +9,123 @@ DataManager::DataManager()
//db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12"); //db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12");
} }
void DataManager::fillFullTokensColnod(QString response) // load all tokens from colnod to comparing with working set from DB
void DataManager::fillFullTokensColnod(const QString& response)
{ {
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
QJsonArray items = doc.object()["items"].toArray(); QJsonArray items = doc.object()["items"].toArray();
if (items.size() > 0) if (!items.empty())
{ {
for (QJsonValueRef item : items) for (QJsonValueRef item : items)
{ {
auto token = new Token(); auto token = new Token();
token->fromJSON(item.toObject()); token->fromJSON(item.toObject());
fullTokensColnod.insert(token->idToStringWithoutBraces(), token); allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
} }
} }
else else
{ {
auto token = new Token("empty"); auto token = new Token("empty");
fullTokensColnod.insert(token->idToStringWithoutBraces(), token); allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
} }
} }
void DataManager::fillTokensColnod(QString response) // load working set with updated tokens from Colnod
void DataManager::fillTokensToUpdateColnod(const QString& response)
{ {
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
QJsonArray items = doc.object()["items"].toArray(); QJsonArray items = doc.object()["items"].toArray();
if (items.size() > 0) if (!items.empty())
{ {
for (QJsonValueRef item : items) for (QJsonValueRef item : items)
{ {
auto token = new Token(); auto token = new Token();
token->fromJSON(item.toObject()); token->fromJSON(item.toObject());
token->setDeleted(false); token->setDeleted(false);
tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token); tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
} }
} }
else else
{ {
auto token = new Token("empty"); auto token = new Token("empty");
tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token); tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
} }
} }
void DataManager::fillSubjectsColnod(QString response) // load working set with updated subjects from Colnod
void DataManager::fillSubjectsToUpdateColnod(const QString& response)
{ {
QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
QJsonArray items = doc.object()["items"].toArray(); QJsonArray items = doc.object()["items"].toArray();
if (items.size() > 0) if (!items.empty())
{ {
for (QJsonValueRef item : items) for (QJsonValueRef item : items)
{ {
auto subject = new Subject(); auto subject = new Subject();
subject->fromJSON(item.toObject()); subject->fromJSON(item.toObject());
subjectsColnod.insert(subject->idToStringWithoutBraces(), subject); subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
} }
} }
else else
{ {
Subject* subject = new Subject("empty"); Subject* subject = new Subject("empty");
subjectsColnod.insert(subject->idToStringWithoutBraces(), subject); subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
} }
} }
// fills tokensDB and tokensToDeleteDB // load working sets with updated/deleted tokens from DB
void DataManager::fillTokensDB() void DataManager::fillTokensToUpdateDB()
{ {
QSqlQuery* query = db->getUpdatedTokens(); QSqlQuery* query = db->getUpdatedTokens();
while (query->next()) while (query->next())
{ {
auto token = new Token; auto token = new Token;
token->fromSQLRecord(query); token->fromSQLRecord(query);
tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token); if (token->getDeleted()){ // sort to delete and to update
tokensFromDBToDeleteFromColnod.append(token->idToStringWithoutBraces());
} }
qDebug() << "Number of tokens to update from DB: "<< tokensToUpdateDB.size(); else{
qDebug() << "Number of tokens to delete from DB: "<< tokensToDeleteDB.size(); tokensToUpdateFromDBToColnod.insert(token->idToStringWithoutBraces(), token);
}
}
qDebug() << "Number of tokens to update from DB: "<< tokensToUpdateFromDBToColnod.size();
qDebug() << "Number of tokens to delete from DB: "<< tokensFromDBToDeleteFromColnod.size();
} }
void DataManager::fillSubjectsDB() void DataManager::fillSubjectsToUpdateDB()
{ {
// Not needed yet // Not needed yet
} }
void DataManager::fillSubjectsToDeleteColnod(QString json) // load working set with subjest to delete from Colnod
void DataManager::fillSubjectsToDeleteColnod(const QString& json)
{ {
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QJsonArray items = doc.object()["items"].toArray(); QJsonArray items = doc.object()["items"].toArray();
if (items.size() > 0) if (!items.empty())
{ {
for (QJsonValueRef item : items) { for (QJsonValueRef item : items) {
subjectsToDeleteColnod.append(item.toString()); subjectsFromColnodToDeleteFromDB.append(item.toString());
} }
} }
else { else {
subjectsToDeleteColnod.append("empty"); subjectsFromColnodToDeleteFromDB.append("empty");
} }
} }
void DataManager::fillTokensToDeleteColnod(QString json) // load working set with tokenst to delete from colnod
void DataManager::fillTokensToDeleteColnod(const QString& json)
{ {
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QJsonArray items = doc.object()["items"].toArray(); QJsonArray items = doc.object()["items"].toArray();
if (items.size() > 0) if (!items.empty())
{ {
for (QJsonValueRef item : items) { for (QJsonValueRef item : items) {
tokensToDeleteColnod.append(item.toString()); tokensFromColnodToDeleteFromDB.append(item.toString());
} }
} }
else { else {
tokensToDeleteColnod.append("empty"); tokensFromColnodToDeleteFromDB.append("empty");
} }
} }
@ -124,134 +134,126 @@ void DataManager::fillSubjectsToDeleteDB()
// Not needed yet // Not needed yet
} }
// update subjects from colnod to DB
void DataManager::pushSubjectsToDB() void DataManager::pushSubjectsToDB()
{ {
if (subjectsColnod.contains("empty")) { if (subjectsToUpdateFromColnodToDB.contains("empty")) {
qDebug() << "All subjects are up to date"; qDebug() << "All subjects are up to date";
return; return;
} }
//QSqlDatabase::database().transaction(); //QSqlDatabase::database().transaction();
qDebug() << "Subjects in progress..."; qDebug() << "Subjects in progress...";
for (auto subject : subjectsColnod) for (const auto& subject : subjectsToUpdateFromColnodToDB)
{ {
db->saveSubject(subject, "colnod_subject"); db->saveSubject(subject, "colnod_subject");
db->saveSubjectAttribute(subject, "colnod_subject_attribute"); db->saveSubjectAttributes(subject, "colnod_subject_attribute");
} }
//QSqlDatabase::database().commit(); //QSqlDatabase::database().commit();
qDebug() << subjectsColnod.size() << " subjects has been updated"; qDebug() << subjectsToUpdateFromColnodToDB.size() << " subjects has been updated";
} }
// update tokens from colnod to DB
void DataManager::pushTokensToDB() void DataManager::pushTokensToDB()
{ {
if (tokensToUpdateColnod.contains("empty")) if (tokensToUpdateFromColnodToDB.contains("empty"))
{ {
qDebug() << "All tokens are up to date"; qDebug() << "All tokens are up to date";
return; return;
} }
//QSqlDatabase::database().transaction(); //QSqlDatabase::database().transaction();
qDebug() << "Tokens in progress..."; qDebug() << "Tokens in progress...";
for (auto token : tokensToUpdateColnod) for (const auto& token : tokensToUpdateFromColnodToDB)
{ {
db->saveToken(token, "colnod_token"); db->saveToken(token, "colnod_token");
} }
//QSqlDatabase::database().commit(); //QSqlDatabase::database().commit();
qDebug() << tokensToUpdateColnod.size() << " tokens has been updated"; qDebug() << tokensToUpdateFromColnodToDB.size() << " tokens has been updated";
} }
void DataManager::deleteSubjectsFromDB() void DataManager::deleteSubjectsFromDB()
{ {
if (subjectsToDeleteColnod[0] == "empty") if (subjectsFromColnodToDeleteFromDB[0] == "empty")
{ {
qDebug() << "No subjects to be deleted"; qDebug() << "No subjects to be deleted";
return; return;
} }
qDebug() << "Deleted subjects in progress..."; qDebug() << "Deleted subjects in progress...";
for (auto subjectId : subjectsToDeleteColnod) for (const auto& subjectId : subjectsFromColnodToDeleteFromDB)
{ {
db->setDeleted(subjectId, "colnod_subject"); db->setDeleted(subjectId, "colnod_subject");
} }
qDebug() << subjectsToDeleteColnod.size() << "subject has beed deleted"; qDebug() << subjectsFromColnodToDeleteFromDB.size() << "subject has beed deleted";
} }
void DataManager::deleteTokensFromDB() // "delete" (set deleted true) tokens in DB depends on Colnod
void DataManager::setDeletedToTokensFromDB()
{ {
if (tokensToDeleteColnod[0] == "empty") if (tokensFromColnodToDeleteFromDB[0] == "empty")
{ {
qDebug() << "No tokens to be deleted"; qDebug() << "No tokens to be deleted";
return; return;
} }
qDebug() << "Deleted tokens in progress..."; qDebug() << "Deleted tokens in progress...";
for (auto tokenId : tokensToDeleteColnod) for (const auto& tokenId : tokensFromColnodToDeleteFromDB)
{ {
db->setDeleted(tokenId, "colnod_token"); db->setDeleted(tokenId, "colnod_token");
} }
qDebug() << tokensToDeleteColnod.size() << "tokens has beed deleted"; qDebug() << tokensFromColnodToDeleteFromDB.size() << "tokens has beed deleted";
}
bool DataManager::haveData()
{
if ( !subjectsColnod.isEmpty() && !tokensToUpdateColnod.isEmpty() )
return true;
return false;
} }
// do I have loaded all data
bool DataManager::haveChangedData() bool DataManager::haveChangedData()
{ {
if ( !subjectsColnod.isEmpty() && return !subjectsToUpdateFromColnodToDB.isEmpty() &&
!tokensToUpdateColnod.isEmpty() && !tokensToUpdateFromColnodToDB.isEmpty() &&
!subjectsToDeleteColnod.isEmpty() && !subjectsFromColnodToDeleteFromDB.isEmpty() &&
!tokensToDeleteColnod.isEmpty() && !tokensFromColnodToDeleteFromDB.isEmpty() &&
!fullTokensColnod.isEmpty() ) !allTokensFromColnod.isEmpty();
return true;
return false;
}
bool DataManager::haveProcessData()
{
if ( !tokensToUpdateColnod.isEmpty() && !tokensToDeleteColnod.isEmpty())
return true;
return false;
} }
// recreate working tables
void DataManager::emptyDatabase() void DataManager::emptyDatabase()
{ {
db->dropTables(); db->dropTables();
db->createTables(); db->createTables();
} }
//clear all structures
void DataManager::clear() void DataManager::clear()
{ {
subjectsColnod.clear(); subjectsToUpdateFromColnodToDB.clear();
subjectsToDeleteColnod.clear(); subjectsFromColnodToDeleteFromDB.clear();
tokensToUpdateColnod.clear(); tokensToUpdateFromColnodToDB.clear();
tokensToDeleteColnod.clear(); tokensFromColnodToDeleteFromDB.clear();
subjectsDB.clear(); //subjectsDB.clear(); // not need yet
subjectsToDeleteDB.clear(); // subjectsToDeleteDB.clear(); // not need yet
tokensToUpdateDB.clear(); tokensToUpdateFromDBToColnod.clear();
tokensToDeleteDB.clear(); tokensFromDBToDeleteFromColnod.clear();
fullTokensColnod.clear(); allTokensFromColnod.clear();
} }
// on the very end of sync update last sync time to begin time of this sync
void DataManager::updateLastSync() void DataManager::updateLastSync()
{ {
db->updateLastSync(nextLastSync); 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() void DataManager::filterTokensDB()
{ {
for (auto token : tokensToUpdateDB) for (auto token : tokensToUpdateFromDBToColnod)
{ {
QString id = token->idToStringWithoutBraces(); QString id = token->idToStringWithoutBraces();
Q_ASSERT(token = fullTokensColnod.value(id)); Q_ASSERT(token = allTokensFromColnod.value(id)); // if working sets are loading correctly equels should never happend
if (fullTokensColnod.contains(id) && token < fullTokensColnod.value(id)) if (allTokensFromColnod.contains(id) && token < allTokensFromColnod.value(id))
tokensToUpdateDB.remove(id); tokensToUpdateFromDBToColnod.remove(id);
} }
} }
void DataManager::filterTokensColnod() void DataManager::filterTokensColnod()
{ {
for (auto token : tokensToUpdateColnod) for (const auto &token : tokensToUpdateFromColnodToDB)
{ {
QString id = token->idToStringWithoutBraces(); QString id = token->idToStringWithoutBraces();
auto record = db->getToken(id); auto record = db->getToken(id);
@ -261,39 +263,14 @@ void DataManager::filterTokensColnod()
tokenDB->fromSQLRecord(record); tokenDB->fromSQLRecord(record);
Q_ASSERT(tokenDB != token); Q_ASSERT(tokenDB != token);
if (tokenDB > token) if (tokenDB > token)
tokensToUpdateColnod.remove(id); tokensToUpdateFromColnodToDB.remove(id);
} }
} }
// old version // sync last update in colnod and DB
void DataManager::loadTokensToAdd()
{
QSqlQuery* query = db->getTokensToAdd();
while (query->next())
{
Token* token = new Token(query->value(0).toString(), query->value(1).toString());
token->setSubjectId(db->getId(token->getName()));
tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token);
}
if (tokensToUpdateDB.isEmpty())
tokensToUpdateDB.insert("empty", nullptr);
}
void DataManager::loadTokensToDelete()
{
QSqlQuery* query = db->getTokensToDelete();
while (query->next())
{
tokensToDeleteDB.append(query->value(0).toString());
}
if (tokensToDeleteDB.isEmpty())
tokensToDeleteDB.append("empty");
}
void DataManager::setLastUpdate() void DataManager::setLastUpdate()
{ {
for (auto token : tokensToUpdateColnod){ for (const auto &token : tokensToUpdateFromColnodToDB){
db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate()); db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
} }
} }

49
src/colnod/datamanager.h
View File

@ -17,16 +17,15 @@ class DataManager : public QObject
public: public:
DataManager(); DataManager();
void getAndSetLastSync(); void fillFullTokensColnod(const QString& jsonResponse);
void fillFullTokensColnod(QString jsonResponse);
void fillTokensColnod(QString jsonResponse); void fillTokensToUpdateColnod(const QString& jsonResponse);
void fillSubjectsColnod(QString jsonResponse); void fillSubjectsToUpdateColnod(const QString& jsonResponse);
void fillSubjectsToDeleteColnod(QString jsonResponse); void fillSubjectsToDeleteColnod(const QString& jsonResponse);
void fillTokensToDeleteColnod(QString jsonResponse); void fillTokensToDeleteColnod(const QString& jsonResponse);
void fillTokensDB(); void fillTokensToUpdateDB();
void fillSubjectsDB(); void fillSubjectsToUpdateDB();
void fillSubjectsToDeleteDB(); void fillSubjectsToDeleteDB();
void filterTokensDB(); void filterTokensDB();
@ -35,23 +34,18 @@ public:
void pushSubjectsToDB(); void pushSubjectsToDB();
void pushTokensToDB(); void pushTokensToDB();
void deleteSubjectsFromDB(); void deleteSubjectsFromDB();
void deleteTokensFromDB(); void setDeletedToTokensFromDB();
void updateLastSync(); void updateLastSync();
bool haveData();
bool haveChangedData(); bool haveChangedData();
bool haveProcessData();
void emptyDatabase(); void emptyDatabase();
void loadTokensToAdd(); QHash<QString, QPointer<Token>> getTokensToUpdateColnod() {return tokensToUpdateFromColnodToDB;}
void loadTokensToDelete(); QList<QString> getTokensToDeleteColnod() {return tokensFromColnodToDeleteFromDB;}
QHash<QString, QPointer<Token>> getTokensToUpdateDB() {return tokensToUpdateFromDBToColnod;}
QHash<QString, QPointer<Token>> getTokensToUpdateColnod() {return tokensToUpdateColnod;} QList<QString> getTokensToDeleteDB() {return tokensFromDBToDeleteFromColnod;}
QList<QString> getTokensToDeleteColnod() {return tokensToDeleteColnod;}
QHash<QString, QPointer<Token>> getTokensToUpdateDB() {return tokensToUpdateDB;}
QList<QString> getTokensToDeleteDB() {return tokensToDeleteDB;}
const quint64 &getLastSync() {return lastSync;} const quint64 &getLastSync() {return lastSync;}
const quint64 &getActualSync() {return nextLastSync;} const quint64 &getActualSync() {return nextLastSync;}
@ -64,20 +58,19 @@ public slots:
private: private:
DatabaseManager *db = nullptr; DatabaseManager *db = nullptr;
quint64 lastSync; quint64 lastSync; // time of last run
quint64 nextLastSync; quint64 nextLastSync; // time of begin of this run
QHash<QString, QPointer<Subject>> subjectsColnod; QHash<QString, QPointer<Subject>> subjectsToUpdateFromColnodToDB;
QHash<QString, QPointer<Token>> tokensToUpdateColnod; QHash<QString, QPointer<Token>> tokensToUpdateFromColnodToDB;
QHash<QString, QPointer<Token>> fullTokensColnod; QHash<QString, QPointer<Token>> allTokensFromColnod;
QHash<QString, QPointer<Subject>> subjectsDB; // in future QHash<QString, QPointer<Subject>> subjectsDB; // in future
QHash<QString, QPointer<Token>> tokensToUpdateDB; QHash<QString, QPointer<Token>> tokensToUpdateFromDBToColnod;
QList<QString> subjectsFromColnodToDeleteFromDB;
QList<QString> subjectsToDeleteColnod; QList<QString> tokensFromColnodToDeleteFromDB;
QList<QString> tokensToDeleteColnod;
QList<QString> subjectsToDeleteDB; QList<QString> subjectsToDeleteDB;
QList<QString> tokensToDeleteDB; QList<QString> tokensFromDBToDeleteFromColnod;
}; };

4
src/colnod/entity.h
View File

@ -27,11 +27,11 @@ public:
virtual void fromJSON(const QJsonObject &json); virtual void fromJSON(const QJsonObject &json);
virtual QJsonObject toJSON() const; virtual QJsonObject toJSON() const;
protected: private:
QUuid id; QUuid id;
QString name; QString name;
QString description; QString description;
qint64 lastUpdate; qint64 lastUpdate{};
}; };

54
src/colnod/requestmanager.cpp
View File

@ -4,15 +4,7 @@ RequestManager::RequestManager()
{ {
manager = new QNetworkAccessManager(); manager = new QNetworkAccessManager();
token = ""; token = "";
loginStatus = false; //should be false, true for testing request header loginStatus = false;
/*
QFile configFile(QDir::current().filePath("config.json"));
if (!configFile.open(QIODevice::ReadOnly)) {
qCritical() << "Couldn't open config file config.json" << QDir::current().filePath("config.json");
QCoreApplication::exit(-1);
return;
}
this->config = QJsonDocument::fromJson(configFile.readAll());*/
QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError); QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
} }
@ -53,7 +45,7 @@ Response* RequestManager::login()
return loginResponse; return loginResponse;
} }
QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json) QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
{ {
QNetworkRequest request; QNetworkRequest request;
request.setUrl(host + endpoint); request.setUrl(host + endpoint);
@ -75,26 +67,21 @@ QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json)
return reply; return reply;
} }
// This will ensure login is called only once
Response* RequestManager::getLoginResponse() { Response* RequestManager::getLoginResponse() {
if (!loginResponse){ if (!loginResponse){
loginResponse = login(); loginResponse = login();
} }
return loginResponse; return loginResponse;
} }
Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray data) Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
{ {
auto loginResponse = getLoginResponse(); auto loginResponse = getLoginResponse();
// This will ensure login is called only once
Q_ASSERT(loginResponse); Q_ASSERT(loginResponse);
Response* response = new Response; auto* response = new Response;
if (!loginStatus){ if (!loginStatus){
connect(this, &RequestManager::successLogin, [=](){ connect(this, &RequestManager::successLogin, [=](){
response->setReply(postRequest(endpoint, data)); response->setReply(postRequest(endpoint, data));
connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready); connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
@ -108,9 +95,10 @@ Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray da
return response; return response;
} }
QString RequestManager::getFromJson(QString json, const QString &member) // get value of member in json
QString RequestManager::getFromJson(const QString& json, const QString &member)
{ {
QJsonParseError err; QJsonParseError err{};
QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err); QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
if (err.error != 0) if (err.error != 0)
{ {
@ -119,12 +107,12 @@ QString RequestManager::getFromJson(QString json, const QString &member)
return document.object().value(member).toString(); return document.object().value(member).toString();
} }
QString RequestManager::encryptedPassword(QString password) QString RequestManager::encryptedPassword(const QString& password)
{ {
return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper(); return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
} }
QString RequestManager::getLoginHeader(QString username, QString hash) QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
{ {
QString authValue = username + ":" + hash; QString authValue = username + ":" + hash;
return "Basic " + authValue.toLocal8Bit().toBase64(); return "Basic " + authValue.toLocal8Bit().toBase64();
@ -150,7 +138,7 @@ void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &er
} }
QByteArray RequestManager::makeTimeStampJson(uint64_t time) QByteArray RequestManager::makeTimestampJson(uint64_t time)
{ {
QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }}; QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }};
QJsonDocument doc; QJsonDocument doc;
@ -162,7 +150,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
{ {
QJsonObject items; QJsonObject items;
QJsonArray jsonTokens; QJsonArray jsonTokens;
for (auto token : tokens) for (const auto& token : tokens)
{ {
jsonTokens.push_back(token->toJSON()); jsonTokens.push_back(token->toJSON());
} }
@ -175,7 +163,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
QByteArray RequestManager::makeIdsJson(const QList<QString> &ids) QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
{ {
QJsonArray jsonIds; QJsonArray jsonIds;
for (auto id : ids) for (const auto& id : ids)
{ {
jsonIds.push_back(id); jsonIds.push_back(id);
} }
@ -203,22 +191,22 @@ Response* RequestManager::getTokenSubject()
Response* RequestManager::getSubjectsUpdated(uint64_t time) Response* RequestManager::getSubjectsUpdated(uint64_t time)
{ {
return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimeStampJson(time)); return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(time));
} }
Response* RequestManager::getSubjectsDeleted(uint64_t time) Response* RequestManager::getSubjectsDeleted(uint64_t time)
{ {
return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimeStampJson(time)); return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimestampJson(time));
} }
Response* RequestManager::getTokensUpdated(uint64_t time) Response* RequestManager::getTokensUpdated(uint64_t time)
{ {
return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimeStampJson(time)); return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
} }
Response* RequestManager::getTokensDeleted(uint64_t time) Response* RequestManager::getTokensDeleted(uint64_t time)
{ {
return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimeStampJson(time)); return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
} }
Response* RequestManager::getAccessGroups() Response* RequestManager::getAccessGroups()
@ -228,12 +216,12 @@ Response* RequestManager::getAccessGroups()
Response* RequestManager::getAccessGroupsUpdated(uint64_t time) Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
{ {
return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimeStampJson(time)); return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
} }
Response* RequestManager::getAccessGroupsDeleted(uint64_t time) Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
{ {
return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimeStampJson(time)); return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
} }
Response* RequestManager::getAccessGroupMembership() Response* RequestManager::getAccessGroupMembership()
@ -243,12 +231,12 @@ Response* RequestManager::getAccessGroupMembership()
Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time) Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
{ {
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimeStampJson(time)); return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(time));
} }
Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time) Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time)
{ {
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimeStampJson(time)); return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimestampJson(time));
} }
Response* RequestManager::setTokens(const QHash<QString, QPointer<Token> > &tokens) Response* RequestManager::setTokens(const QHash<QString, QPointer<Token> > &tokens)

12
src/colnod/requestmanager.h
View File

@ -58,13 +58,13 @@ public:
const QString &getResponse() const {return jsonResponse;} const QString &getResponse() const {return jsonResponse;}
private: private:
QNetworkReply* postRequest(QString endpoint, QByteArray json = QByteArray()); QNetworkReply* postRequest(const QString& endpoint, const QByteArray& json = QByteArray());
Response* postRequestReturnLogic(QString endpoint, QByteArray data = QByteArray()); Response* postRequestReturnLogic(const QString& endpoint, const QByteArray& data = QByteArray());
QString getFromJson(QString json, const QString &member); QString getFromJson(const QString& json, const QString &member);
QString encryptedPassword(QString password); QString encryptedPassword(const QString& password);
QString getLoginHeader(QString username, QString hash); QString getLoginHeader(const QString& username, const QString& hash);
QByteArray makeTimeStampJson(uint64_t time); QByteArray makeTimestampJson(uint64_t time);
QByteArray makeTokensJson(const QHash<QString, QPointer<Token>> &tokens); QByteArray makeTokensJson(const QHash<QString, QPointer<Token>> &tokens);
QByteArray makeIdsJson(const QList<QString> &ids); QByteArray makeIdsJson(const QList<QString> &ids);
Response* getLoginResponse(); Response* getLoginResponse();

10
src/colnod/subject.cpp
View File

@ -4,9 +4,9 @@
#include <QJsonArray> #include <QJsonArray>
Subject::Subject(QString namee) Subject::Subject(QString name)
{ {
this->name = namee; setName(std::move(name));
} }
QString Subject::getEmail() const { QString Subject::getEmail() const {
@ -17,10 +17,10 @@ void Subject::fromJSON(const QJsonObject &json) {
Entity::fromJSON(json); Entity::fromJSON(json);
attributes = json.value("attributes").toObject().value("items").toObject(); attributes = json.value("attributes").toObject().value("items").toObject();
for (int i = 0; i < attributeTypes->length(); i++) for (const auto & attributeType : attributeTypes)
{ {
if (!attributes[attributeTypes[i]].toString().isEmpty()){ if (!attributes[attributeType].toString().isEmpty()){
atr.append(qMakePair(attributeTypes[i], attributes[attributeTypes[i]].toString())); atr.append(qMakePair(attributeType, attributes[attributeType].toString()));
} }
} }
const auto &tokenFlagsArray = json.value("tokenFlags").toArray(); const auto &tokenFlagsArray = json.value("tokenFlags").toArray();

6
src/colnod/subject.h
View File

@ -12,7 +12,7 @@ class Subject : public Entity {
public: public:
using Entity::Entity; using Entity::Entity;
Subject() = default;
Subject(QString name); Subject(QString name);
QString getEmail() const; QString getEmail() const;
@ -33,14 +33,14 @@ public:
void fromJSON(const QJsonObject &json) override; void fromJSON(const QJsonObject &json) override;
QJsonObject toJSON() const override; QJsonObject toJSON() const override;
protected: private:
QJsonObject attributes; QJsonObject attributes;
QSet<QString> tokenFlags; QSet<QString> tokenFlags;
QString pin; QString pin;
QSet<QString> pinFlags; QSet<QString> pinFlags;
//QList<QPointer<Attribute>> atr; //QList<QPointer<Attribute>> atr;
QList<QPair<QString, QString>> atr; QList<QPair<QString, QString>> atr;
const QString attributeTypes[6] = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"}; const std::array<QString, 6> attributeTypes = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"};
}; };

23
src/colnod/token.cpp
View File

@ -1,13 +1,14 @@
#include "token.h" #include "token.h"
#include <QJsonArray> #include <QJsonArray>
#include <utility>
Token::Token(QString namee, QString tokenData, QString decription) Token::Token(QString name, QString tokenData, QString decription)
{ {
this->name = namee; this->setName(std::move(name));
this->tokenData = tokenData; this->tokenData = std::move(tokenData);
this->description = decription; this->setDescription(std::move(decription));
this->id = QUuid::createUuid(); this->setId(QUuid::createUuid());
this->tokenType = "Token"; this->tokenType = "Token";
this->tokenBits = 32; this->tokenBits = 32;
this->timeToLive = 255; this->timeToLive = 255;
@ -16,9 +17,9 @@ Token::Token(QString namee, QString tokenData, QString decription)
} }
Token::Token(QString namee) Token::Token(QString name)
{ {
this->name = namee; this->setName(std::move(name));
} }
@ -57,17 +58,17 @@ QJsonObject Token::toJSON() const {
void Token::fromSQLRecord(QSqlQuery *query) void Token::fromSQLRecord(QSqlQuery *query)
{ {
id = query->value(0).toUuid(); setId(query->value(0).toUuid());
authErrors = query->value(1).toInt(); authErrors = query->value(1).toInt();
description = query->value(2).toString(); setDescription(query->value(2).toString());
QSet<QString> flags; QSet<QString> flags;
if (query->value(6).toBool()) if (query->value(6).toBool())
flags.insert("NoValidity"); flags.insert("NoValidity");
if (query->value(3).toBool()) if (query->value(3).toBool())
flags.insert("Enabled"); flags.insert("Enabled");
this->flags = flags; this->flags = flags;
lastUpdate = query->value(4).toUInt(); setLastUpdate(query->value(4).toUInt());
name = query->value(5).toString(); setName(query->value(5).toString());
timeToLive = query->value(7).toInt(); timeToLive = query->value(7).toInt();
tokenBits = query->value(8).toInt(); tokenBits = query->value(8).toInt();
tokenData = query->value(9).toString(); tokenData = query->value(9).toString();

17
src/colnod/token.h
View File

@ -51,18 +51,19 @@ public:
void fromSQLRecord(QSqlQuery* query); void fromSQLRecord(QSqlQuery* query);
void fromJSON(const QJsonObject &json) override; void fromJSON(const QJsonObject &json) override;
QJsonObject toJSON() const override; QJsonObject toJSON() const override;
protected:
private:
QString tokenType; QString tokenType;
int tokenBits; int tokenBits{};
QString tokenData; QString tokenData;
quint64 validFrom; qint64 validFrom{};
quint64 validTo; qint64 validTo{};
int timeToLive; int timeToLive{};
int authErrors; int authErrors{};
QSet<QString> flags; QSet<QString> flags;
QUuid subjectId; QUuid subjectId;
quint64 lastModified; quint64 lastModified{};
bool deleted; bool deleted{};
}; };

107
test/unitTests/UnitTest.cpp
View File

@ -7,12 +7,11 @@ void UnitTest::initTestCase()
void UnitTest::loginSuccessfully() void UnitTest::loginSuccessfully()
{ {
RequestManager* testAccess = new RequestManager(); auto testAccess = new RequestManager();
QJsonDocument config = testAccess->getConfig();
QSignalSpy spy(testAccess, SIGNAL(successLogin())); QSignalSpy spy(testAccess, SIGNAL(successLogin()));
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
testAccess->login(); testAccess->login();
spy.wait(15000); spy.wait(timeout);
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = testAccess->getResponse(); QString json = testAccess->getResponse();
@ -24,13 +23,13 @@ void UnitTest::loginSuccessfully()
//POST request w/o datas //POST request w/o datas
void UnitTest::getSubjects() void UnitTest::getSubjects()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
Response* response = testAccess->getSubjects(); Response* response = testAccess->getSubjects();
QSignalSpy spy1(response, &Response::ready); QSignalSpy spy1(response, &Response::ready);
spy.wait(15000); spy.wait(timeout);
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QCOMPARE(spy1.count(), 1); QCOMPARE(spy1.count(), 1);
@ -45,11 +44,11 @@ void UnitTest::getSubjects()
void UnitTest::getTokens() void UnitTest::getTokens()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
Response* response = testAccess->getTokens(); Response* response = testAccess->getTokens();
QSignalSpy spy(response, &Response::ready); QSignalSpy spy(response, &Response::ready);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -62,11 +61,11 @@ void UnitTest::getTokens()
void UnitTest::getTokenSubject() void UnitTest::getTokenSubject()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getTokenSubject(); Response* response = testAccess->getTokenSubject();
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -75,11 +74,11 @@ void UnitTest::getTokenSubject()
void UnitTest::getSubjectsUpdated() void UnitTest::getSubjectsUpdated()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getSubjectsUpdated(1568646217767); Response* response = testAccess->getSubjectsUpdated(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -88,11 +87,11 @@ void UnitTest::getSubjectsUpdated()
void UnitTest::getSubjectsDeleted() void UnitTest::getSubjectsDeleted()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getSubjectsDeleted(1568646217767); Response* response = testAccess->getSubjectsDeleted(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -101,11 +100,11 @@ void UnitTest::getSubjectsDeleted()
void UnitTest::getTokensUpdated() void UnitTest::getTokensUpdated()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getTokensUpdated(1570109859681); Response* response = testAccess->getTokensUpdated(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -114,11 +113,11 @@ void UnitTest::getTokensUpdated()
void UnitTest::getTokensDeleted() void UnitTest::getTokensDeleted()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getTokensDeleted(1570109859681); Response* response = testAccess->getTokensDeleted(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -127,11 +126,11 @@ void UnitTest::getTokensDeleted()
void UnitTest::getAccessGroups() void UnitTest::getAccessGroups()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroups(); Response* response = testAccess->getAccessGroups();
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -140,11 +139,11 @@ void UnitTest::getAccessGroups()
void UnitTest::getAccessGroupsUpdated() void UnitTest::getAccessGroupsUpdated()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroupsUpdated(1568646217767); Response* response = testAccess->getAccessGroupsUpdated(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -153,11 +152,11 @@ void UnitTest::getAccessGroupsUpdated()
void UnitTest::getAccessGroupsDeleted() void UnitTest::getAccessGroupsDeleted()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroupsDeleted(1568646217767); Response* response = testAccess->getAccessGroupsDeleted(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -166,11 +165,11 @@ void UnitTest::getAccessGroupsDeleted()
void UnitTest::getAccessGroupMembership() void UnitTest::getAccessGroupMembership()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroupMembership(); Response* response = testAccess->getAccessGroupMembership();
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -179,11 +178,11 @@ void UnitTest::getAccessGroupMembership()
void UnitTest::getAccessGroupMembershipUpdated() void UnitTest::getAccessGroupMembershipUpdated()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroupMembershipUpdated(1568646217767); Response* response = testAccess->getAccessGroupMembershipUpdated(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -192,11 +191,11 @@ void UnitTest::getAccessGroupMembershipUpdated()
void UnitTest::getAccessGroupMembershipDeleted() void UnitTest::getAccessGroupMembershipDeleted()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getAccessGroupMembershipDeleted(1568646217767); Response* response = testAccess->getAccessGroupMembershipDeleted(epochMS);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -220,11 +219,11 @@ void UnitTest::setTokens()
qDebug() << token; qDebug() << token;
tokens.insert(token->idToStringWithoutBraces(), token); tokens.insert(token->idToStringWithoutBraces(), token);
} }
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->setTokens(tokens); Response* response = testAccess->setTokens(tokens);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -233,14 +232,14 @@ void UnitTest::setTokens()
void UnitTest::deleteTokens() void UnitTest::deleteTokens()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
QList<QString> ids; QList<QString> ids;
ids.append("582c982d-6fd7-4856-8548-7ce542791c7a"); ids.append("582c982d-6fd7-4856-8548-7ce542791c7a");
ids.append("3ff23b41-3da3-4b33-82ce-d8e2d8c9a546"); ids.append("3ff23b41-3da3-4b33-82ce-d8e2d8c9a546");
Response* response = testAccess->deleteTokens(ids); Response* response = testAccess->deleteTokens(ids);
QCOMPARE(spy.count(), 0); QCOMPARE(spy.count(), 0);
spy.wait(15000); spy.wait(timeout);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QString json = response->getJson(); QString json = response->getJson();
@ -262,10 +261,10 @@ void UnitTest::subjectJSONParser()
QJsonObject obj = doc.object(); QJsonObject obj = doc.object();
QJsonArray arr = obj["items"].toArray(); QJsonArray arr = obj["items"].toArray();
*/ */
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getSubjects(); Response* response = testAccess->getSubjects();
spy.wait(15000); spy.wait(timeout);
QString json = response->getJson(); QString json = response->getJson();
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QJsonArray arr = doc.object()["items"].toArray(); QJsonArray arr = doc.object()["items"].toArray();
@ -277,10 +276,10 @@ void UnitTest::subjectJSONParser()
void UnitTest::tokenJSONParser() void UnitTest::tokenJSONParser()
{ {
RequestManager* testAccess = new RequestManager(); auto* testAccess = new RequestManager();
QSignalSpy spy(testAccess, SIGNAL(responseReady())); QSignalSpy spy(testAccess, SIGNAL(responseReady()));
Response* response = testAccess->getTokens(); Response* response = testAccess->getTokens();
spy.wait(15000); spy.wait(timeout);
QString json = response->getJson(); QString json = response->getJson();
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
QJsonArray arr = doc.object()["items"].toArray(); QJsonArray arr = doc.object()["items"].toArray();
@ -290,15 +289,15 @@ void UnitTest::tokenJSONParser()
QVERIFY(!testToken->getName().isEmpty()); QVERIFY(!testToken->getName().isEmpty());
} }
void UnitTest::connectToDB() //void UnitTest::connectToDB()
{ //{
DatabaseManager *db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12"); // DatabaseManager *db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
QVERIFY(db->getOpened()); // QVERIFY(db->getOpened());
qDebug() << db->getTestMessage(1); // qDebug() << db->getTestMessage(1);
QVERIFY(true); // QVERIFY(true);
QCOMPARE(db->getTestMessage(1), QStringLiteral("Hello world")); // QCOMPARE(db->getTestMessage(1), QStringLiteral("Hello world"));
QCOMPARE(db->getTestMessage(db->createTestRecord("Now it's diffrent")), QStringLiteral("Now it's diffrent")); // QCOMPARE(db->getTestMessage(db->createTestRecord("Now it's diffrent")), QStringLiteral("Now it's diffrent"));
} //}
/* /*
void UnitTest::debugConnection() void UnitTest::debugConnection()

36
test/unitTests/complextest.cpp
View File

@ -9,7 +9,7 @@ void ComplexTest::initTestCase()
Response* deleteTokensResp = reqMan1->deleteTokens(ids); Response* deleteTokensResp = reqMan1->deleteTokens(ids);
QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready); QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
QCOMPARE(deleteTokensRespSpy.count(), 0); QCOMPARE(deleteTokensRespSpy.count(), 0);
deleteTokensRespSpy.wait(10000); deleteTokensRespSpy.wait(timeout);
QTest::qWait(2500); QTest::qWait(2500);
start = QDateTime::currentMSecsSinceEpoch()-2000; start = QDateTime::currentMSecsSinceEpoch()-2000;
api = new ColnodAPI; api = new ColnodAPI;
@ -26,7 +26,7 @@ void ComplexTest::cleanupTestCase()
Response* deleteTokensResp = reqMan->deleteTokens(ids); Response* deleteTokensResp = reqMan->deleteTokens(ids);
QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready); QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
QCOMPARE(deleteTokensRespSpy.count(), 0); QCOMPARE(deleteTokensRespSpy.count(), 0);
deleteTokensRespSpy.wait(10000); deleteTokensRespSpy.wait(timeout);
QCOMPARE(deleteTokensRespSpy.count(), 1); QCOMPARE(deleteTokensRespSpy.count(), 1);
} }
@ -39,7 +39,7 @@ void ComplexTest::complexTest()
QSignalSpy loginRespSpy(loginResp, &Response::ready); QSignalSpy loginRespSpy(loginResp, &Response::ready);
QCOMPARE(loginSpy.count(), 0); QCOMPARE(loginSpy.count(), 0);
QCOMPARE(loginRespSpy.count(), 0); QCOMPARE(loginRespSpy.count(), 0);
loginSpy.wait(10000); loginSpy.wait(timeout);
QCOMPARE(loginResp->getStatusCode(), 200); // HTTP status code check QCOMPARE(loginResp->getStatusCode(), 200); // HTTP status code check
QCOMPARE(loginSpy.count(), 1); // Checking multiple calls QCOMPARE(loginSpy.count(), 1); // Checking multiple calls
QCOMPARE(loginRespSpy.count(), 1); QCOMPARE(loginRespSpy.count(), 1);
@ -62,7 +62,7 @@ void ComplexTest::complexTest()
Response* setTokensResp = reqMan->setTokens(tokens); Response* setTokensResp = reqMan->setTokens(tokens);
QSignalSpy setTokensRespSpy(setTokensResp, &Response::ready); QSignalSpy setTokensRespSpy(setTokensResp, &Response::ready);
QCOMPARE(setTokensRespSpy.count(), 0); QCOMPARE(setTokensRespSpy.count(), 0);
setTokensRespSpy.wait(10000); setTokensRespSpy.wait(timeout);
QCOMPARE(setTokensRespSpy.count(), 1); QCOMPARE(setTokensRespSpy.count(), 1);
QCOMPARE(setTokensResp->getStatusCode(), 200); QCOMPARE(setTokensResp->getStatusCode(), 200);
QCOMPARE(getNumOfTokens(), numOfTokens + 1); QCOMPARE(getNumOfTokens(), numOfTokens + 1);
@ -73,7 +73,7 @@ void ComplexTest::complexTest()
//start = QDateTime::currentMSecsSinceEpoch(); //start = QDateTime::currentMSecsSinceEpoch();
QSignalSpy getTokensUpdatedRespSpy(getTokensUpdatedResp, &Response::ready); QSignalSpy getTokensUpdatedRespSpy(getTokensUpdatedResp, &Response::ready);
QCOMPARE(getTokensUpdatedRespSpy.count(), 0); QCOMPARE(getTokensUpdatedRespSpy.count(), 0);
getTokensUpdatedRespSpy.wait(10000); getTokensUpdatedRespSpy.wait(timeout);
QCOMPARE(getTokensUpdatedResp->getStatusCode(), 200); QCOMPARE(getTokensUpdatedResp->getStatusCode(), 200);
QCOMPARE(getTokensUpdatedRespSpy.count(), 1); QCOMPARE(getTokensUpdatedRespSpy.count(), 1);
auto doc1 = getJsonDoc(getTokensUpdatedResp->getJson()); auto doc1 = getJsonDoc(getTokensUpdatedResp->getJson());
@ -86,7 +86,7 @@ void ComplexTest::complexTest()
Response* deleteTokensResp = reqMan->deleteTokens(ids); Response* deleteTokensResp = reqMan->deleteTokens(ids);
QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready); QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
QCOMPARE(deleteTokensRespSpy.count(), 0); QCOMPARE(deleteTokensRespSpy.count(), 0);
deleteTokensRespSpy.wait(10000); deleteTokensRespSpy.wait(timeout);
QCOMPARE(deleteTokensRespSpy.count(), 1); QCOMPARE(deleteTokensRespSpy.count(), 1);
QCOMPARE(deleteTokensResp->getStatusCode(), 200); QCOMPARE(deleteTokensResp->getStatusCode(), 200);
// DELETE_TOKENS_CHECK_END // DELETE_TOKENS_CHECK_END
@ -96,7 +96,7 @@ void ComplexTest::complexTest()
start = QDateTime::currentMSecsSinceEpoch(); start = QDateTime::currentMSecsSinceEpoch();
QSignalSpy getTokensDeletedRespSpy(getTokensDeletedResp, &Response::ready); QSignalSpy getTokensDeletedRespSpy(getTokensDeletedResp, &Response::ready);
QCOMPARE(getTokensDeletedRespSpy.count(), 0); QCOMPARE(getTokensDeletedRespSpy.count(), 0);
getTokensDeletedRespSpy.wait(10000); getTokensDeletedRespSpy.wait(timeout);
QCOMPARE(getTokensDeletedResp->getStatusCode(), 200); QCOMPARE(getTokensDeletedResp->getStatusCode(), 200);
QCOMPARE(getTokensDeletedRespSpy.count(), 1); QCOMPARE(getTokensDeletedRespSpy.count(), 1);
auto doc2 = getJsonDoc(getTokensDeletedResp->getJson()); auto doc2 = getJsonDoc(getTokensDeletedResp->getJson());
@ -119,7 +119,7 @@ void ComplexTest::fullSync()
api->prepareDatabase(); api->prepareDatabase();
api->loadDataFromColnod(); api->loadDataFromColnod();
QSignalSpy spy(api, &ColnodAPI::dataDownloaded); QSignalSpy spy(api, &ColnodAPI::dataDownloaded);
spy.wait(10000); spy.wait(timeout);
api->syncDataFromColnod(); api->syncDataFromColnod();
// api->syncDataToColnod(); // api->syncDataToColnod();
} }
@ -128,12 +128,14 @@ void ComplexTest::syncLastUpdated()
{ {
api->loadDataFromColnod(); api->loadDataFromColnod();
QSignalSpy spy(api, &ColnodAPI::dataDownloaded); QSignalSpy spy(api, &ColnodAPI::dataDownloaded);
spy.wait(10000); spy.wait(timeout);
api->loadDataFromDB(); api->loadDataFromDB();
api->syncDataFromColnod(); api->syncDataFromColnod();
api->syncDataFromDB(); api->syncDataFromDBToColnod();
QSignalSpy processSpy(api, &ColnodAPI::dataProcessed); QSignalSpy processSpy(api, &ColnodAPI::dataUpdatedToColnod);
processSpy.wait(10000); processSpy.wait(timeout);
QSignalSpy finish(api, &ColnodAPI::syncFinished);
finish.wait(timeout);
qDebug() << "All right, at least should be."; qDebug() << "All right, at least should be.";
} }
@ -150,7 +152,7 @@ int ComplexTest::getNumOfSubjects()
{ {
Response* subjectsResp = reqMan->getSubjects(); Response* subjectsResp = reqMan->getSubjects();
QSignalSpy subjectsRespSpy(subjectsResp, &Response::ready); QSignalSpy subjectsRespSpy(subjectsResp, &Response::ready);
subjectsRespSpy.wait(10000); 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();
} }
@ -159,17 +161,17 @@ int ComplexTest::getNumOfTokens()
{ {
Response* tokensResp = reqMan->getTokens(); Response* tokensResp = reqMan->getTokens();
QSignalSpy tokensRespSpy(tokensResp, &Response::ready); QSignalSpy tokensRespSpy(tokensResp, &Response::ready);
tokensRespSpy.wait(10000); 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(QString json) QJsonDocument ComplexTest::getJsonDoc(const QString &json)
{ {
return QJsonDocument::fromJson(json.toUtf8()); return QJsonDocument::fromJson(json.toUtf8());
} }
Token* ComplexTest::getTestToken() QPointer<Token> ComplexTest::getTestToken()
{ {
QJsonObject jsonToken; QJsonObject jsonToken;
jsonToken.insert("id", "582c982d-6fd7-4856-8548-7ce542791c7a"); jsonToken.insert("id", "582c982d-6fd7-4856-8548-7ce542791c7a");
@ -185,7 +187,7 @@ Token* ComplexTest::getTestToken()
flags.push_back("NoValidity"); flags.push_back("NoValidity");
jsonToken.insert("flags", flags); jsonToken.insert("flags", flags);
jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904"); jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904");
Token* token = new Token; QPointer<Token> token = new Token;
token->fromJSON(jsonToken); token->fromJSON(jsonToken);
return token; return token;
} }

6
test/unitTests/complextest.h
View File

@ -23,8 +23,8 @@ private:
// FUNCTIONS // FUNCTIONS
int getNumOfSubjects(); int getNumOfSubjects();
int getNumOfTokens(); int getNumOfTokens();
QJsonDocument getJsonDoc(QString json); QJsonDocument getJsonDoc(const QString &json);
Token* getTestToken(); QPointer<Token> getTestToken();
// VARIABLES // VARIABLES
@ -34,5 +34,7 @@ private:
RequestManager* reqMan = nullptr; RequestManager* reqMan = nullptr;
uint64_t start = 0; uint64_t start = 0;
ColnodAPI* api = nullptr; ColnodAPI* api = nullptr;
static constexpr qint16 timeout = 10000;
}; };

5
test/unitTests/unittest.h
View File

@ -37,7 +37,7 @@ private slots:
void deleteTokens(); void deleteTokens();
void subjectJSONParser(); void subjectJSONParser();
void tokenJSONParser(); void tokenJSONParser();
void connectToDB(); //void connectToDB();
//void debugConnection(); //void debugConnection();
void saveDataToDB(); void saveDataToDB();
void getUuid(); void getUuid();
@ -48,4 +48,7 @@ private:
QString host = "https://192.168.1.3:8443"; //local testing server QString host = "https://192.168.1.3:8443"; //local testing server
QString password = "spaceti1"; QString password = "spaceti1";
QString email = "spaceti"; QString email = "spaceti";
static constexpr int timeout = 10000;
static constexpr qint64 epochMS = 1568646217767;
}; };