ondra/colnod-connector
1
0
Fork 1
mirror of https://gitlab.com/spaceti-app/integrations/acs/colnod-connector.git synced 2026-07-12 13:10:45 +02:00
Code Issues 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[])
{
QCoreApplication a(argc, argv);
ColnodAPI *api = new ColnodAPI();
auto *api = new ColnodAPI();
/*api->downloadData(); // this will start downloading data
@ -31,5 +31,5 @@ int main(int argc, char *argv[])
api->loadDataFromDB();
return a.exec();
return QCoreApplication::exec();
}

150
src/colnod/colnodapi.cpp
View File

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

20
src/colnod/colnodapi.h
View File

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

99
src/colnod/databasemanager.cpp
View File

@ -1,6 +1,6 @@
#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");
@ -12,15 +12,16 @@ DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QSt
//db.setPort(80);
//
db.setPassword(password);
opened = db.open();
if (!opened)
if (!db.open())
{
qDebug() << "Opening error" + db.lastError().text();
}
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();
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();
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();
for (auto attribute : attributes){
for (const auto& attribute : attributes){
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) "
"WHERE id = :id").arg(table));
query.bindValue(":id", id);
@ -106,8 +108,7 @@ void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
query.bindValue(":subject_id", subject->idToStringWithoutBraces());
query.exec();
}
else
{
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);
@ -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();
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();
}
QString DatabaseManager::getTestMessage(int id)
{
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)
bool DatabaseManager::checkIfExists(const QString& id, const QString& table)
{
query.prepare(QString("SELECT EXISTS(SELECT 1 FROM %1 WHERE id = :id)").arg(table));
query.bindValue(":id", id);
@ -160,16 +140,23 @@ bool DatabaseManager::checkIfExists(QString id, QString table)
return query.value(0).toBool();
}
bool DatabaseManager::executeQuery(QSqlQuery &query) const
{
bool res = query.exec();
return res;
}
void DatabaseManager::dropTables()
{
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()
{
query.exec("CREATE TABLE colnod_subject ("
"id character(36) primary key NOT NULL,"
//"access_pin smallint,"
"description character varying(255),"
"last_update timestamp NOT NULL,"
"name character varying(255),"
@ -198,6 +185,7 @@ void DatabaseManager::createTables()
"subject_id CHAR(36))");
}
// return last_sync time
uint64_t DatabaseManager::getLastSync()
{
query.exec("SELECT last_sync FROM config");
@ -206,6 +194,7 @@ uint64_t DatabaseManager::getLastSync()
return temp;
}
// on the very end of sync set new Last_sync time (begin of this sync)
void DatabaseManager::updateLastSync(quint64 lastSync)
{
query.prepare("UPDATE config SET last_sync = :last_sync");
@ -213,37 +202,8 @@ void DatabaseManager::updateLastSync(quint64 lastSync)
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* qry = new QSqlQuery;
@ -252,7 +212,7 @@ QSqlQuery* DatabaseManager::getUpdatedTokens()
return qry;
}
QSqlQuery* DatabaseManager::getToken(QString id)
QSqlQuery* DatabaseManager::getToken(const QString& id)
{
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 "
@ -262,9 +222,7 @@ QSqlQuery* DatabaseManager::getToken(QString id)
if (qry->next()){
return qry;
}
else {
return nullptr;
}
}
quint64 DatabaseManager::getNow()
@ -274,7 +232,8 @@ quint64 DatabaseManager::getNow()
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.bindValue(":id", id);

39
src/colnod/databasemanager.h
View File

@ -16,53 +16,32 @@ class DatabaseManager : public QObject
{
Q_OBJECT
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, QString table);
void saveToken(Token* token, 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 saveSubject(Subject* subject, const QString& table);
void saveToken(Token* token, const QString& table);
void saveSubjectAttributes(Subject* subject, const QString& table);
void setDeleted(const QString& id, const QString& table);
void dropTables();
void createTables();
bool getOpened() {return opened;}
quint64 getLastSync();
void updateLastSync(quint64 lastSync);
quint64 getNow();
QSqlQuery* getUpdatedTokens();
QSqlQuery* getToken(QString id);
// Old version
QSqlQuery* getTokensToAdd();
QSqlQuery* getTokensToDelete();
void setLastUpdate(QString id, quint64 lastUpdate);
QUuid getId(QString name);
QSqlQuery* getToken(const QString& id);
void setLastUpdate(const QString& id, quint64 lastUpdate);
private:
bool checkIfExists(QString id, QString table);
bool checkIfExists(const QString& id, const QString& table);
bool executeQuery(QSqlQuery &query) const;
private:
QSqlDatabase db;
QSqlQuery query;
bool opened;
};
#endif // DATABASEMANAGER_H

183
src/colnod/datamanager.cpp
View File

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

49
src/colnod/datamanager.h
View File

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

54
src/colnod/requestmanager.cpp
View File

@ -4,15 +4,7 @@ RequestManager::RequestManager()
{
manager = new QNetworkAccessManager();
token = "";
loginStatus = false; //should be false, true for testing request header
/*
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());*/
loginStatus = false;
QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
}
@ -53,7 +45,7 @@ Response* RequestManager::login()
return loginResponse;
}
QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json)
QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
{
QNetworkRequest request;
request.setUrl(host + endpoint);
@ -75,26 +67,21 @@ QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json)
return reply;
}
// This will ensure login is called only once
Response* RequestManager::getLoginResponse() {
if (!loginResponse){
loginResponse = login();
}
return loginResponse;
}
Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray data)
Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
{
auto loginResponse = getLoginResponse();
// This will ensure login is called only once
Q_ASSERT(loginResponse);
Response* response = new Response;
auto* response = new Response;
if (!loginStatus){
connect(this, &RequestManager::successLogin, [=](){
response->setReply(postRequest(endpoint, data));
connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
@ -108,9 +95,10 @@ Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray da
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);
if (err.error != 0)
{
@ -119,12 +107,12 @@ QString RequestManager::getFromJson(QString json, const QString &member)
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();
}
QString RequestManager::getLoginHeader(QString username, QString hash)
QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
{
QString authValue = username + ":" + hash;
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)) }};
QJsonDocument doc;
@ -162,7 +150,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
{
QJsonObject items;
QJsonArray jsonTokens;
for (auto token : tokens)
for (const auto& token : tokens)
{
jsonTokens.push_back(token->toJSON());
}
@ -175,7 +163,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
{
QJsonArray jsonIds;
for (auto id : ids)
for (const auto& id : ids)
{
jsonIds.push_back(id);
}
@ -203,22 +191,22 @@ Response* RequestManager::getTokenSubject()
Response* RequestManager::getSubjectsUpdated(uint64_t time)
{
return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimeStampJson(time));
return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(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)
{
return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimeStampJson(time));
return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
}
Response* RequestManager::getTokensDeleted(uint64_t time)
{
return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimeStampJson(time));
return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroups()
@ -228,12 +216,12 @@ Response* RequestManager::getAccessGroups()
Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimeStampJson(time));
return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimeStampJson(time));
return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
}
Response* RequestManager::getAccessGroupMembership()
@ -243,12 +231,12 @@ Response* RequestManager::getAccessGroupMembership()
Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
{
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimeStampJson(time));
return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(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)

