mirror of
https://gitlab.com/spaceti-app/integrations/acs/colnod-connector.git
synced 2026-07-12 12:00:37 +02:00
Merge branch 'feat/unitest-syncmanager' into 'master'
Feat/unitest syncmanager See merge request spaceti-app/integrations/acs/colnod-connector!33
This commit is contained in:
Ondřej Fischer
commit
18032ef1fc
109
README.md
109
README.md
@ -169,6 +169,115 @@ It is possible to chain requests: [see doc](https://support.insomnia.rest/articl
|
||||
|
||||
`npm install -g snowboard`
|
||||
|
||||
## Tests made
|
||||
Changes on colnod are made by [Colnod client](https://spaceti.atlassian.net/wiki/spaces/IN/pages/194576388/Colnod+client)
|
||||
|
||||
Changes on db can be made by sql commands directly or by [pgAdmin](https://www.pgadmin.org/)
|
||||
- add token to db/colnod (2 tests)
|
||||
- edit token in db/colnod (2 tests)
|
||||
- delete token from db/colnod (2 tests)
|
||||
- add subject to colnod
|
||||
- edit subject in colnod
|
||||
- delete subject from colnod
|
||||
- edit same token on both db/colnod (diffrent time)
|
||||
|
||||
## First sync expected results
|
||||
- 2892 tokens updated
|
||||
- 173 tokens deleted
|
||||
- 2894 subjects updated
|
||||
- 117 subjects deleted
|
||||
|
||||
## Database inicialization
|
||||
- Token table
|
||||
```SQL create
|
||||
-- Table: public.colnod_token
|
||||
-- DROP TABLE public.colnod_token;
|
||||
CREATE TABLE public.colnod_token
|
||||
(
|
||||
id character(36) COLLATE pg_catalog."default" NOT NULL,
|
||||
auth_errors integer DEFAULT 255,
|
||||
description character varying(255) COLLATE pg_catalog."default",
|
||||
enabled boolean DEFAULT true,
|
||||
last_update timestamp without time zone DEFAULT '1970-01-01 00:00:00.001'::timestamp without time zone,
|
||||
name character varying(255) COLLATE pg_catalog."default",
|
||||
no_validity boolean DEFAULT true,
|
||||
time_to_live integer DEFAULT 255,
|
||||
token_bits integer DEFAULT 32,
|
||||
token_data character varying(255) COLLATE pg_catalog."default",
|
||||
token_type character varying(255) COLLATE pg_catalog."default" DEFAULT 'Token'::character varying,
|
||||
subject_id character(36) COLLATE pg_catalog."default",
|
||||
last_modified timestamp without time zone NOT NULL,
|
||||
deleted boolean DEFAULT false,
|
||||
CONSTRAINT colnod_token_pkey PRIMARY KEY (id)
|
||||
)
|
||||
WITH (
|
||||
OIDS = FALSE
|
||||
)
|
||||
TABLESPACE pg_default;
|
||||
|
||||
ALTER TABLE public.colnod_token
|
||||
OWNER to postgres;
|
||||
```
|
||||
- Subject table
|
||||
```SQL create
|
||||
-- Table: public.colnod_subject
|
||||
-- DROP TABLE public.colnod_subject;
|
||||
CREATE TABLE public.colnod_subject
|
||||
(
|
||||
id character(36) COLLATE pg_catalog."default" NOT NULL,
|
||||
description character varying(255) COLLATE pg_catalog."default",
|
||||
last_update timestamp without time zone NOT NULL,
|
||||
name character varying(255) COLLATE pg_catalog."default",
|
||||
pin character varying(255) COLLATE pg_catalog."default",
|
||||
last_modified timestamp without time zone,
|
||||
deleted boolean,
|
||||
CONSTRAINT colnod_subject_pkey PRIMARY KEY (id)
|
||||
)
|
||||
WITH (
|
||||
OIDS = FALSE
|
||||
)
|
||||
TABLESPACE pg_default;
|
||||
|
||||
ALTER TABLE public.colnod_subject
|
||||
OWNER to postgres;
|
||||
```
|
||||
- Subject attributes table
|
||||
```SQL create
|
||||
-- Table: public.colnod_subject_attribute
|
||||
-- DROP TABLE public.colnod_subject_attribute;
|
||||
CREATE TABLE public.colnod_subject_attribute
|
||||
(
|
||||
id character varying(255) COLLATE pg_catalog."default" NOT NULL,
|
||||
attribute_key character varying(255) COLLATE pg_catalog."default",
|
||||
attribute_value character varying(255) COLLATE pg_catalog."default",
|
||||
subject_id character(36) COLLATE pg_catalog."default",
|
||||
CONSTRAINT colnod_subject_attribute_pkey PRIMARY KEY (id)
|
||||
)
|
||||
WITH (
|
||||
OIDS = FALSE
|
||||
)
|
||||
TABLESPACE pg_default;
|
||||
|
||||
ALTER TABLE public.colnod_subject_attribute
|
||||
OWNER to postgres;
|
||||
```
|
||||
- Config
|
||||
```SQL create
|
||||
-- Table: public.config
|
||||
-- DROP TABLE public.config;
|
||||
CREATE TABLE public.config
|
||||
(
|
||||
last_sync bigint NOT NULL DEFAULT 0,
|
||||
CONSTRAINT config_pkey PRIMARY KEY (last_sync)
|
||||
)
|
||||
WITH (
|
||||
OIDS = FALSE
|
||||
)
|
||||
TABLESPACE pg_default;
|
||||
|
||||
ALTER TABLE public.config
|
||||
OWNER to postgres;
|
||||
```
|
||||
## Possible checks
|
||||
[here](https://gitlab.com/spaceti-app/integrations/acs/colnod-connector/blob/master/doc/possible-checks.md)
|
||||
|
||||
|
||||
@ -1 +1 @@
|
||||
Subproject commit a818055b75dc0de97e26be44cbbfd2e94516c09e
|
||||
Subproject commit 3640c0db5d1e24b314b00cc2b0dd61915080381b
|
||||
@ -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,10 +1,12 @@
|
||||
#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);
|
||||
@ -18,89 +20,126 @@ ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, con
|
||||
* @return signal with nullptr when something went wrong
|
||||
* @return signal with data when valid data returned
|
||||
*/
|
||||
void ColnodAPI::downloadData(const qint64 &time)
|
||||
bool ColnodAPI::downloadData(const qint64 &time)
|
||||
{
|
||||
// Have to get Login
|
||||
auto login = requestLogin();
|
||||
Q_ASSERT(login);
|
||||
if (login->networkReply() == nullptr) {
|
||||
qCCritical(colnod) << "Not possible to create login request";
|
||||
return false;
|
||||
}
|
||||
connect(login.get(), &serversdk::Request::finished, this, [=](){
|
||||
// Get login token
|
||||
if (!checkRequest(login)) {
|
||||
if (login->status() != 200) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
AuthToken token;
|
||||
|
||||
if (checkResponse(login->responseData())) {
|
||||
qCWarning(colnod) << "empty response data when logging in";
|
||||
emit downloadDataFinished(nullptr);
|
||||
return false;
|
||||
}
|
||||
|
||||
token.fromJson(login->responseData());
|
||||
authToken = token.id();
|
||||
if (authToken.isEmpty()) {
|
||||
qCCritical(colnod) << "Token uuid is empty";
|
||||
emit downloadDataFinished(nullptr);
|
||||
return false;
|
||||
}
|
||||
|
||||
auto data = std::make_shared<Data>();
|
||||
|
||||
auto errorHandler = [=](std::shared_ptr<serversdk::Request> request){
|
||||
if (!checkRequest(request)) {
|
||||
qWarning(colnod) << "ERROR during calling" << request->url() << ", request unsuccessful";
|
||||
mValid = false;
|
||||
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";
|
||||
mValid = false;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// if I have all data emit downloadDataFinished
|
||||
connect(this, &ColnodAPI::partOfDataReady, this, &ColnodAPI::areDataReady);
|
||||
|
||||
Timestamp timestamp;
|
||||
timestamp.setTimestamp(time);
|
||||
|
||||
auto checkData = [=]() {
|
||||
int dataCount = data->incrementCounter();
|
||||
if ( dataCount > 5) {
|
||||
qCCritical(colnod) << "check data cannnot be higher then 4";
|
||||
}
|
||||
Q_ASSERT(dataCount < 5);
|
||||
if (dataCount == 4) {
|
||||
qInfo(colnod) << tab << "- src col:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
|
||||
"] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
|
||||
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
|
||||
!data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
|
||||
qInfo(colnod) << dash;
|
||||
}
|
||||
for (auto token : data->updatedTokens) {
|
||||
qInfo(colnod) << Message::massageTemplate("Download updated", "token", "colnod", token->name());
|
||||
}
|
||||
for (auto id : data->deletedTokens) {
|
||||
qInfo(colnod) << Message::massageTemplate("Download deleted", "token", "colnod", id);
|
||||
}
|
||||
for (auto subject : data->updatedSubjects) {
|
||||
qInfo(colnod) << Message::massageTemplate("Download updated", "subject", "colnod", subject->name());
|
||||
}
|
||||
for (auto id : data->deletedSubjects) {
|
||||
qInfo(colnod) << Message::massageTemplate("Download deleted", "token", "colnod", id);
|
||||
}
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
|
||||
!data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
|
||||
qInfo(colnod) << dash;
|
||||
}
|
||||
emit downloadDataFinished(data);
|
||||
}
|
||||
};
|
||||
|
||||
auto tokensRequest = getTokensUpdated(timestamp);
|
||||
connect(tokensRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveUpdatedTokens(data, tokensRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
if (!saveUpdatedTokens(data, tokensRequest->responseData())) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
checkData();
|
||||
});
|
||||
|
||||
auto deletedTokensRequest = getTokensDeleted(timestamp);
|
||||
connect(deletedTokensRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(deletedTokensRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveDeletedTokens(data, deletedTokensRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
if (!saveDeletedTokens(data, deletedTokensRequest->responseData())) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
checkData();
|
||||
});
|
||||
|
||||
auto subjectsRequest = getSubjectsUpdated(timestamp);
|
||||
connect(subjectsRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(subjectsRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveUpdatedSubjects(data, subjectsRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
if (!saveUpdatedSubjects(data, subjectsRequest->responseData())) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
checkData();
|
||||
});
|
||||
|
||||
auto deletedSubjectsRequest = getSubjectsDeleted(timestamp);
|
||||
connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, errorHandler);
|
||||
connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, [=](){
|
||||
saveDeletedSubjects(data, deletedSubjectsRequest->responseData());
|
||||
emit partOfDataReady(data);
|
||||
if (!saveDeletedSubjects(data, deletedSubjectsRequest->responseData())) {
|
||||
emit downloadDataFinished(nullptr);
|
||||
return;
|
||||
}
|
||||
checkData();
|
||||
});
|
||||
return true;
|
||||
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
void ColnodAPI::processData(const std::shared_ptr<Data> &data)
|
||||
{
|
||||
for (const auto &token : data->updatedTokens) {
|
||||
qInfo(colnod).noquote() << Message::massageTemplate("Updating", "token", "colnod", token->name());
|
||||
}
|
||||
for (const auto &id : data->deletedTokens) {
|
||||
qInfo(colnod).noquote() << Message::massageTemplate("Deleting", "token", "colnod", id);
|
||||
}
|
||||
qInfo(colnod) << tab << "- push col:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
|
||||
"] [ added/updated : deleted ]";
|
||||
|
||||
connect(this, &ColnodAPI::partOfDataProcessFinished, this, &ColnodAPI::isDataProcessFinished);
|
||||
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
|
||||
qInfo(colnod) << dash;
|
||||
}
|
||||
qInfo(colnod) << tab << "-> DATA PROCESSED TO COLNOD:";
|
||||
qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS UPDATED";
|
||||
qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
|
||||
qInfo(colnod) << dash;
|
||||
|
||||
|
||||
connect(this, &ColnodAPI::partOfDataProcessFinished, this, &ColnodAPI::isDataProcessFinished);
|
||||
if ( !data->updatedTokens.isEmpty() && !mDryMode) {
|
||||
setTokens(data->updatedTokens);
|
||||
} else {
|
||||
@ -111,6 +150,9 @@ void ColnodAPI::processData(const std::shared_ptr<Data> &data)
|
||||
} else {
|
||||
emit partOfDataProcessFinished();
|
||||
}
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
|
||||
qInfo(colnod) << dash;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<serversdk::Request> ColnodAPI::requestLogin()
|
||||
@ -174,15 +216,17 @@ std::shared_ptr<serversdk::Request> ColnodAPI::setTokens(const QHash<QString, st
|
||||
connect(request.get(), &serversdk::Request::finished, [=](){
|
||||
if (!checkRequest(request)) {
|
||||
qCritical(colnod) << "ERROR during calling /TokenManager/setTokens, request unsuccessful. EXIT";
|
||||
emit error();
|
||||
}
|
||||
if (checkResponse(request->responseData())) {
|
||||
for (const auto &token : tokens) {
|
||||
qInfo(colnod).noquote() << Message::massageTemplate("Updated", "token", "colnod", token->name());
|
||||
}
|
||||
emit partOfDataProcessFinished();
|
||||
}
|
||||
else {
|
||||
qWarning(colnod) << "Tokens wasn't updated";
|
||||
mValid = false;
|
||||
emit partOfDataProcessFinished();
|
||||
emit partOfDataProcessFinished(false);
|
||||
}
|
||||
});
|
||||
return request;
|
||||
@ -196,15 +240,17 @@ std::shared_ptr<serversdk::Request> ColnodAPI::deleteTokens(const QList<QString>
|
||||
connect(request.get(), &serversdk::Request::finished, [=](){
|
||||
if (!checkRequest(request)) {
|
||||
qCritical(colnod) << "ERROR during calling /TokenManager/deleteTokens, request unsuccessful. EXIT";
|
||||
emit error();
|
||||
}
|
||||
if (checkResponse(request->responseData())) {
|
||||
for (const auto &id : ids) {
|
||||
qInfo(colnod).noquote() << Message::massageTemplate("Deleted", "token", "colnod", id);
|
||||
}
|
||||
emit partOfDataProcessFinished();
|
||||
}
|
||||
else {
|
||||
qWarning(colnod) << "Tokens wasn't deleted";
|
||||
mValid = false;
|
||||
emit partOfDataProcessFinished();
|
||||
emit partOfDataProcessFinished(false);
|
||||
}
|
||||
});
|
||||
return request;
|
||||
@ -218,10 +264,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()
|
||||
@ -239,17 +282,6 @@ void ColnodAPI::setPassword(const QString &password)
|
||||
mPassword = password;
|
||||
}
|
||||
|
||||
qint64 ColnodAPI::lastSync() const
|
||||
{
|
||||
return mLastSync.timestamp();
|
||||
}
|
||||
|
||||
void ColnodAPI::setlastSync(const qint64 &lastSync)
|
||||
{
|
||||
mLastSync.setTimestamp(lastSync);
|
||||
}
|
||||
|
||||
|
||||
QString ColnodAPI::userName() const
|
||||
{
|
||||
return mUserName;
|
||||
@ -260,60 +292,72 @@ 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) {
|
||||
|
||||
qInfo(colnod) << tab << "-> COLNOD DATA:";
|
||||
qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
|
||||
qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
|
||||
qInfo(colnod) << tab << tab << data->updatedSubjects.size() << "SUBJECTS WERE ADDED/UPDATED";
|
||||
qInfo(colnod) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
|
||||
qInfo(colnod) << dash;
|
||||
// new
|
||||
qInfo(colnod) << "- src colnod: tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
|
||||
"] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
|
||||
//OLD
|
||||
// qInfo(colnod) << tab << "-> COLNOD DATA:";
|
||||
// qInfo(colnod) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
|
||||
// qInfo(colnod) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
|
||||
// qInfo(colnod) << tab << tab << data->updatedSubjects.size() << "SUBJECTS WERE ADDED/UPDATED";
|
||||
// qInfo(colnod) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
|
||||
// qInfo(colnod) << dash;
|
||||
|
||||
amountData = 0;
|
||||
emit downloadDataFinished(data);
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodAPI::isDataProcessFinished()
|
||||
void ColnodAPI::isDataProcessFinished(bool success)
|
||||
{
|
||||
if (!success) {
|
||||
mSuccess = false;
|
||||
}
|
||||
if (++amountProccessesFinished == 2) {
|
||||
emit dataProcessFinished();
|
||||
emit dataProcessFinished(mSuccess);
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodAPI::saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
bool ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
data->loadTokensFromJson(responseData);
|
||||
Q_ASSERT(data);
|
||||
return data->loadTokensFromJson(responseData);
|
||||
}
|
||||
|
||||
void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
bool ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
Q_ASSERT(data);
|
||||
if (responseData.isEmpty())
|
||||
return false;
|
||||
QJsonDocument doc = QJsonDocument::fromJson(responseData);
|
||||
QJsonArray items = doc.object()["items"].toArray();
|
||||
for (QJsonValueRef item : items) {
|
||||
data->deletedTokens.append(item.toString());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void ColnodAPI::saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
bool ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
data->loadSubjectsFormJson(responseData);
|
||||
Q_ASSERT(data);
|
||||
return data->loadSubjectsFormJson(responseData);
|
||||
}
|
||||
|
||||
void ColnodAPI::saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
|
||||
bool ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
|
||||
{
|
||||
Q_ASSERT(data);
|
||||
if (responseData.isEmpty())
|
||||
return false;
|
||||
QJsonDocument doc = QJsonDocument::fromJson(responseData);
|
||||
QJsonArray items = doc.object()["items"].toArray();
|
||||
for (QJsonValueRef item : items) {
|
||||
data->deletedSubjects.append(item.toString());
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodAPI::newData()
|
||||
{
|
||||
mData = std::make_shared<Data>();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ColnodAPI::checkResponse(const QByteArray &responseData)
|
||||
|
||||
@ -41,15 +41,13 @@ 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 qint64 &time);
|
||||
bool downloadData(const qint64 &time);
|
||||
void processData(const std::shared_ptr<Data> &data);
|
||||
|
||||
// New approach
|
||||
std::shared_ptr<serversdk::Request> requestLogin();
|
||||
|
||||
|
||||
std::shared_ptr<serversdk::Request> getTokensUpdated(const Timestamp &time);
|
||||
std::shared_ptr<serversdk::Request> getTokensDeleted(const Timestamp &time);
|
||||
std::shared_ptr<serversdk::Request> getSubjectsUpdated(const Timestamp &time);
|
||||
@ -63,26 +61,21 @@ public:
|
||||
void setUserName(const QString &userName);
|
||||
QString password() const;
|
||||
void setPassword(const QString &password);
|
||||
qint64 lastSync() const;
|
||||
void setlastSync(const qint64 &lastSync);
|
||||
|
||||
bool isValid();
|
||||
|
||||
private:
|
||||
Q_SLOT void areDataReady(std::shared_ptr<Data> data);
|
||||
Q_SLOT void isDataProcessFinished();
|
||||
Q_SLOT void areDataReady(const std::shared_ptr<Data>& data);
|
||||
Q_SLOT void isDataProcessFinished(bool success);
|
||||
|
||||
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 newData();
|
||||
bool saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
bool saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
bool saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
bool saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
|
||||
|
||||
bool checkResponse(const QByteArray &responseData);
|
||||
|
||||
QByteArray getTimestampJson(const qint64 &time);
|
||||
std::shared_ptr<serversdk::Request> composeRequest(const QString &endpoint, const QByteArray &data);
|
||||
|
||||
bool checkRequest(const std::shared_ptr<serversdk::Request> &request);
|
||||
@ -91,8 +84,8 @@ private:
|
||||
signals:
|
||||
void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());
|
||||
void partOfDataReady(std::shared_ptr<Data> = std::shared_ptr<Data>());
|
||||
void partOfDataProcessFinished();
|
||||
void dataProcessFinished();
|
||||
void partOfDataProcessFinished(bool success = true);
|
||||
void dataProcessFinished(bool success = true);
|
||||
|
||||
void error();
|
||||
|
||||
@ -104,8 +97,7 @@ private:
|
||||
Timestamp mLastSync;
|
||||
bool mDryMode = false;
|
||||
bool mValid = true;
|
||||
|
||||
std::shared_ptr<Data> mData;
|
||||
bool mSuccess = true;
|
||||
|
||||
QString authToken;
|
||||
qint16 amountData = 0;
|
||||
|
||||
@ -9,8 +9,11 @@ void Data::clear()
|
||||
deletedSubjects.clear();
|
||||
}
|
||||
|
||||
void Data::loadTokensFromJson(const QByteArray &data)
|
||||
bool Data::loadTokensFromJson(const QByteArray &data)
|
||||
{
|
||||
if (data.isEmpty())
|
||||
return false;
|
||||
|
||||
auto doc = QJsonDocument::fromJson(data);
|
||||
auto items = doc.object()["items"].toArray();
|
||||
for (auto item : items) {
|
||||
@ -19,10 +22,14 @@ void Data::loadTokensFromJson(const QByteArray &data)
|
||||
token->fromJson(doc.toJson());
|
||||
updatedTokens.insert(token->id(), token);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Data::loadSubjectsFormJson(const QByteArray &data)
|
||||
bool Data::loadSubjectsFormJson(const QByteArray &data)
|
||||
{
|
||||
if (data.isEmpty())
|
||||
return false;
|
||||
|
||||
auto doc = QJsonDocument::fromJson(data);
|
||||
auto items = doc.object()["items"].toArray();
|
||||
for (auto item : items) {
|
||||
@ -31,4 +38,10 @@ void Data::loadSubjectsFormJson(const QByteArray &data)
|
||||
subject->fromJson(doc.toJson());
|
||||
updatedSubjects.insert(subject->id(), subject);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
int Data::incrementCounter()
|
||||
{
|
||||
return ++counter;
|
||||
}
|
||||
|
||||
@ -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 + "'";
|
||||
}
|
||||
@ -28,13 +30,19 @@ public:
|
||||
|
||||
void clear();
|
||||
|
||||
void loadTokensFromJson(const QByteArray &data);
|
||||
void loadSubjectsFormJson(const QByteArray &data);
|
||||
bool loadTokensFromJson(const QByteArray &data);
|
||||
bool loadSubjectsFormJson(const QByteArray &data);
|
||||
|
||||
QHash<QString, std::shared_ptr<Token>> updatedTokens;
|
||||
QList<QString> deletedTokens;
|
||||
QHash<QString, std::shared_ptr<Subject>> updatedSubjects;
|
||||
QList<QString> deletedSubjects;
|
||||
|
||||
int incrementCounter();
|
||||
|
||||
|
||||
private:
|
||||
int counter = 0;
|
||||
};
|
||||
|
||||
struct PreparedData
|
||||
@ -46,8 +54,8 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
// 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);
|
||||
}
|
||||
@ -46,32 +46,49 @@ std::shared_ptr<Data> DatabaseAPI::downloadData()
|
||||
}
|
||||
|
||||
return composeData(updatedQuery, deletedQuery);
|
||||
// TODO: why emiting signal??
|
||||
// this can return Strucutre
|
||||
//emit downloadDataFinished(composeData(updatedQuery, deletedQuery));
|
||||
}
|
||||
|
||||
bool DatabaseAPI::processData(const std::shared_ptr<Data> &data)
|
||||
{
|
||||
uploadTokens(data->updatedTokens);
|
||||
uploadSubjects(data->updatedSubjects);
|
||||
deleteItems(data->deletedTokens, "colnod_token");
|
||||
deleteItems(data->deletedSubjects, "colnod_subject");
|
||||
if ( !data->updatedTokens.isEmpty() ||
|
||||
!data->updatedSubjects.isEmpty() ||
|
||||
!data->deletedTokens.isEmpty() ||
|
||||
!data->deletedSubjects.isEmpty()) {
|
||||
bool res = true;
|
||||
if (!uploadTokens(data->updatedTokens)) {
|
||||
res = false;
|
||||
}
|
||||
if (!uploadSubjects(data->updatedSubjects)) {
|
||||
res = false;
|
||||
}
|
||||
if (!deleteItems(data->deletedTokens, "colnod_token")) {
|
||||
res = false;
|
||||
}
|
||||
if (!deleteItems(data->deletedSubjects, "colnod_subject")) {
|
||||
res = false;
|
||||
}
|
||||
|
||||
qInfo(database) << tab << "- push db:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
|
||||
"] subjects [" << data->updatedSubjects.size() << ":" << data->deletedSubjects.size() << "] [ added/updated : deleted ]";
|
||||
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
|
||||
!data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
|
||||
qInfo(database) << dash;
|
||||
}
|
||||
qInfo(database) << tab << "-> DATA PROCESSED TO DATABASE:";
|
||||
qInfo(database) << tab << tab << data->updatedTokens.size() << "TOKENS ADDED/UPDATED";
|
||||
qInfo(database) << tab << tab << data->deletedTokens.size() << "TOKENS DELETED";
|
||||
qInfo(database) << tab << tab << data->updatedSubjects.size() << "SUBJECTS ADDED/UPDATED";
|
||||
qInfo(database) << tab << tab << data->deletedSubjects.size() << "SUBJECTS DELETED";
|
||||
for (auto token : data->updatedTokens) {
|
||||
qInfo(database) << Message::massageTemplate("Updated", "token", "database", token->name());
|
||||
}
|
||||
for (auto id : data->deletedTokens) {
|
||||
qInfo(database) << Message::massageTemplate("Deleted", "token", "database", id);
|
||||
}
|
||||
for (auto subject : data->updatedSubjects) {
|
||||
qInfo(database) << Message::massageTemplate("Updated", "subject", "database", subject->name());
|
||||
}
|
||||
for (auto id : data->deletedSubjects) {
|
||||
qInfo(database) << Message::massageTemplate("Deleted", "token", "database", id);
|
||||
}
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty() ||
|
||||
!data->updatedSubjects.isEmpty() || !data->deletedSubjects.isEmpty()) {
|
||||
qInfo(database) << dash;
|
||||
}
|
||||
|
||||
// TODO: add error handling
|
||||
return true;
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
@ -86,10 +103,21 @@ std::shared_ptr<Data> DatabaseAPI::composeData(const QSqlQuery &updatedQuery, QS
|
||||
data->deletedTokens.append(deletedQuery.value(0).toString());
|
||||
}
|
||||
|
||||
qInfo(database) << tab << "-> DATABASE DATA:";
|
||||
qInfo(database) << tab << tab << data->updatedTokens.size() << "TOKENS WERE ADDED/UPDATED";
|
||||
qInfo(database) << tab << tab << data->deletedTokens.size() << "TOKENS MARKED FOR DELETION";
|
||||
qInfo(database) << tab << "- src db:" << tab << "tokens [" << data->updatedTokens.size() << ":" << data->deletedTokens.size() <<
|
||||
"] [ added/updated : deleted ]";
|
||||
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
|
||||
qInfo(database) << dash;
|
||||
}
|
||||
for (auto token : data->updatedTokens) {
|
||||
qInfo(database) << Message::massageTemplate("Download updated", "token", "database", token->name());
|
||||
}
|
||||
for (auto id : data->deletedTokens) {
|
||||
qInfo(database) << Message::massageTemplate("Download deleted", "token", "database", id);
|
||||
}
|
||||
if (!data->updatedTokens.isEmpty() || !data->deletedTokens.isEmpty()) {
|
||||
qInfo(database) << dash;
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
@ -118,24 +146,7 @@ void DatabaseAPI::setLastSync(qint64 timestamp)
|
||||
}
|
||||
}
|
||||
|
||||
void DatabaseAPI::reupdateUpdated(const QHash<QString, std::shared_ptr<Token>> &tokens)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
for (const auto &token : tokens){
|
||||
query.prepare("UPDATE colnod_token SET last_update = :last_update WHERE id = :id");
|
||||
query.bindValue(":last_update", token->lastUpdate());
|
||||
query.bindValue(":id", token->id());
|
||||
if (!executeQuery(query)) {
|
||||
qWarning(database) << "ERROR during updating last update of token:" << token->name() << ", it will be synced from Colnod to db in next sync. Last modified will be invalid";
|
||||
}
|
||||
}
|
||||
|
||||
qInfo(database) << equals;
|
||||
qInfo(database) << "Synchronize last update in database with colnod";
|
||||
qInfo(database) << equals;
|
||||
}
|
||||
|
||||
void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
|
||||
void DatabaseAPI::reupdateDeleted(const QList<QString>& ids)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
for (const auto &id : ids){
|
||||
@ -148,7 +159,6 @@ void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
qint64 DatabaseAPI::getNow()
|
||||
@ -159,48 +169,19 @@ qint64 DatabaseAPI::getNow()
|
||||
return -1;
|
||||
}
|
||||
query.next();
|
||||
qDebug() << "Database time:" << QDateTime::fromMSecsSinceEpoch(query.value(0).toLongLong()).toString("yyyy-MM-dd hh:mm:ss.zzz");
|
||||
qDebug() << "Current time:" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
|
||||
return query.value(0).toLongLong();
|
||||
}
|
||||
|
||||
void DatabaseAPI::initNewTokens()
|
||||
bool DatabaseAPI::uploadTokens(const QHash<QString, std::shared_ptr<Token>> &tokens, const QSet<QString> &filters)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
if (!executeQuery(query, "SELECT * FROM colnod_token WHERE name IS NULL")) {
|
||||
qWarning(database) << "ERROR during getting uninitialized tokens";
|
||||
}
|
||||
QHash<QString, std::shared_ptr<Token>> tokensToInit;
|
||||
auto list = utils->tableFromQuery<Token>(query);
|
||||
for (const auto &token : list) {
|
||||
qint16 num = getNumOfTokensOfSubject(token->subjectId());
|
||||
token->setName(getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
|
||||
token->setDescription("mobile");
|
||||
token->setTokenData(token->tokenData().toUpper());
|
||||
tokensToInit.insert(token->id(), token);
|
||||
|
||||
qInfo(database).noquote() << Message::massageTemplate("Inicializing new", "token", "database", token->name());
|
||||
}
|
||||
uploadTokens(tokensToInit);
|
||||
}
|
||||
|
||||
bool DatabaseAPI::uploadTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
|
||||
{
|
||||
// TODO: first check if OK, then message
|
||||
// OK -> token was updated
|
||||
// ERROR -> not possible to update
|
||||
auto query = mDbMan->createQuery();
|
||||
for (const auto &token : tokens) {
|
||||
// Get token
|
||||
|
||||
if (exists(token->id(), "colnod_token")) {
|
||||
query = utils->updateTable(token.get(), "colnod_token");
|
||||
query = utils->updateTable(token.get(), "colnod_token", filters);
|
||||
if (filters.contains("last_modified"))
|
||||
qInfo(database).noquote() << Message::massageTemplate("Updating", "token", "database", token->name());
|
||||
}
|
||||
else {
|
||||
// TODO: first check if OK, then message
|
||||
// OK -> token was updated
|
||||
// ERROR -> not possible to update
|
||||
query = utils->insertIntoTable(token.get(), "colnod_token");
|
||||
qInfo(database).noquote() << Message::massageTemplate("Adding", "token", "database", token->name());
|
||||
}
|
||||
@ -251,6 +232,19 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
QString nowString = QDateTime::fromMSecsSinceEpoch(getLastSync()).toString("yyyy-MM-dd hh:mm:ss.zzz");
|
||||
|
||||
if (tableName == "colnod_subject") {
|
||||
for (const auto &id : ids) {
|
||||
query.prepare("DELETE FROM colnod_subject_attribute WHERE subject_id = :id");
|
||||
query.bindValue(":id", id);
|
||||
if (!executeQuery(query)) {
|
||||
qWarning(database) << "ERROR during marking as deleted:" << id;
|
||||
mValid = false;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const auto &id : ids) {
|
||||
qInfo(database).noquote() << Message::massageTemplate("Deleting", tableName.mid(tableName.indexOf("_") + 1, tableName.length() - 1), "database", id);
|
||||
|
||||
@ -258,7 +252,8 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
|
||||
query.bindValue(":id", id);
|
||||
query.bindValue(":now", nowString);
|
||||
if (!executeQuery(query)) {
|
||||
qWarning(database) << "ERROR during marking token as deleted:" << id;
|
||||
qWarning(database) << "ERROR during marking as deleted:" << id;
|
||||
mValid = false;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -268,35 +263,18 @@ bool DatabaseAPI::deleteItems(const QList<QString> &ids, const QString &tableNam
|
||||
std::shared_ptr<Token> DatabaseAPI::getToken(const QString &id)
|
||||
{
|
||||
auto query = mDbMan->createQuery();
|
||||
query.prepare("SELECT * FROM colnod_token WHERE d = :id");
|
||||
query.prepare("SELECT * FROM colnod_token WHERE id = :id");
|
||||
query.bindValue(":id", id);
|
||||
if (!executeQuery(query)) {
|
||||
qCritical(database) << "ERROR during accessing existing tokens. EXIT";
|
||||
emit error();
|
||||
return nullptr;
|
||||
}
|
||||
auto list = utils->tableFromQuery<Token>(query);
|
||||
if (list.isEmpty())
|
||||
return nullptr;
|
||||
return std::make_shared<Token>();
|
||||
return list.at(0);
|
||||
}
|
||||
|
||||
bool DatabaseAPI::isAlreadyDeleted(const QString &id)
|
||||
{
|
||||
auto token = getToken(id);
|
||||
if (!token) {
|
||||
if (id.isEmpty()) {
|
||||
|
||||
}
|
||||
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;
|
||||
|
||||
}
|
||||
|
||||
bool DatabaseAPI::isValid()
|
||||
{
|
||||
return mValid;
|
||||
|
||||
@ -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,21 +31,17 @@ public:
|
||||
bool processData(const std::shared_ptr<Data> &data);
|
||||
qint64 getLastSync();
|
||||
void setLastSync(qint64 timestamp);
|
||||
void reupdateUpdated(const QHash<QString, std::shared_ptr<Token> > &tokens);
|
||||
void reupdateDeleted(const QList<QString> ids);
|
||||
void reupdateDeleted(const QList<QString>& ids);
|
||||
qint64 getNow();
|
||||
|
||||
void initNewTokens();
|
||||
|
||||
// process data
|
||||
bool uploadTokens(const QHash<QString, std::shared_ptr<Token> > &tokens);
|
||||
bool uploadTokens(const QHash<QString, std::shared_ptr<Token> > &tokens, const QSet<QString> &filters = {});
|
||||
bool uploadSubjects(const QHash<QString, std::shared_ptr<Subject> > &subjects);
|
||||
bool deleteItems(const QList<QString> &ids, const QString &tableName);
|
||||
|
||||
std::shared_ptr<Token> getToken(const QString &id);
|
||||
|
||||
bool isAlreadyDeleted(const QString &id);
|
||||
|
||||
bool isValid();
|
||||
|
||||
qint16 getNumOfTokensOfSubject(const QString &id);
|
||||
@ -54,7 +50,6 @@ public:
|
||||
private:
|
||||
int exists(const QString &id, const QString &tableName);
|
||||
|
||||
QSqlQuery getUpdatedTokens();
|
||||
std::shared_ptr<Data> composeData(const QSqlQuery &updatedQuery, QSqlQuery &deletedQuery);
|
||||
|
||||
signals:
|
||||
|
||||
@ -13,7 +13,6 @@ class SubjectAttribute : public serversdk::DatabaseTable {
|
||||
TABLE_PROPERTY(QString, subjectId, setSubjectId, "")
|
||||
};
|
||||
|
||||
|
||||
class Subject : public serversdk::DatabaseTable {
|
||||
Q_OBJECT
|
||||
TABLE_PROPERTY(QString, id, setId, QString())
|
||||
@ -24,7 +23,6 @@ class Subject : public serversdk::DatabaseTable {
|
||||
TABLE_PROPERTY(QDateTime, lastModified, setLastModified, QDateTime())
|
||||
TABLE_PROPERTY(bool, deleted, setDeleted, false)
|
||||
|
||||
|
||||
public:
|
||||
Subject() = default;
|
||||
explicit Subject(const QString& name);
|
||||
@ -32,7 +30,6 @@ public:
|
||||
bool fromJson(const QByteArray &data) override;
|
||||
QList<std::shared_ptr <SubjectAttribute>> getAttributes();
|
||||
|
||||
|
||||
private:
|
||||
QList<std::shared_ptr <SubjectAttribute>> attributes;
|
||||
};
|
||||
|
||||
@ -43,14 +43,7 @@ bool SyncManager::startSynchronization()
|
||||
return false;
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "SYNCHRONIZATION BEGIN";
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "DOWNLOADING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager).noquote() << "Modified data since last synchronization (" << mlastSync.toDateString() << "):";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager) << tab << "- begin sync ( previous sync" << mlastSync.toDateString() << ")";
|
||||
|
||||
// GETTING DATA FROM DATABASE
|
||||
auto databaseData = database->downloadData();
|
||||
@ -60,83 +53,69 @@ 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(mlastSync.timestamp());
|
||||
connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](const std::shared_ptr<Data> &colnodData) {
|
||||
if (!colnodData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
|
||||
// NOW I SHOULD HAVE VALID DATA FROM COLNOD
|
||||
|
||||
|
||||
std::unique_ptr<PreparedData> preparedData = prepareDataNew(databaseData, colnodData);
|
||||
if (!preparedData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
qCritical(syncmanager) << "Not possible to compose data";
|
||||
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;
|
||||
|
||||
if (!database->processData(preparedData->databaseData)) {
|
||||
if (!database->processData(preparedData->colnodData)) {
|
||||
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;
|
||||
connect(colnod.get(), &ColnodAPI::dataProcessFinished, [&,syncBegin](bool success){
|
||||
if (!success) {
|
||||
qCritical(syncmanager) << "Not possible to upload data to colnod";
|
||||
}
|
||||
|
||||
// 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);
|
||||
auto tokensRequest = colnod->getTokensUpdated(time);
|
||||
|
||||
// updated data are ready
|
||||
connect(colnod.get(), &ColnodAPI::partOfDataReady, [=](const std::shared_ptr<Data> &uploadedData){
|
||||
connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
|
||||
|
||||
auto uploadedData = std::make_shared<Data>();
|
||||
uploadedData->loadTokensFromJson(tokensRequest->responseData());
|
||||
|
||||
if (!uploadedData) {
|
||||
qCritical(syncmanager) << "Not possible to get correct data from colnod";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
if (!database->uploadTokens(uploadedData->updatedTokens)) {
|
||||
if (!database->uploadTokens(uploadedData->updatedTokens, {"lastModified"})) {
|
||||
qCritical(syncmanager) << "Not possible to upload data to database";
|
||||
QCoreApplication::exit(-1);
|
||||
return;
|
||||
}
|
||||
database->reupdateDeleted(uploadedData->deletedTokens);
|
||||
database->reupdateDeleted(databaseData->deletedTokens);
|
||||
|
||||
if (!database->isValid() || !colnod->isValid()) {
|
||||
qWarning(syncmanager) << "Synchronization was unsuccessful, next run of sync will be with same last sync time, check warnings";
|
||||
qWarning(syncmanager) << "Unsuccessful FINISH, 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) << "Successful FINISH";
|
||||
}
|
||||
|
||||
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";
|
||||
colnod->processData(preparedData->databaseData);
|
||||
});
|
||||
|
||||
return true;
|
||||
@ -151,48 +130,6 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
|
||||
QList<QString> conflicts;
|
||||
QList<QString> alreadySynced;
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager) << "Resolve conflicts ( changes on same item on both Colnod and DB ):";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// 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);
|
||||
@ -216,20 +153,67 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
preparedDatabaseData->deletedTokens = databaseData->deletedTokens;
|
||||
|
||||
qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << tab << "- prep db:" << tab << "tokens [" << preparedDatabaseData->updatedTokens.size() << ":" << preparedDatabaseData->deletedTokens.size() <<
|
||||
"] [ added/updated : deleted ]";
|
||||
|
||||
// add all data which should be pushed to database
|
||||
for (const auto &colnodToken : colnodData->updatedTokens) {
|
||||
|
||||
// not conflict so add to prepered tokens
|
||||
if (!databaseData->updatedTokens.contains(colnodToken->id())) {
|
||||
auto token = database->getToken(colnodToken->id());
|
||||
if (!token) {
|
||||
qCritical(syncmanager) << "Not possible to access database.";
|
||||
return nullptr;
|
||||
}
|
||||
if ( token ) {
|
||||
// alredy synced ( tokens are same )
|
||||
if (token == colnodToken) {
|
||||
alreadySynced.append(colnodToken->id());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
|
||||
continue;
|
||||
}
|
||||
|
||||
// change in colnod is newer
|
||||
if (databaseData->updatedTokens.value(colnodToken->id()) < colnodToken) {
|
||||
preparedColnodData->updatedTokens.insert(colnodToken->id(), colnodToken);
|
||||
}
|
||||
else {
|
||||
conflicts.append(colnodToken->id());
|
||||
}
|
||||
}
|
||||
|
||||
for (const auto &id : colnodData->deletedTokens) {
|
||||
auto corespondingToken = database->getToken(id);
|
||||
if ( !corespondingToken) {
|
||||
qWarning(syncmanager) << "Token:" << id << ", deleted in colnod, but not exists in db";
|
||||
continue;
|
||||
}
|
||||
if ( !corespondingToken->deleted()) {
|
||||
preparedColnodData->deletedTokens.append(id);
|
||||
}
|
||||
}
|
||||
|
||||
preparedColnodData->updatedSubjects = colnodData->updatedSubjects;
|
||||
preparedColnodData->deletedSubjects = colnodData->deletedSubjects;
|
||||
|
||||
qInfo(syncmanager) << tab << "- prep col:" << tab << "tokens [" << preparedColnodData->updatedTokens.size() << ":" << preparedColnodData->deletedTokens.size() <<
|
||||
"] subjects [" << preparedColnodData->updatedSubjects.size() << ":" << preparedColnodData->deletedSubjects.size() << "] [ added/updated : deleted ]";
|
||||
|
||||
|
||||
auto preparedData = std::make_unique<PreparedData>(preparedDatabaseData, preparedColnodData);
|
||||
return preparedData;
|
||||
}
|
||||
|
||||
void SyncManager::initNewToken(std::shared_ptr<Token> token)
|
||||
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");
|
||||
@ -237,102 +221,3 @@ void SyncManager::initNewToken(std::shared_ptr<Token> token)
|
||||
|
||||
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)
|
||||
{
|
||||
Q_UNUSED(databaseData)
|
||||
Q_UNUSED(colnodData)
|
||||
|
||||
qInfo(syncmanager) << equals;
|
||||
qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
|
||||
qInfo(syncmanager) << dash;
|
||||
qInfo(syncmanager) << "Resolve conflicts ( changes on same item on both Colnod and DB ):";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
|
||||
Q_ASSERT(colnodData);
|
||||
Q_ASSERT(databaseData);
|
||||
|
||||
|
||||
// TODO: why copy data?
|
||||
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 : cloneColnodDataToProcess->updatedTokens) {
|
||||
if (cloneDatabaseDataToProcess->updatedTokens.contains(colnodToken->id())) {
|
||||
// updated in db later
|
||||
if (cloneDatabaseDataToProcess->updatedTokens.value(colnodToken->id()) > colnodToken) {
|
||||
conflicts.append(colnodToken->id());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
auto token = database->getToken(colnodToken->id());
|
||||
if ( token )
|
||||
// alredy synced ( tokens are same )
|
||||
if (token == colnodToken)
|
||||
alreadySynced.append(colnodToken->id());
|
||||
}
|
||||
// remove tokens which should be not updated
|
||||
for (const auto &id : conflicts)
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
for (const auto &id : alreadySynced)
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
|
||||
qInfo(syncmanager) << tab << "-> COLNOD DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN DATABASE TOO";
|
||||
qInfo(syncmanager) << tab << tab << alreadySynced.size() << "TOKENS WERE ALREADY SYNCED";
|
||||
|
||||
|
||||
|
||||
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 : cloneColnodDataToProcess->deletedTokens) {
|
||||
if (database->isAlreadyDeleted(id)) {
|
||||
conflicts.append(id);
|
||||
}
|
||||
}
|
||||
for (const auto &id : conflicts) {
|
||||
cloneColnodDataToProcess->deletedTokens.removeOne(id);
|
||||
}
|
||||
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ALREADY DELETED";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
conflicts.clear();
|
||||
|
||||
// chech modified from db, remove token if it was edited in colnod later
|
||||
for (const auto &databaseToken : cloneDatabaseDataToProcess->updatedTokens) {
|
||||
if (cloneColnodDataToProcess->updatedTokens.contains(databaseToken->id())) {
|
||||
if (databaseToken < cloneColnodDataToProcess->updatedTokens.value(databaseToken->id()))
|
||||
conflicts.append(databaseToken->id());
|
||||
}
|
||||
else {
|
||||
// restriction cauesed by colnod rest api
|
||||
if (databaseToken->description() != "mobile") {
|
||||
qCritical(syncmanager) << "Token:" << databaseToken->id() << "doesn't have 'mobile' in description, can't be ";
|
||||
conflicts.append(databaseToken->id());
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const auto &id : conflicts)
|
||||
cloneColnodDataToProcess->updatedTokens.remove(id);
|
||||
|
||||
qInfo(syncmanager) << tab << "-> DATABASE DATA - CHANGES:";
|
||||
qInfo(syncmanager) << tab << tab << conflicts.size() << "TOKENS WERE ADDED/UPDATED IN IN COLNOD TOO";
|
||||
qInfo(syncmanager) << dash;
|
||||
|
||||
qInfo(syncmanager) << "PREPARING DATA -> FINISHED";
|
||||
qInfo(syncmanager) << equals;
|
||||
|
||||
// Prepare data
|
||||
auto preparedData = std::make_unique<PreparedData>();
|
||||
preparedData->colnodData = cloneColnodDataToProcess;
|
||||
preparedData->databaseData = cloneDatabaseDataToProcess;
|
||||
|
||||
return preparedData;
|
||||
}
|
||||
|
||||
@ -26,17 +26,9 @@ private:
|
||||
* @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(std::shared_ptr<Token> token);
|
||||
|
||||
void updateLastUpdate(qint64 syncBegin);
|
||||
|
||||
signals:
|
||||
void syncFinished();
|
||||
|
||||
void error();
|
||||
void initNewToken(const std::shared_ptr<Token>& token);
|
||||
|
||||
private:
|
||||
std::shared_ptr<ColnodAPI> colnod;
|
||||
|
||||
@ -45,6 +45,7 @@ QByteArray Token::jsonData(const QSet<QString> &filters) const
|
||||
QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
|
||||
return doc.toJson(QJsonDocument::Compact);
|
||||
}
|
||||
|
||||
bool Token::fromJson(const QByteArray &data)
|
||||
{
|
||||
QJsonDocument doc = QJsonDocument::fromJson(data);
|
||||
@ -81,24 +82,3 @@ QByteArray Token::idsToJSON(const QList<QString> &ids)
|
||||
doc.setObject(items);
|
||||
return doc.toJson();
|
||||
}
|
||||
|
||||
|
||||
void Token::fromSQLRecord(const QSqlQuery& query)
|
||||
{
|
||||
setId(query.value(0).toString());
|
||||
a_authErrors = query.value(1).toInt();
|
||||
setDescription(query.value(2).toString());
|
||||
setNoValidity(query.value(6).toBool());
|
||||
setEnabled(query.value(3).toBool());
|
||||
QDateTime date = query.value(4).toDateTime();
|
||||
setLastUpdate(date);
|
||||
setName(query.value(5).toString());
|
||||
a_timeToLive = query.value(7).toInt();
|
||||
a_tokenBits = query.value(8).toInt();
|
||||
a_tokenData = query.value(9).toString();
|
||||
a_tokenType = query.value(10).toString();
|
||||
a_subjectId = query.value(11).toString();
|
||||
date = query.value(12).toDateTime();
|
||||
setLastModified(date);
|
||||
setDeleted(query.value(13).toBool());
|
||||
}
|
||||
|
||||
@ -65,8 +65,6 @@ public:
|
||||
lToken->subjectId() == rToken->subjectId();
|
||||
}
|
||||
|
||||
void fromSQLRecord(const QSqlQuery& query);
|
||||
|
||||
static QByteArray tokensToColnodJson(const QHash<QString, std::shared_ptr<Token> > &tokens);
|
||||
static QByteArray idsToJSON(const QList<QString> &ids);
|
||||
|
||||
|
||||
@ -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,13 +15,13 @@ 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:
|
||||
@ -39,37 +40,29 @@ void ColnodTest::login()
|
||||
QVERIFY(login->responseData().contains("id"));
|
||||
}
|
||||
|
||||
void ColnodTest::getTokens()
|
||||
{
|
||||
serversdk::RequestManager reqMan;
|
||||
ColnodAPI colnod(&reqMan);
|
||||
|
||||
// get login token
|
||||
auto login = colnod.requestLogin();
|
||||
QSignalSpy spy(login.get(), &serversdk::Request::finished);
|
||||
spy.wait();
|
||||
QString token = getLoginToken(colnod);
|
||||
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);
|
||||
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()
|
||||
{
|
||||
serversdk::RequestManager reqMan;
|
||||
ColnodAPI colnod(&reqMan);
|
||||
|
||||
colnod.downloadData(QDateTime::currentMSecsSinceEpoch());
|
||||
QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
|
||||
QVERIFY(spy.wait());
|
||||
@ -78,7 +71,6 @@ void ColnodTest::download_data_test()
|
||||
|
||||
QVERIFY(data->updatedTokens.isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
void ColnodTest::download_data_fail_test()
|
||||
{
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
#include "databaseapi.h"
|
||||
// add necessary includes here
|
||||
#include "token.h"
|
||||
|
||||
class DatabaseTest : public QObject
|
||||
{
|
||||
@ -14,6 +15,7 @@ private slots:
|
||||
void open_database_password_fail_test();
|
||||
void download_data_test();
|
||||
void download_data_fail_test();
|
||||
void get_token_test();
|
||||
};
|
||||
|
||||
void DatabaseTest::open_database_test()
|
||||
@ -76,6 +78,36 @@ void DatabaseTest::download_data_fail_test()
|
||||
QVERIFY(!db.downloadData());
|
||||
}
|
||||
|
||||
void DatabaseTest::get_token_test()
|
||||
{
|
||||
serversdk::DatabaseManager dbManager;
|
||||
DatabaseAPI db(&dbManager, false);
|
||||
{
|
||||
QTest::ignoreMessage(QtWarningMsg, "QSqlQuery::prepare: database not open");
|
||||
QTest::ignoreMessage(QtSystemMsg, "ERROR during accessing existing tokens. EXIT");
|
||||
QVERIFY(!db.getToken("6c907a42-0401-4403-8af4-9d58eb35cddc"));
|
||||
}
|
||||
|
||||
db.open();
|
||||
|
||||
auto token = db.getToken("6c907a42-0401-4403-8af4-9d58eb35cddc");
|
||||
QVERIFY(token);
|
||||
auto compareToken = std::make_shared<Token>();
|
||||
compareToken->setId("6c907a42-0401-4403-8af4-9d58eb35cddc");
|
||||
compareToken->setName("Losenicky");
|
||||
compareToken->setDescription("");
|
||||
compareToken->setLastUpdate(QDateTime::fromMSecsSinceEpoch(1543494713260));
|
||||
compareToken->setTokenData("AB1EA4D4");
|
||||
compareToken->setSubjectId("69c6e3b3-3f23-456f-a6c2-73ef08e589a4");
|
||||
QCOMPARE(compareToken, token);
|
||||
|
||||
auto compareToken1 = std::make_shared<Token>();
|
||||
auto token1 = db.getToken("non-existing-id");
|
||||
QVERIFY(token1);
|
||||
QCOMPARE(compareToken1, token1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
QTEST_APPLESS_MAIN(DatabaseTest)
|
||||
|
||||
|
||||
@ -6,29 +6,147 @@
|
||||
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 oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
|
||||
auto token = std::make_shared<Token>();
|
||||
token->setDescription("mobile");
|
||||
token->setId("id1");
|
||||
dbData->updatedTokens.insert("id1", token);
|
||||
|
||||
auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
|
||||
QVERIFY(newPreparedData->databaseData->updatedTokens.contains("id1"));
|
||||
QVERIFY(newPreparedData->databaseData->updatedSubjects.isEmpty());
|
||||
QVERIFY(newPreparedData->databaseData->deletedTokens.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 newPreparedData = sync.prepareDataNew(dbData, colnodData);
|
||||
|
||||
QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
|
||||
QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
|
||||
|
||||
auto testTokens = [=](const QSet<QString> &set, const QString &expectedId) {
|
||||
if (expectedId.isEmpty()) {
|
||||
QVERIFY(set.isEmpty());
|
||||
} else {
|
||||
QVERIFY(set.contains(expectedId));
|
||||
}
|
||||
};
|
||||
|
||||
testTokens(newPreparedData->databaseData->updatedTokens.keys().toSet(), expected_db_tokens_toupdate);
|
||||
testTokens(newPreparedData->databaseData->deletedTokens.toSet(), expected_db_tokens_todelete);
|
||||
|
||||
testTokens(newPreparedData->colnodData->updatedTokens.keys().toSet(), expected_colnod_tokens_toupdate);
|
||||
|
||||
// Can't work without access to database
|
||||
//testTokens(newPreparedData->colnodData->deletedTokens.toSet(), 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 deleted in colnod
|
||||
// out: 1 colnod token must be deleted from database
|
||||
QEXPECT_FAIL("delete 1 existing token in database", "Rare case, not sure if handling is needed", Continue);
|
||||
QTest::newRow("delete 1 existing token in database") << "" << ""
|
||||
<< "" << "id1,20191010:23:23:00"
|
||||
// expected database: toupdate << todelete
|
||||
<< "" << ""
|
||||
// expected colnod: toupdate << todelete
|
||||
<< "" << "id1";
|
||||
}
|
||||
|
||||
QTEST_MAIN(SyncManagerTest)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user