mirror of
https://gitlab.com/spaceti-app/integrations/acs/colnod-connector.git
synced 2026-07-12 13:10:45 +02:00
Merge branch 'suggest/preapre-data-use-old' into 'master'
Suggest/preapre data use old See merge request spaceti-app/integrations/acs/colnod-connector!31
This commit is contained in:
Filip Bucek
commit
1f223adfcb
@ -1 +1 @@
|
||||
Subproject commit a818055b75dc0de97e26be44cbbfd2e94516c09e
|
||||
Subproject commit 031b6c2535408bce18a5d7bbc5842f9ee4384328
|
||||
@ -45,13 +45,13 @@ int main(int argc, char *argv[])
|
||||
|
||||
// Initialize database and colnod API
|
||||
if (!syncManager.databaseInitialization()) {
|
||||
qCritical("Not possible to initialize sync application");
|
||||
qCritical() << "Not possible to initialize sync application";
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Synchronizaiton
|
||||
if (!syncManager.startSynchronization()) {
|
||||
qCritical("Not possible to start synchronization");
|
||||
qCritical() << "Not possible to start synchronization";
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@ -1,38 +1,58 @@
|
||||
#include "colnodapi.h"
|
||||
|
||||
#include <utility>
|
||||
|
||||
Q_LOGGING_CATEGORY(colnod, "colnod.api");
|
||||
|
||||
|
||||
ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, const QString &userName, const QString &password)
|
||||
:mReqMan(reqMan), mUserName(userName), mPassword(password), mDryMode(dryMode)
|
||||
ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, QString userName, QString password)
|
||||
:mReqMan(reqMan), mUserName(std::move(userName)), mPassword(std::move(password)), mDryMode(dryMode)
|
||||
{
|
||||
// -----------------------------------
|
||||
mReqMan->setIgnoreSsl(true);
|
||||
// -----------------------------------
|
||||
}
|
||||
|
||||
void ColnodAPI::downloadData(const Timestamp &time)
|
||||
/**
|
||||
* @brief Downloads new data from Colnod -> emits downloadDataFinished signal
|
||||
* @param time
|
||||
*
|
||||
* @return signal with nullptr when something went wrong
|
||||
* @return signal with data when valid data returned
|
||||
*/
|
||||
void ColnodAPI::downloadData(const qint64 &time)
|
||||
{
|
||||
// Have to get Login
|
||||
auto login = requestLogin();
|
||||
connect(login.get(), &serversdk::Request::finished, this, [=](){
|
||||
// Get login token
|
||||
if (!checkRequest(login)) {
|
||||
if (login->status() != 200) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
AuthToken token;
|
||||
auto responseData = login->responseData();
|
||||
if (responseData.isEmpty()) {
|
||||
qCWarning(colnod) << "empty response data when logging in";
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
|
||||
AuthToken token;
|
||||
token.fromJson(login->responseData());
|
||||
token.fromJson(responseData);
|
||||
authToken = token.id();
|
||||
if (authToken.isEmpty()) {
|
||||
qCCritical(colnod) << "Token uuid is empty";
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
|
||||
auto data = std::make_shared<Data>();
|
||||
|
||||
auto errorHandler = [=](std::shared_ptr<serversdk::Request> request){
|
||||
auto errorHandler = [=](const std::shared_ptr<serversdk::Request>& request){
|
||||
if (!checkRequest(request)) {
|
||||
qWarning(colnod) << "ERROR during calling" << request->url() << ", request unsuccessful";
|
||||
mValid = false;
|
||||
emit downloadDataFinished(nullptr);
|
||||
emit downloadDataFinished(nullptr); // TODO: think about it, will the other if passed?
|
||||
}
|
||||
else if (!checkResponse(request->responseData())) {
|
||||
qWarning(colnod) << "Data from" << request->url() << "are invalid";
|
||||
@ -40,31 +60,35 @@ void ColnodAPI::downloadData(const Timestamp &time)
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// if I have all data emit downloadDataFinished
|
||||
connect(this, &ColnodAPI::partOfDataReady, this, &ColnodAPI::areDataReady);
|
||||
|
||||
auto tokensRequest = getTokensUpdated(time);
|
||||
Timestamp timestamp;
|
||||
timestamp.setTimestamp(time);
|
||||
|
||||
auto tokensRequest = getTokensUpdated(timestamp);
|
||||
connect(tokensRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveUpdatedTokens(data, tokensRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
});
|
||||
|
||||
auto deletedTokensRequest = getTokensDeleted(time);
|
||||
auto deletedTokensRequest = getTokensDeleted(timestamp);
|
||||
connect(deletedTokensRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(deletedTokensRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveDeletedTokens(data, deletedTokensRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
});
|
||||
|
||||
auto subjectsRequest = getSubjectsUpdated(time);
|
||||
auto subjectsRequest = getSubjectsUpdated(timestamp);
|
||||
connect(subjectsRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(subjectsRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveUpdatedSubjects(data, subjectsRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
});
|
||||
|
||||
auto deletedSubjectsRequest = getSubjectsDeleted(time);
|
||||
auto deletedSubjectsRequest = getSubjectsDeleted(timestamp);
|
||||
connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveDeletedSubjects(data, deletedSubjectsRequest->responseData());
|
||||
@ -107,14 +131,14 @@ std::shared_ptr<serversdk::Request> ColnodAPI::requestLogin()
|
||||
{
|
||||
Q_ASSERT(mReqMan);
|
||||
LoginResp login;
|
||||
login.set_username(userName());
|
||||
login.setUsername(userName());
|
||||
|
||||
// password
|
||||
QString encodedPassword = QCryptographicHash::hash(
|
||||
password().toLocal8Bit(), // -> bytearray
|
||||
QCryptographicHash::Sha512 // SHA 512
|
||||
).toHex().toUpper();
|
||||
login.set_password(encodedPassword);
|
||||
login.setPassword(encodedPassword);
|
||||
|
||||
auto loginRequest = composeRequest("/AaaManager/authSession", login.jsonData());
|
||||
loginRequest->setUserName(login.username());
|
||||
@ -208,10 +232,7 @@ std::shared_ptr<serversdk::Request> ColnodAPI::composeRequest(const QString &end
|
||||
|
||||
bool ColnodAPI::checkRequest(const std::shared_ptr<serversdk::Request> &request)
|
||||
{
|
||||
if (request->status() == 200) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return request->status() == 200;
|
||||
}
|
||||
|
||||
bool ColnodAPI::isValid()
|
||||
@ -236,7 +257,7 @@ qint64 ColnodAPI::lastSync() const
|
||||
|
||||
void ColnodAPI::setlastSync(const qint64 &lastSync)
|
||||
{
|
||||
mLastSync.set_timestamp(lastSync);
|
||||
mLastSync.setTimestamp(lastSync);
|
||||
}
|
||||
|
||||
|
||||
@ -250,7 +271,7 @@ void ColnodAPI::setUserName(const QString &userName)
|
||||
mUserName = userName;
|
||||
}
|
||||
|
||||
void ColnodAPI::areDataReady(std::shared_ptr<Data> data)
|
||||
void ColnodAPI::areDataReady(const std::shared_ptr<Data>& data)
|
||||
{
|
||||
if (++amountData == 4) {
|
||||
|
||||
@ -273,12 +294,12 @@ void ColnodAPI::isDataProcessFinished()
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodAPI::saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
void ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
data->loadTokensFromJson(responseData);
|
||||
}
|
||||
|
||||
void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
void ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
QJsonDocument doc = QJsonDocument::fromJson(responseData);
|
||||
QJsonArray items = doc.object()["items"].toArray();
|
||||
@ -287,12 +308,12 @@ void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodAPI::saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
void ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
data->loadSubjectsFormJson(responseData);
|
||||
}
|
||||
|
||||
void ColnodAPI::saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
void ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
QJsonDocument doc = QJsonDocument::fromJson(responseData);
|
||||
QJsonArray items = doc.object()["items"].toArray();
|
||||
|
||||
@ -10,31 +10,24 @@ Q_DECLARE_LOGGING_CATEGORY(colnod)
|
||||
|
||||
class LoginResp : public serversdk::DatabaseTable {
|
||||
Q_OBJECT
|
||||
TABLE_PROPERTY(QString, username, set_username, "")
|
||||
TABLE_PROPERTY(QString, password, set_password, "")
|
||||
TABLE_PROPERTY(QString, username, setUsername, "")
|
||||
TABLE_PROPERTY(QString, password, setPassword, "")
|
||||
};
|
||||
|
||||
class AuthToken : public serversdk::DatabaseTable {
|
||||
Q_OBJECT
|
||||
TABLE_PROPERTY(QString, id, set_id, QString())
|
||||
TABLE_PROPERTY(QString, id, setId, QString())
|
||||
};
|
||||
|
||||
class Timestamp : public serversdk::DatabaseTable {
|
||||
Q_OBJECT
|
||||
TABLE_PROPERTY(qint64, timestamp, set_timestamp, 0)
|
||||
TABLE_PROPERTY(qint64, timestamp, setTimestamp, 0)
|
||||
public:
|
||||
Timestamp() = default;
|
||||
explicit Timestamp(const Timestamp &time)
|
||||
|
||||
void setTimestamp(QDateTime time)
|
||||
{
|
||||
this->set_timestamp(time.timestamp());
|
||||
}
|
||||
explicit Timestamp(qint64 time)
|
||||
{
|
||||
set_timestamp(time);
|
||||
}
|
||||
explicit Timestamp(QDateTime time)
|
||||
{
|
||||
set_timestamp(time.toMSecsSinceEpoch());
|
||||
setTimestamp(time.toMSecsSinceEpoch());
|
||||
}
|
||||
|
||||
QString toDateString()
|
||||
@ -48,9 +41,9 @@ class ColnodAPI: public QObject
|
||||
Q_OBJECT
|
||||
public:
|
||||
ColnodAPI() = default;
|
||||
ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, const QString &userName = "spaceti", const QString &password = "spaceti1");
|
||||
ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, QString userName = "spaceti", QString password = "spaceti1");
|
||||
|
||||
void downloadData(const Timestamp &time);
|
||||
void downloadData(const qint64 &time);
|
||||
void processData(const std::shared_ptr<Data> &data);
|
||||
|
||||
// New approach
|
||||
@ -76,14 +69,14 @@ public:
|
||||
bool isValid();
|
||||
|
||||
private:
|
||||
Q_SLOT void areDataReady(std::shared_ptr<Data> data);
|
||||
Q_SLOT void areDataReady(const std::shared_ptr<Data>& data);
|
||||
Q_SLOT void isDataProcessFinished();
|
||||
|
||||
private:
|
||||
void saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
|
||||
void saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
|
||||
void saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
|
||||
void saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
|
||||
void saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
void saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
void saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
void saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
|
||||
void newData();
|
||||
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "token.h"
|
||||
#include "subject.h"
|
||||
|
||||
@ -13,7 +15,7 @@ constexpr auto tab = "\t";
|
||||
class Message
|
||||
{
|
||||
public:
|
||||
static QString massageTemplate(QString action, QString item, QString source, QString itemInfo)
|
||||
static QString massageTemplate(const QString& action, const QString& item, const QString& source, const QString& itemInfo)
|
||||
{
|
||||
return action + " " + item + " in " + source + ", " + item + ": '" + itemInfo + "'";
|
||||
}
|
||||
@ -37,3 +39,16 @@ public:
|
||||
QList<QString> deletedSubjects;
|
||||
};
|
||||
|
||||
struct PreparedData
|
||||
{
|
||||
public:
|
||||
PreparedData() = default;
|
||||
PreparedData(const std::shared_ptr<Data> &database, const std::shared_ptr<Data> &colnod)
|
||||
:databaseData(std::move(database)), colnodData(std::move(colnod))
|
||||
{
|
||||
}
|
||||
|
||||
// TODO: make unique_ptr ( neeed because of ColnodAPI )
|
||||
std::shared_ptr<Data> databaseData;
|
||||
std::shared_ptr<Data> colnodData;
|
||||
};
|
||||
|
||||
@ -12,7 +12,7 @@ DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode)
|
||||
mDbMan->setDryMode(dryMode);
|
||||
}
|
||||
|
||||
bool DatabaseAPI::open(QString host, QString name, QString user, QString password)
|
||||
bool DatabaseAPI::open(const QString& host, const QString& name, const QString& user, const QString& password)
|
||||
{
|
||||
return mDbMan->openPostgres(host, name, user, password);
|
||||
}
|
||||
@ -118,7 +118,7 @@ void DatabaseAPI::setLastSync(qint64 timestamp)
|
||||
}
|
||||
}
|
||||
|
||||
void DatabaseAPI::setLastUpdate(const QHash<QString, std::shared_ptr<Token>> &tokens)
|
||||
void DatabaseAPI::reupdateUpdated(const QHash<QString, std::shared_ptr<Token>> &tokens)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
for (const auto &token : tokens){
|
||||
@ -135,7 +135,8 @@ void DatabaseAPI::setLastUpdate(const QHash<QString, std::shared_ptr<Token>> &to
|
||||
qInfo(database) << equals;
|
||||
}
|
||||
|
||||
void DatabaseAPI::setLastUpdate(const QList<QString> ids)
|
||||
|
||||
void DatabaseAPI::reupdateDeleted(const QList<QString>& ids)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
for (const auto &id : ids){
|
||||
@ -148,7 +149,6 @@ void DatabaseAPI::setLastUpdate(const QList<QString> ids)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
qint64 DatabaseAPI::getNow()
|
||||
@ -193,14 +193,6 @@ bool DatabaseAPI::uploadTokens(const QHash<QString, std::shared_ptr<Token>> &tok
|
||||
for (const auto &token : tokens) {
|
||||
// Get token
|
||||
|
||||
QSqlQuery query;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if (exists(token->id(), "colnod_token")) {
|
||||
query = utils->updateTable(token.get(), "colnod_token");
|
||||
qInfo(database).noquote() << Message::massageTemplate("Updating", "token", "database", token->name());
|
||||
@ -299,10 +291,7 @@ bool DatabaseAPI::isAlreadyDeleted(const QString &id)
|
||||
qWarning(database) << "Token deleted in colnod doesn't exists in db, will be noted as already deleted in stats";
|
||||
return true;
|
||||
}
|
||||
if (token->deleted())
|
||||
return true;
|
||||
return false;
|
||||
|
||||
return token->deleted();
|
||||
}
|
||||
|
||||
bool DatabaseAPI::isValid()
|
||||
|
||||
@ -20,10 +20,10 @@ class DatabaseAPI : public QObject
|
||||
public:
|
||||
explicit DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode);
|
||||
|
||||
bool open(QString host = "192.168.1.94",
|
||||
QString name = "deloitte",
|
||||
QString user = "postgres",
|
||||
QString password = "34rjkciea12");
|
||||
bool open(const QString& host = "192.168.1.94",
|
||||
const QString& name = "deloitte",
|
||||
const QString& user = "postgres",
|
||||
const QString& password = "34rjkciea12");
|
||||
|
||||
bool executeQuery(QSqlQuery &query, const QString &statement = QString());
|
||||
|
||||
@ -31,8 +31,8 @@ public:
|
||||
bool processData(const std::shared_ptr<Data> &data);
|
||||
qint64 getLastSync();
|
||||
void setLastSync(qint64 timestamp);
|
||||
void setLastUpdate(const QHash<QString, std::shared_ptr<Token> > &tokens);
|
||||
void setLastUpdate(const QList<QString> ids);
|
||||
void reupdateUpdated(const QHash<QString, std::shared_ptr<Token> > &tokens);
|
||||
void reupdateDeleted(const QList<QString>& ids);
|
||||
qint64 getNow();
|
||||
|
||||
void initNewTokens();
|
||||
@ -48,13 +48,14 @@ public:
|
||||
|
||||
bool isValid();
|
||||
|
||||
qint16 getNumOfTokensOfSubject(const QString &id);
|
||||
QString getSubjectNameByTokenId(const QString &tokenId);
|
||||
|
||||
private:
|
||||
int exists(const QString &id, const QString &tableName);
|
||||
|
||||
QSqlQuery getUpdatedTokens();
|
||||
std::shared_ptr<Data> composeData(const QSqlQuery &updatedQuery, QSqlQuery &deletedQuery);
|
||||
qint16 getNumOfTokensOfSubject(const QString &id);
|
||||
QString getSubjectNameByTokenId(const QString &tokenId);
|
||||
|
||||
signals:
|
||||
void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());
|
||||
|
||||
@ -13,9 +13,6 @@ SyncManager::SyncManager(bool dryMode)
|
||||
bool SyncManager::databaseInitialization()
|
||||
{
|
||||
database = std::make_shared<DatabaseAPI>(&dbMan, mDryMode);
|
||||
// connect(database.get(), &DatabaseAPI::error, [=](){
|
||||
// QCoreApplication::exit(1);
|
||||
// });
|
||||
|
||||
// Open database
|
||||
if (!database->open()) {
|
||||
@ -31,7 +28,7 @@ bool SyncManager::databaseInitialization()
|
||||
}
|
||||
|
||||
// here -> nothing can fail
|
||||
mlastSync.set_timestamp(database->getLastSync());
|
||||
mlastSync.setTimestamp(database->getLastSync());
|
||||
colnod = std::make_shared<ColnodAPI>(&reqMan, mDryMode);
|
||||
return true;
|
||||
}
|
||||
@ -49,9 +46,11 @@ bool SyncManager::startSynchronization()
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "SYNCHRONIZATION BEGIN";
|
||||
|
||||
// TODO: check error
|
||||
database->initNewTokens();
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "DOWNLOADING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager).noquote() << "Modified data since last synchronization (" << mlastSync.toDateString() << "):";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
// GETTING DATA FROM DATABASE
|
||||
auto databaseData = database->downloadData();
|
||||
@ -61,85 +60,187 @@ bool SyncManager::startSynchronization()
|
||||
}
|
||||
// NOW I HAVE DATA FROM DATABASE
|
||||
|
||||
colnod->downloadData(syncBegin);
|
||||
connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> colnodData) {
|
||||
qInfo(syncmanager) << "DOWNLOADING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
colnod->downloadData(Timestamp(syncBegin));
|
||||
connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> data) {
|
||||
if (!data) {
|
||||
if (!colnodData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
|
||||
// NOW I SHOULD HAVE VALID DATA FROM COLNOD
|
||||
|
||||
|
||||
// NOW I HAVE DATA FROM COLNOD
|
||||
// I can process data
|
||||
qDebug(syncmanager) << "I have colnod and database data";
|
||||
qDebug(syncmanager) << "updated token count" << data->updatedTokens.count();
|
||||
std::unique_ptr<PreparedData> preparedData = prepareDataNew(databaseData, colnodData);
|
||||
if (!preparedData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
|
||||
});
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "PROCESSING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager) << "Push changes to both Colnod and Database:";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
return true;
|
||||
//downloadData();
|
||||
|
||||
auto colnodDataFinished = [=](std::shared_ptr<Data> data) {
|
||||
qDebug() << "Now I can check that I have all data I need";
|
||||
};
|
||||
|
||||
//connect(this, &SyncManager::dataReady, processDownloadedData);
|
||||
|
||||
|
||||
connect(this, &SyncManager::dataReady, [=](){
|
||||
prepareData();
|
||||
|
||||
connect(this, &SyncManager::dataProcessFinished, [=](){
|
||||
if (!database->processData(preparedData->databaseData)) {
|
||||
qCritical(syncmanager) << "Not possible to upload data to database";
|
||||
}
|
||||
|
||||
// data is processed to other sides
|
||||
connect(colnod.get(), &ColnodAPI::dataProcessFinished, [&](){
|
||||
qInfo(syncmanager) << "PROCESSING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
updateLastUpdate(syncBegin);
|
||||
connect(this, &SyncManager::syncFinished, [=](){
|
||||
if (database->isValid() && colnod->isValid()) {
|
||||
database->setLastSync(syncBegin);
|
||||
// REUPDATE tokens pushed from database to colnod (cause of lastUpdate time)
|
||||
Timestamp time;
|
||||
time.setTimestamp(syncBegin);
|
||||
|
||||
database->reupdateDeleted(preparedData->databaseData->deletedTokens);
|
||||
// download data changes in this sync
|
||||
colnod->getTokensUpdated(time);
|
||||
|
||||
// updated data are ready
|
||||
connect(colnod.get(), &ColnodAPI::partOfDataReady, [=](const std::shared_ptr<Data> &uploadedData){
|
||||
if (!uploadedData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
else {
|
||||
if (!database->uploadTokens(uploadedData->updatedTokens)) {
|
||||
qCritical(syncmanager) << "Not possible to upload data to database";
|
||||
}
|
||||
database->reupdateDeleted(uploadedData->deletedTokens);
|
||||
|
||||
if (!database->isValid() || !colnod->isValid()) {
|
||||
qWarning(syncmanager) << "Synchronization was unsuccessful, next run of sync will be with same last sync time, check warnings";
|
||||
}
|
||||
|
||||
else {
|
||||
database->setLastSync(syncBegin);
|
||||
qInfo(syncmanager).noquote() << "Update last synchronization time to time of this sync ("
|
||||
<< QDateTime::fromMSecsSinceEpoch(syncBegin).toString("yyyy-MM-dd hh:mm:ss.zzz")
|
||||
<< ")";
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "SYNCHRONIZATION FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
QCoreApplication::exit();
|
||||
});
|
||||
|
||||
colnod->processData(preparedData->colnodData);
|
||||
//qCritical(syncmanager) << "Not possible to upload data to colnod";
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
processData();
|
||||
});
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
bool SyncManager::downloadData()
|
||||
std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)
|
||||
{
|
||||
bool res = true;
|
||||
auto preparedColnodData = std::make_shared<Data>();
|
||||
auto preparedDatabaseData = std::make_shared<Data>();
|
||||
|
||||
QList<QString> conflicts;
|
||||
QList<QString> alreadySynced;
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "DOWNLOADING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager).noquote() << "Modified data since last synchronization (" << mlastSync.toDateString() << "):";
|
||||
qInfo(syncmanager) << "Resolve conflicts ( changes on same item on both Colnod and DB ):";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
connect(colnod.get(), &ColnodAPI::downloadDataFinished, this, &SyncManager::saveColnodData);
|
||||
//connect(database.get(), &DatabaseAPI::downloadDataFinished, this, &SyncManager::saveDatabaseData);
|
||||
//database->downloadData();
|
||||
//colnod->downloadData();
|
||||
|
||||
return res;
|
||||
for (const auto &colnodToken : colnodData->updatedTokens) {
|
||||
|
||||
// not conflict so add to prepered tokens
|
||||
if (!databaseData->updatedTokens.contains(colnodToken->id())) {
|
||||
preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
|
||||
continue;
|
||||
}
|
||||
|
||||
// finds conflicts -> changes on both sides (colnod and DB), apply newer change
|
||||
bool SyncManager::prepareData()
|
||||
// change in colnod is newer
|
||||
if (databaseData->updatedTokens.value(colnodToken->id()) < colnodToken) {
|
||||
preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
|
||||
}
|
||||
else {
|
||||
conflicts.append(colnodToken->id());
|
||||
}
|
||||
|
||||
auto token = database->getToken(colnodToken->id());
|
||||
if ( token )
|
||||
// alredy synced ( tokens are same )
|
||||
if (token == colnodToken)
|
||||
alreadySynced.append(colnodToken->id());
|
||||
}
|
||||
|
||||
for (const auto &id : colnodData->deletedTokens) {
|
||||
if (!database->isAlreadyDeleted(id)) {
|
||||
preparedColnodData->deletedTokens.append(id);
|
||||
}
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << tab << "-> COLNOD DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN DATABASE AFTER";
|
||||
qInfo(syncmanager) << tab << tab << alreadySynced.size() << "TOKENS WERE ALREADY SYNCED";
|
||||
qInfo(syncmanager) << tab << tab << colnodData->deletedTokens.size() - preparedColnodData->deletedTokens.size() << "TOKENS WERE ALREADY DELETED";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
for (const auto &databaseToken : databaseData->updatedTokens) {
|
||||
if (databaseToken->name().isEmpty()) {
|
||||
initNewToken(databaseToken);
|
||||
}
|
||||
|
||||
// restriction cauesed by colnod rest api
|
||||
if (databaseToken->description() != "mobile") {
|
||||
qCritical(syncmanager) << "Token:" << databaseToken->id() << "doesn't have 'mobile' in description, can't be ";
|
||||
continue;
|
||||
}
|
||||
|
||||
// no conflict
|
||||
if (!colnodData->updatedTokens.contains(databaseToken->id())) {
|
||||
preparedDatabaseData->updatedTokens.insert(databaseToken->id(), databaseToken);
|
||||
continue;
|
||||
}
|
||||
|
||||
// database change is newer
|
||||
if (databaseToken > colnodData->updatedTokens.value(databaseToken->id())) {
|
||||
preparedDatabaseData->updatedTokens.insert(databaseToken->id(), databaseToken);
|
||||
}
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << databaseData->updatedTokens.size() - preparedColnodData->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED IN COLNOD AFTER";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
|
||||
auto preparedData = std::make_unique<PreparedData>(preparedDatabaseData, preparedColnodData);
|
||||
return preparedData;
|
||||
}
|
||||
|
||||
void SyncManager::initNewToken(const std::shared_ptr<Token>& token)
|
||||
{
|
||||
Q_ASSERT(database);
|
||||
Q_ASSERT(token);
|
||||
qint16 num = database->getNumOfTokensOfSubject(token->subjectId());
|
||||
token->setName(database->getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
|
||||
token->setDescription("mobile");
|
||||
token->setTokenData(token->tokenData().toUpper());
|
||||
|
||||
qInfo(syncmanager).noquote() << Message::massageTemplate("Inicializing new", "token", "sync manager", token->name());
|
||||
}
|
||||
|
||||
std::unique_ptr<PreparedData> SyncManager::prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)
|
||||
{
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
|
||||
@ -153,17 +254,17 @@ bool SyncManager::prepareData()
|
||||
|
||||
|
||||
// TODO: why copy data?
|
||||
colnodDataToProcess = std::make_shared<Data>(*colnodData);
|
||||
databaseDataToProcess = std::make_shared<Data>(*databaseData);
|
||||
std::shared_ptr<Data> cloneColnodDataToProcess = std::make_shared<Data>(*colnodData);
|
||||
std::shared_ptr<Data> cloneDatabaseDataToProcess = std::make_shared<Data>(*databaseData);
|
||||
|
||||
QList<QString> conflicts;
|
||||
QList<QString> alreadySynced;
|
||||
|
||||
// check modifed tokens from colnod, dont want update token, if it was edited in db after or has been already synced
|
||||
for (const auto &colnodToken : colnodDataToProcess->updatedTokens) {
|
||||
if (databaseDataToProcess->updatedTokens.contains(colnodToken->id())) {
|
||||
for (const auto &colnodToken : cloneColnodDataToProcess->updatedTokens) {
|
||||
if (cloneDatabaseDataToProcess->updatedTokens.contains(colnodToken->id())) {
|
||||
// updated in db later
|
||||
if (databaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken) {
|
||||
if (cloneDatabaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken) {
|
||||
conflicts.append(colnodToken->id());
|
||||
}
|
||||
continue;
|
||||
@ -176,9 +277,9 @@ bool SyncManager::prepareData()
|
||||
}
|
||||
// remove tokens which should be not updated
|
||||
for (const auto &id : conflicts)
|
||||
colnodDataToProcess->updatedTokens.remove(id);
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
for (const auto &id : alreadySynced)
|
||||
colnodDataToProcess->updatedTokens.remove(id);
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
|
||||
qInfo(syncmanager) << tab << "-> COLNOD DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN DATABASE TOO";
|
||||
@ -189,13 +290,13 @@ bool SyncManager::prepareData()
|
||||
conflicts.clear();
|
||||
|
||||
// chech for already deleted ( in previous synced tokens were deleted from colnod, so it come to this sync but we dont want to sync it again
|
||||
for (const auto &id : colnodDataToProcess->deletedTokens) {
|
||||
for (const auto &id : cloneColnodDataToProcess->deletedTokens) {
|
||||
if (database->isAlreadyDeleted(id)) {
|
||||
conflicts.append(id);
|
||||
}
|
||||
}
|
||||
for (const auto &id : conflicts) {
|
||||
colnodDataToProcess->deletedTokens.removeOne(id);
|
||||
cloneColnodDataToProcess->deletedTokens.removeOne(id);
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ALREADY DELETED";
|
||||
@ -204,9 +305,9 @@ bool SyncManager::prepareData()
|
||||
conflicts.clear();
|
||||
|
||||
// chech modified from db, remove token if it was edited in colnod later
|
||||
for (const auto &databaseToken : databaseDataToProcess->updatedTokens) {
|
||||
if (colnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
|
||||
if (databaseToken < colnodDataToProcess->updatedTokens.value(databaseToken->id()))
|
||||
for (const auto &databaseToken : cloneDatabaseDataToProcess->updatedTokens) {
|
||||
if (cloneColnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
|
||||
if (databaseToken < cloneColnodDataToProcess->updatedTokens.value(databaseToken->id()))
|
||||
conflicts.append(databaseToken->id());
|
||||
}
|
||||
else {
|
||||
@ -218,7 +319,7 @@ bool SyncManager::prepareData()
|
||||
}
|
||||
}
|
||||
for (const auto &id : conflicts)
|
||||
colnodDataToProcess->updatedTokens.remove(id);
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
|
||||
qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN IN COLNOD TOO";
|
||||
@ -226,54 +327,11 @@ bool SyncManager::prepareData()
|
||||
|
||||
qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SyncManager::processData()
|
||||
{
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "PROCESSING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager) << "Push changes to both Colnod and Database:";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
database->processData(colnodDataToProcess);
|
||||
connect(colnod.get(), &ColnodAPI::dataProcessFinished, this, &SyncManager::dataProcessFinished);
|
||||
colnod->processData(databaseDataToProcess);
|
||||
return true;
|
||||
}
|
||||
|
||||
void SyncManager::updateLastUpdate(qint64 syncBegin)
|
||||
{
|
||||
Timestamp time;
|
||||
time.set_timestamp(syncBegin);
|
||||
colnod->getTokensUpdated(time);
|
||||
database->setLastUpdate(databaseDataToProcess->deletedTokens);
|
||||
connect(colnod.get(), &ColnodAPI::partOfDataReady, [=](const std::shared_ptr<Data> &data){
|
||||
database->setLastUpdate(data->updatedTokens);
|
||||
emit syncFinished();
|
||||
});
|
||||
}
|
||||
|
||||
void SyncManager::areDataReady()
|
||||
{
|
||||
if (++dataAmount == 1) {
|
||||
|
||||
qInfo(syncmanager) << "DOWNLOADING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
emit dataReady();
|
||||
}
|
||||
}
|
||||
|
||||
void SyncManager::saveColnodData(const std::shared_ptr<Data> &data)
|
||||
{
|
||||
colnodData = data;
|
||||
areDataReady();
|
||||
}
|
||||
|
||||
void SyncManager::saveDatabaseData(const std::shared_ptr<Data> &data)
|
||||
{
|
||||
databaseData = data;
|
||||
areDataReady();
|
||||
|
||||
// Prepare data
|
||||
auto preparedData = std::make_unique<PreparedData>();
|
||||
preparedData->colnodData = cloneColnodDataToProcess;
|
||||
preparedData->databaseData = cloneDatabaseDataToProcess;
|
||||
|
||||
return preparedData;
|
||||
}
|
||||
|
||||
@ -8,27 +8,32 @@ Q_DECLARE_LOGGING_CATEGORY(syncmanager)
|
||||
class SyncManager : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
friend class SyncManagerTest;
|
||||
public:
|
||||
explicit SyncManager(bool dryMode);
|
||||
|
||||
bool databaseInitialization();
|
||||
bool startSynchronization();
|
||||
|
||||
// New approach
|
||||
private:
|
||||
bool downloadData();
|
||||
bool prepareData();
|
||||
bool processData();
|
||||
/**
|
||||
* @brief Preapre data to be pushed to database and colnod from actual downloaded data
|
||||
* @param data from database
|
||||
* @param data from colnod
|
||||
* @return prepared data to be pushed into colnod and db
|
||||
*
|
||||
* @todo rename when removed old aproach
|
||||
*/
|
||||
std::unique_ptr<PreparedData> prepareDataNew(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
|
||||
std::unique_ptr<PreparedData> prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
|
||||
|
||||
private:
|
||||
void initNewToken(const std::shared_ptr<Token>& token);
|
||||
|
||||
void updateLastUpdate(qint64 syncBegin);
|
||||
|
||||
|
||||
private:
|
||||
Q_SLOT void saveColnodData(const std::shared_ptr<Data> &data);
|
||||
Q_SLOT void saveDatabaseData(const std::shared_ptr<Data> &data);
|
||||
Q_SLOT void areDataReady();
|
||||
|
||||
signals:
|
||||
void dataReady();
|
||||
void dataProcessFinished();
|
||||
void syncFinished();
|
||||
|
||||
void error();
|
||||
@ -40,14 +45,5 @@ private:
|
||||
serversdk::DatabaseManager dbMan;
|
||||
Timestamp mlastSync;
|
||||
|
||||
std::shared_ptr<Data> colnodData;
|
||||
std::shared_ptr<Data> databaseData;
|
||||
|
||||
std::shared_ptr<Data> colnodDataToProcess;
|
||||
std::shared_ptr<Data> databaseDataToProcess;
|
||||
|
||||
int dataAmount = 0;
|
||||
bool mDryMode;
|
||||
|
||||
std::function<void()> onError = nullptr;
|
||||
};
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
Q_DECLARE_METATYPE(std::shared_ptr<Data>)
|
||||
Q_DECLARE_METATYPE(std::shared_ptr<serversdk::Request>);
|
||||
|
||||
|
||||
class ColnodTest : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
@ -14,22 +15,20 @@ public:
|
||||
ColnodTest()
|
||||
{
|
||||
qRegisterMetaType<std::shared_ptr<Data>>();
|
||||
qRegisterMetaType<std::shared_ptr<serversdk::Request>>();
|
||||
qRegisterMetaType<std::shared_ptr<serversdk::Request>>("std::shared_ptr<Request>");
|
||||
}
|
||||
|
||||
private slots:
|
||||
void login();
|
||||
void getTokens();
|
||||
void download_data_test();
|
||||
void download_data_test_now();
|
||||
void download_data_fail_test();
|
||||
|
||||
private:
|
||||
QString getLoginToken(ColnodAPI &colnod);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
void ColnodTest::login()
|
||||
{
|
||||
serversdk::RequestManager reqMan;
|
||||
@ -52,35 +51,41 @@ void ColnodTest::getTokens()
|
||||
QSignalSpy spy(login.get(), &serversdk::Request::finished);
|
||||
spy.wait();
|
||||
QString token = getLoginToken(colnod);
|
||||
Timestamp time(QDateTime::currentMSecsSinceEpoch());
|
||||
Timestamp time;
|
||||
time.setTimestamp(QDateTime::currentMSecsSinceEpoch());
|
||||
colnod.getTokensUpdated(time);
|
||||
}
|
||||
|
||||
void ColnodTest::download_data_test()
|
||||
{
|
||||
serversdk::RequestManager reqMan;
|
||||
//reqMan.setIgnoreSsl(true);
|
||||
ColnodAPI colnod(&reqMan);
|
||||
{
|
||||
|
||||
QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
|
||||
colnod.downloadData(Timestamp(1570190399259));
|
||||
QVERIFY(spy.isValid());
|
||||
colnod.downloadData(1570190399259);
|
||||
QVERIFY(spy.wait());
|
||||
|
||||
auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
|
||||
QVERIFY(data);
|
||||
|
||||
QVERIFY(data->updatedTokens.size() > 0);
|
||||
QVERIFY(! data->updatedTokens.isEmpty());
|
||||
QVERIFY(data->updatedTokens.contains("5e2f1260-da1c-441f-9644-24dfe3b97b2a"));
|
||||
}
|
||||
|
||||
void ColnodTest::download_data_test_now()
|
||||
{
|
||||
Timestamp time(QDateTime::currentMSecsSinceEpoch());
|
||||
colnod.downloadData(time);
|
||||
serversdk::RequestManager reqMan;
|
||||
ColnodAPI colnod(&reqMan);
|
||||
|
||||
colnod.downloadData(QDateTime::currentMSecsSinceEpoch());
|
||||
QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
|
||||
QVERIFY(spy.wait());
|
||||
auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
|
||||
QVERIFY(data);
|
||||
|
||||
QVERIFY(data->updatedTokens.size() == 0);
|
||||
}
|
||||
QVERIFY(data->updatedTokens.isEmpty());
|
||||
}
|
||||
|
||||
void ColnodTest::download_data_fail_test()
|
||||
@ -88,17 +93,14 @@ void ColnodTest::download_data_fail_test()
|
||||
serversdk::RequestManager reqMan;
|
||||
ColnodAPI colnod(&reqMan, false, "spaceti", "wrong password");
|
||||
|
||||
Timestamp time(0);
|
||||
QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
|
||||
colnod.downloadData(time);
|
||||
colnod.downloadData(0);
|
||||
|
||||
QVERIFY(spy.wait());
|
||||
|
||||
auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
|
||||
|
||||
QVERIFY(!data);
|
||||
|
||||
|
||||
}
|
||||
|
||||
QString ColnodTest::getLoginToken(ColnodAPI &colnod)
|
||||
|
||||
@ -6,18 +6,149 @@
|
||||
class SyncManagerTest : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
private:
|
||||
std::shared_ptr<Token> tokenFromString(const QString &text);
|
||||
private slots:
|
||||
void tokenFromString_test();
|
||||
void sync_init_test();
|
||||
void prepareData_test();
|
||||
void prepareData_tokens();
|
||||
void prepareData_tokens_data();
|
||||
|
||||
};
|
||||
|
||||
std::shared_ptr<Token> SyncManagerTest::tokenFromString(const QString &text)
|
||||
{
|
||||
auto split = text.split(",");
|
||||
if (split.count() != 2)
|
||||
return nullptr;
|
||||
|
||||
auto token = std::make_shared<Token>();
|
||||
token->setId(split.first());
|
||||
token->setDescription("mobile");
|
||||
token->setLastUpdate(QDateTime::fromString(split.last(), "yyyyMMdd:HHmmss"));
|
||||
return token;
|
||||
}
|
||||
|
||||
void SyncManagerTest::tokenFromString_test()
|
||||
{
|
||||
auto token = tokenFromString("id1,20191010:232300");
|
||||
QCOMPARE(token->id(), QStringLiteral("id1"));
|
||||
QCOMPARE(token->lastUpdate(), QDateTime::fromString("20191010:232300", "yyyyMMdd:HHmmss"));
|
||||
}
|
||||
|
||||
void SyncManagerTest::sync_init_test()
|
||||
{
|
||||
SyncManager sync(true);
|
||||
|
||||
QVERIFY(sync.databaseInitialization());
|
||||
}
|
||||
|
||||
|
||||
void SyncManagerTest::prepareData_test()
|
||||
{
|
||||
SyncManager sync(true);
|
||||
QVERIFY(sync.databaseInitialization());
|
||||
auto dbData = std::make_shared<Data>();
|
||||
auto colnodData = std::make_shared<Data>();
|
||||
|
||||
auto token = std::make_shared<Token>();
|
||||
token->setDescription("mobile");
|
||||
token->setId("id1");
|
||||
dbData->updatedTokens.insert("id1", token);
|
||||
|
||||
auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
|
||||
auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
|
||||
QVERIFY(oldPreparedData->databaseData->updatedTokens.contains("id1"));
|
||||
QVERIFY(newPreparedData->databaseData->updatedTokens.contains("id1"));
|
||||
QVERIFY(oldPreparedData->databaseData->updatedSubjects.isEmpty());
|
||||
QVERIFY(newPreparedData->databaseData->updatedSubjects.isEmpty());
|
||||
QVERIFY(oldPreparedData->databaseData->deletedTokens.isEmpty());
|
||||
QVERIFY(newPreparedData->databaseData->deletedTokens.isEmpty());
|
||||
QVERIFY(oldPreparedData->databaseData->deletedSubjects.isEmpty());
|
||||
QVERIFY(newPreparedData->databaseData->deletedSubjects.isEmpty());
|
||||
}
|
||||
|
||||
void SyncManagerTest::prepareData_tokens()
|
||||
{
|
||||
SyncManager sync(true);
|
||||
QVERIFY(sync.databaseInitialization());
|
||||
|
||||
|
||||
|
||||
QFETCH(QString, db_token_updated);
|
||||
QFETCH(QString, db_token_deleted);
|
||||
QFETCH(QString, colnod_token_updated);
|
||||
QFETCH(QString, colnod_token_deleted);
|
||||
QFETCH(QString, expected_db_tokens_toupdate);
|
||||
QFETCH(QString, expected_db_tokens_todelete);
|
||||
QFETCH(QString, expected_colnod_tokens_toupdate);
|
||||
QFETCH(QString, expected_colnod_tokens_todelete);
|
||||
|
||||
// fake data
|
||||
auto dbData = std::make_shared<Data>();
|
||||
auto colnodData = std::make_shared<Data>();
|
||||
|
||||
// Database
|
||||
auto utoken = tokenFromString(db_token_updated);
|
||||
if ( utoken )
|
||||
dbData->updatedTokens.insert(utoken->id(), utoken);
|
||||
auto dtoken = tokenFromString(db_token_deleted);
|
||||
if ( dtoken )
|
||||
dbData->deletedTokens.append(dtoken->id());
|
||||
|
||||
// Colnod
|
||||
auto colnod_utoken = tokenFromString(colnod_token_updated);
|
||||
if ( colnod_utoken )
|
||||
colnodData->updatedTokens.insert(colnod_utoken->id(), colnod_utoken);
|
||||
auto colnod_dtoken = tokenFromString(colnod_token_deleted);
|
||||
if ( colnod_dtoken )
|
||||
colnodData->deletedTokens.append(colnod_dtoken->id());
|
||||
|
||||
auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
|
||||
auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
|
||||
|
||||
QVERIFY(newPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
|
||||
QVERIFY(newPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
|
||||
QVERIFY(newPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
|
||||
QVERIFY(newPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));
|
||||
|
||||
QVERIFY(oldPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
|
||||
QVERIFY(oldPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
|
||||
QVERIFY(oldPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
|
||||
QVERIFY(oldPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));
|
||||
|
||||
}
|
||||
|
||||
void SyncManagerTest::prepareData_tokens_data()
|
||||
{
|
||||
QTest::addColumn<QString>("db_token_updated");
|
||||
QTest::addColumn<QString>("db_token_deleted");
|
||||
QTest::addColumn<QString>("colnod_token_updated");
|
||||
QTest::addColumn<QString>("colnod_token_deleted");
|
||||
QTest::addColumn<QString>("expected_db_tokens_toupdate");
|
||||
QTest::addColumn<QString>("expected_db_tokens_todelete");
|
||||
QTest::addColumn<QString>("expected_colnod_tokens_toupdate");
|
||||
QTest::addColumn<QString>("expected_colnod_tokens_todelete");
|
||||
|
||||
// in: db 1 new token
|
||||
// out: 1 db token must be updated in colnod
|
||||
QTest::newRow("db 1 update") << "id1,20191010:23:23:00" << ""
|
||||
<< "" << ""
|
||||
// expected database: toupdate << todelete
|
||||
<< "id1" << ""
|
||||
// expected colnod: toupdate << todelete
|
||||
<< "" << "";
|
||||
// in: id1 in database new/updated
|
||||
// in: id1 deleted in colnod
|
||||
// out: 1 colnod token must be deleted from database
|
||||
QTest::newRow("delete 1 existing token in database") << "id1,20191010:23:23:00" << ""
|
||||
<< "" << "id1,20191010:23:23:00"
|
||||
// expected database: toupdate << todelete
|
||||
<< "" << "id1"
|
||||
// expected colnod: toupdate << todelete
|
||||
<< "" << "";
|
||||
}
|
||||
|
||||
QTEST_MAIN(SyncManagerTest)
|
||||
|
||||
#include "tst_syncmanager.moc"
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user