12
src/colnod/requestmanager.h
View File

@ -58,13 +58,13 @@ public:
const QString &getResponse() const {return jsonResponse;}
private:
QNetworkReply* postRequest(QString endpoint, QByteArray json = QByteArray());
Response* postRequestReturnLogic(QString endpoint, QByteArray data = QByteArray());
QString getFromJson(QString json, const QString &member);
QString encryptedPassword(QString password);
QString getLoginHeader(QString username, QString hash);
QNetworkReply* postRequest(const QString& endpoint, const QByteArray& json = QByteArray());
Response* postRequestReturnLogic(const QString& endpoint, const QByteArray& data = QByteArray());
QString getFromJson(const QString& json, const QString &member);
QString encryptedPassword(const QString& password);
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 makeIdsJson(const QList<QString> &ids);
Response* getLoginResponse();

10
src/colnod/subject.cpp
View File

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

6
src/colnod/subject.h
View File

@ -12,7 +12,7 @@ class Subject : public Entity {
public:
using Entity::Entity;
Subject() = default;
Subject(QString name);
QString getEmail() const;
@ -33,14 +33,14 @@ public:
void fromJSON(const QJsonObject &json) override;
QJsonObject toJSON() const override;
protected:
private:
QJsonObject attributes;
QSet<QString> tokenFlags;
QString pin;
QSet<QString> pinFlags;
//QList<QPointer<Attribute>> 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 <QJsonArray>
#include <utility>
Token::Token(QString namee, QString tokenData, QString decription)
Token::Token(QString name, QString tokenData, QString decription)
{
this->name = namee;
this->tokenData = tokenData;
this->description = decription;
this->id = QUuid::createUuid();
this->setName(std::move(name));
this->tokenData = std::move(tokenData);
this->setDescription(std::move(decription));
this->setId(QUuid::createUuid());
this->tokenType = "Token";
this->tokenBits = 32;
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)
{
id = query->value(0).toUuid();
setId(query->value(0).toUuid());
authErrors = query->value(1).toInt();
description = query->value(2).toString();
setDescription(query->value(2).toString());
QSet<QString> flags;
if (query->value(6).toBool())
flags.insert("NoValidity");
if (query->value(3).toBool())
flags.insert("Enabled");
this->flags = flags;
lastUpdate = query->value(4).toUInt();
name = query->value(5).toString();
setLastUpdate(query->value(4).toUInt());
setName(query->value(5).toString());
timeToLive = query->value(7).toInt();
tokenBits = query->value(8).toInt();
tokenData = query->value(9).toString();

17
src/colnod/token.h
View File

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

107
test/unitTests/UnitTest.cpp
View File

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

36
test/unitTests/complextest.cpp
View File

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

6
test/unitTests/complextest.h
View File

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

5
test/unitTests/unittest.h
View File

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