QuasarApp/Heart
4
1
Fork 0
mirror of https://github.com/QuasarApp/Heart.git synced 2025-04-28 02:34:41 +00:00
Code Issues Projects Releases Wiki Activity

remove deprecated code

Browse Source
This commit is contained in:
Andrei Yankovich 2023-02-26 20:07:35 +01:00
parent e923fbb10d
commit 438ec18e9d
18 changed files with 39 additions and 635 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -33,7 +33,6 @@ else()
endif()
# Use only for android debug builds with debugging from usb.
option(HEART_STATIC_SSL "This option enable or disabled static link ssl libraryes" OFF)
option(HEART_DEPRECATED_API "This option enable or disabled deprecated command api" OFF)
option(CMAKE_SHARE "This option enable or disabled ssl functions of nodes" OFF)
option(PRINT_SQL_QUERIES "This option enable or disabled log of all sql queries" OFF)

11
src/CMakeLists.txt
View File

@ -17,10 +17,6 @@ set(CMAKE_AUTORCC ON)
add_definitions(-DHEART_LIBRARY)
if (HEART_DEPRECATED_API)
add_definitions(-DHEART_DEPRECATED_API)
endif()
if (PRINT_SQL_QUERIES)
add_definitions(-DPRINT_SQL_QUERIES)
endif()
@ -45,13 +41,6 @@ file(GLOB SOURCE_CPP
"public/hcryptoFeatures/*.cpp" "public/hcryptoFeatures/*.h" "public/hcryptoFeatures/*.qrc"
)
if (NOT HEART_DEPRECATED_API)
file(GLOB SOURCE_CPP_DEPRECATED
"private/*_old.cpp" "private/*_old.h"
)
list(REMOVE_ITEM SOURCE_CPP ${SOURCE_CPP_DEPRECATED})
endif()
set(PUBLIC_INCUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(PUBLIC_INCUDE_DIR ${PUBLIC_INCUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/public")
set(PUBLIC_INCUDE_DIR ${PUBLIC_INCUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/public/packages")

86
src/private/abstractnodeparser_old.cpp
View File

@ -1,86 +0,0 @@
//#
//# Copyright (C) 2022-2022 QuasarApp.
//# Distributed under the lgplv3 software license, see the accompanying
//# Everyone is permitted to copy and distribute verbatim copies
//# of this license document, but changing it is not allowed.
//#
#include "abstractnodeparser_old.h"
#include "params.h"
#include "abstractnode.h"
#include "qaglobalutils.h"
#include <badrequest.h>
#include <bigdatarequest.h>
#include <closeconnection.h>
#include <ping.h>
namespace QH {
AbstractNodeParserOld::AbstractNodeParserOld(AbstractNode* parentNode): iParser(parentNode) {
debug_assert(parentNode, "Node object can't be null!");
registerPackageTypeOld<PKG::Ping>();
registerPackageTypeOld<PKG::BadRequest>();
registerPackageTypeOld<PKG::CloseConnection>();
}
AbstractNodeParserOld::~AbstractNodeParserOld() {
}
ParserResult AbstractNodeParserOld::parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
const Header &pkgHeader,
AbstractNodeInfo *sender) {
auto nodePtr = node();
if (!nodePtr) {
return ParserResult::NotProcessed;
}
if (!(sender)) {
QuasarAppUtils::Params::log("sender socket is not valid!",
QuasarAppUtils::Error);
return ParserResult::Error;
}
if (!pkg->isValid()) {
QuasarAppUtils::Params::log("incomming package is not valid!",
QuasarAppUtils::Error);
nodePtr->changeTrust(sender->networkAddress(), CRITICAL_ERROOR);
return ParserResult::Error;
}
if (PKG::Ping::commandOld() == pkg->cmd()) {
auto cmd = pkg.staticCast<PKG::Ping>();
if (!cmd->ansver()) {
cmd->setAnsver(true);
nodePtr->sendData(cmd.data(), sender, &pkgHeader);
}
emit sigPingReceived(cmd);
return ParserResult::Processed;
} else if (PKG::BadRequest::commandOld() == pkg->cmd()) {
auto cmd = static_cast<PKG::BadRequest *>(pkg.data());
emit nodePtr->requestError(cmd->errCode(), cmd->err());
return ParserResult::Processed;
} else if (PKG::CloseConnection::commandOld() == pkg->cmd()) {
if (sender->isLocal()) {
nodePtr->removeNode(sender->networkAddress());
}
return ParserResult::Processed;
}
return ParserResult::NotProcessed;
}
int AbstractNodeParserOld::version() const {
return 0;
}
QString AbstractNodeParserOld::parserId() const {
return "HeartLibAbstractAPI";
}
}

53
src/private/abstractnodeparser_old.h
View File

@ -1,53 +0,0 @@
//#
//# Copyright (C) 2022-2022 QuasarApp.
//# Distributed under the lgplv3 software license, see the accompanying
//# Everyone is permitted to copy and distribute verbatim copies
//# of this license document, but changing it is not allowed.
//#
#ifndef ABSTRACTNODEPARSER_OLD_H
#define ABSTRACTNODEPARSER_OLD_H
#include <iparser.h>
#include <ping.h>
namespace QH {
/**
* @brief The AbstractNodeParserOld class is main parser of the abstract level of the hear lib.
* @note This class some as AbstractNodeParser
*/
class AbstractNodeParserOld: public iParser
{
Q_OBJECT
public:
template<class T>
/**
* @brief registerPackageTypeOld This method register package type T.
* This is need to prepare pacakge for parsing in the parsePackage method.
*/
void registerPackageTypeOld() {
_registeredTypes[T::commandOld()] = [](){
return new T();
};
};
AbstractNodeParserOld(AbstractNode *parentNode);
~AbstractNodeParserOld() override;
ParserResult parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
const Header &pkgHeader,
AbstractNodeInfo *sender) override;
int version() const override;
QString parserId() const override;
signals:
/**
* @brief sigPingReceived This method emited
* @param ping this is received ping object.
*/
void sigPingReceived(const QSharedPointer<QH::PKG::Ping> &ping);
};
}
#endif

2
src/private/apiversion.h
View File

@ -30,8 +30,6 @@ public:
static QString commandText(){return "PROTOCKOL_VERSION_COMMAND";}
unsigned short cmd() const override {return APIVersion::command();}
unsigned short cmdOld() const override {return APIVersion::command();}
QString cmdString() const override {return APIVersion::commandText();}
const VersionData &version() const;

240
src/private/bigdataparser_old.cpp
View File

@ -1,240 +0,0 @@
/*
* Copyright (C) 2022-2022 QuasarApp.
* Distributed under the lgplv3 software license, see the accompanying
* Everyone is permitted to copy and distribute verbatim copies
* of this license document, but changing it is not allowed.
*/
#include "bigdataparser_old.h"
#include "bigdataheader.h"
#include "bigdatapart.h"
#include <bigdatarequest.h>
#include <abstractnode.h>
#include <cmath>
#include <params.h>
#include <bigdatawraper.h>
#define TIMEOUT_INTERVAL 30000
namespace QH {
BigDataParserOld::BigDataParserOld(AbstractNode* parentNode): iParser(parentNode) {
registerPackageTypeOld<PKG::BigDataWraper>();
registerPackageTypeOld<PKG::BigDataRequest>();
registerPackageTypeOld<PKG::BigDataHeader>();
registerPackageTypeOld<PKG::BigDataPart>();
}
ParserResult BigDataParserOld::parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
const Header &pkgHeader,
AbstractNodeInfo *sender) {
auto result = commandHandlerOld<PKG::BigDataRequest>(this,
&BigDataParserOld::processRequest,
pkg, sender, pkgHeader);
if (result != QH::ParserResult::NotProcessed) {
return result;
}
result = commandHandlerOld<PKG::BigDataWraper>(this,
&BigDataParserOld::processBigDataWraper,
pkg, sender, pkgHeader);
if (result != QH::ParserResult::NotProcessed) {
return result;
}
result = commandHandlerOld<PKG::BigDataHeader>(this,
&BigDataParserOld::newPackage,
pkg, sender, pkgHeader);
if (result != QH::ParserResult::NotProcessed) {
return result;
}
result = commandHandlerOld<PKG::BigDataPart>(this,
&BigDataParserOld::processPart,
pkg, sender, pkgHeader);
if (result != QH::ParserResult::NotProcessed) {
return result;
}
return ParserResult::NotProcessed;
}
int BigDataParserOld::version() const {
return 0;
}
QString BigDataParserOld::parserId() const {
return "HeartBigDataAPI";
}
void QH::BigDataParserOld::insertNewBigData(const QSharedPointer<PKG::BigDataHeader> &header) {
if (!_pool.contains(header->packageId())) {
QVector<QSharedPointer<PKG::BigDataPart>> _array;
_array.resize(header->getPackagesCount());
_pool[header->packageId()] = {header, _array, static_cast<int>(time(0))};
}
checkOutDatedPacakges(header->packageId());
}
bool BigDataParserOld::newPackage(const QSharedPointer<PKG::BigDataHeader> &header,
AbstractNodeInfo *sender,
const Header & hdr) {
if (!header->isValid())
return false;
insertNewBigData(header);
PKG::BigDataRequest request;
request.setCurrentPart(0);
request.setPackageId(header->packageId());
return node()->sendData(&request, sender, &hdr);
}
bool BigDataParserOld::processPart(const QSharedPointer<PKG::BigDataPart> &part,
AbstractNodeInfo *sender,
const Header & hdr) {
if (!_pool.contains(part->packageId())) {
return false;
}
checkOutDatedPacakges(part->packageId());
auto& localPool = _pool[part->packageId()];
localPool.chaindata[part->getPakckageNumber()] = part;
auto sendRequest = [sender, &hdr, this](int part, unsigned int id){
PKG::BigDataRequest request;
request.setCurrentPart(part);
request.setPackageId(id);
return node()->sendData(&request, sender, &hdr);
};
if (part->getPakckageNumber() + 1 < localPool.chaindata.size()) {
return sendRequest(part->getPakckageNumber() + 1,
part->packageId());
}
auto package = node()->genPackage(localPool.header->getCommand(),
sender);
if (!package)
return false;
QByteArray packageRawData;
for (int idx = 0; idx < localPool.chaindata.size(); ++idx) {
if (localPool.chaindata[idx]) {
packageRawData += localPool.chaindata[idx]->data();
} else {
return sendRequest(idx, part->packageId());
}
}
package->fromBytes(packageRawData);
if (node()->parsePackage(package, hdr, sender) == ParserResult::Error) {
return false;
}
_pool.remove(part->packageId());
return true;
}
bool BigDataParserOld::processRequest(const QSharedPointer<PKG::BigDataRequest> &request,
AbstractNodeInfo *sender,
const Header &pkgHeader) {
unsigned int id = request->packageId();
if (!_pool.contains(id)) {
QuasarAppUtils::Params::log("requested data is missing!");
return false;
}
checkOutDatedPacakges(id);
const auto &localPool = _pool[id];
if (request->currentPart() >= localPool.chaindata.size()) {
return false;
}
bool fLast = localPool.chaindata.size() - 1 == request->currentPart();
const auto &data = localPool.chaindata[request->currentPart()];
if (!node()->sendData(data.data(), sender, &pkgHeader)) {
return false;
}
if (fLast) {
_pool.remove(id);
}
return true;
}
bool BigDataParserOld::processBigDataWraper(const QSharedPointer<PKG::BigDataWraper> &request,
AbstractNodeInfo *sender,
const Header &pkgHeader) {
return sendBigDataPackage(request->data(), sender, &pkgHeader);
}
bool BigDataParserOld::sendBigDataPackage(const PKG::AbstractData *data,
const AbstractNodeInfo *sender,
const QH::Header *pkgHeader) {
unsigned int sizeLimit = Package::maximumSize() - sizeof (PKG::BigDataPart);
auto rawData = data->toBytes();
auto hdr = QSharedPointer<PKG::BigDataHeader>::create();
hdr->setPackagesCount(std::ceil(rawData.size() / static_cast<double>(sizeLimit)));
hdr->setPackageId(rand());
hdr->setCommand(data->cmd());
insertNewBigData(hdr);
for (int i = 0; i < hdr->getPackagesCount(); ++i) {
auto part = QSharedPointer<PKG::BigDataPart>::create();
part->setPackageId(hdr->packageId());
part->setPakckageNumber(i);
part->setData(rawData.mid(i * sizeLimit, sizeLimit));
_pool[hdr->packageId()].chaindata[i] = part;
}
if (!node()->sendData(hdr.data(), sender, pkgHeader)) {
return false;
}
return true;
}
void BigDataParserOld::checkOutDatedPacakges(unsigned int currentProcessedId) {
int utx = time(0);
if (_pool.contains(currentProcessedId)) {
_pool[currentProcessedId].lastUpdate = utx;
}
for (auto key = _pool.keyBegin(); key != _pool.keyEnd(); ++key) {
if (utx - _pool[*key].lastUpdate > TIMEOUT_INTERVAL) {
_pool.remove(*key);
}
}
}
}

149
src/private/bigdataparser_old.h
View File

@ -1,149 +0,0 @@
/*
* Copyright (C) 2021-2022 QuasarApp.
* Distributed under the lgplv3 software license, see the accompanying
* Everyone is permitted to copy and distribute verbatim copies
* of this license document, but changing it is not allowed.
*/
#ifndef BIGDATAPARSER_OLD_H
#define BIGDATAPARSER_OLD_H
#include <iparser.h>
namespace QH {
namespace PKG {
class BigDataHeader;
class BigDataPart;
class BigDataRequest;
class BigDataWraper;
}
class AbstractNode;
class AbstractNodeInfo;
/**
* @brief The BigDataParserOld class is main manager for control big data packages.
* @note This is some a BigDataParser
*/
class BigDataParserOld final: public iParser
{
struct PoolData {
QSharedPointer<PKG::BigDataHeader> header;
QVector<QSharedPointer<PKG::BigDataPart>> chaindata;
int lastUpdate = time(0);
};
public:
template<class T>
/**
* @brief registerPackageType This method register package type T.
* This is need to prepare pacakge for parsing in the parsePackage method.
*/
void registerPackageTypeOld() {
_registeredTypes[T::commandOld()] = [](){
return new T();
};
};
template<class PackageClass,class HandlerType, class HandlerMethod>
inline ParserResult commandHandlerOld(HandlerType handlerObject, HandlerMethod method,
const QSharedPointer<QH::PKG::AbstractData> &pkg,
QH::AbstractNodeInfo *sender,
const QH::Header &pkgHeader) {
if (PackageClass::commandOld() == pkg->cmd()) {
auto data = pkg.staticCast<PackageClass>();
if (!data->isValid()) {
return QH::ParserResult::Error;
}
if(!(handlerObject->*method)(data, sender, pkgHeader)) {
return QH::ParserResult::Error;
}
return QH::ParserResult::Processed;
}
return QH::ParserResult::NotProcessed;
}
BigDataParserOld(AbstractNode* parentNode);
ParserResult parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
const Header &pkgHeader,
AbstractNodeInfo *sender) override;
int version() const override;
QString parserId() const override;
protected:
/**
* @brief newPackage This method process first header packge of the big data.
* @param header This is header package.
* @param pkgHeader This is header of an incomming package.
* @param sender This is socket object of a sender that send this package.
* @return true if packge processed successful else false
*/
bool newPackage(const QSharedPointer<PKG::BigDataHeader> &header,
AbstractNodeInfo * sender,
const Header & pkgHeader);
/**
* @brief processPart This method process part of package
* @param part This is pacakge part.
* @param pkgHeader This is header of an incomming package.
* @param sender This is socket object of a sender that send this package.
* @return true if packge processed successful else false
*/
bool processPart(const QSharedPointer<PKG::BigDataPart>& part,
AbstractNodeInfo *sender,
const QH::Header &pkgHeader);
/**
* @brief finishPart This metho process last package of big data transaction.
* @param request this is shared pointer to last part of big data transaction.
* @param pkgHeader This is header of an incomming package.
* @param sender This is socket object of a sender that send this package.
* @return true if pacakge parsed successful else false.
*/
bool processRequest(const QSharedPointer<PKG::BigDataRequest>& request,
QH::AbstractNodeInfo *sender,
const QH::Header &pkgHeader);
/**
* @brief sendBigDataPackage This method separate big pacakge and sent only heder ot serve.
* @param data This is package that will be sent to remote node.
* @param sender This is request object.
* @param pkgHeader requested header.
* @return true if package sent successful
*/
bool processBigDataWraper(const QSharedPointer<PKG::BigDataWraper> &request,
AbstractNodeInfo *sender,
const Header &pkgHeader);
private:
/**
* @brief sendBigDataPackage This method separate big pacakge and sent only heder ot serve.
* @param data This is package that will be sent to remote node.
* @param sender This is request object.
* @param pkgHeader requested header.
* @return true if package sent successful
*/
bool sendBigDataPackage(const PKG::AbstractData *data,
const QH::AbstractNodeInfo *sender,
const Header *pkgHeader);
void insertNewBigData(const QSharedPointer<PKG::BigDataHeader> &header);
void checkOutDatedPacakges(unsigned int currentProcessedId);
QHash<int, PoolData> _pool;
};
}
#endif // BIGDATAPARSER_OLD_H

1
src/private/versionisreceived.h
View File

@ -26,7 +26,6 @@ public:
static unsigned short command(){return PROTOCKOL_VERSION_RECEIVED_COMMAND;}
static QString commandText(){return "PROTOCKOL_VERSION_RECEIVED_COMMAND";}
unsigned short cmd() const override {return VersionIsReceived::command();}
unsigned short cmdOld() const override {return VersionIsReceived::command();}
QString cmdString() const override {return VersionIsReceived::commandText();}

32
src/public/abstractnode.cpp
View File

@ -48,11 +48,6 @@
#include <abstractnodeparser.h>
#include <apiversionparser.h>
#ifdef HEART_DEPRECATED_API
#include "bigdataparser_old.h"
#include "abstractnodeparser_old.h"
#endif
namespace QH {
using namespace PKG;
@ -73,12 +68,6 @@ AbstractNode::AbstractNode( QObject *ptr):
_tasksheduller = new TaskScheduler();
_apiVersionParser = new APIVersionParser(this);
#ifdef HEART_DEPRECATED_API
addApiParser<BigDataParserOld>();
auto abstractNodeParserOld = addApiParserNative<AbstractNodeParserOld>();
connect(abstractNodeParserOld.data(), &AbstractNodeParserOld::sigPingReceived,
this, &AbstractNode::receivePing, Qt::DirectConnection);
#endif
addApiParser<BigDataParser>();
auto abstractNodeParser = addApiParserNative<AbstractNodeParser>();
@ -762,26 +751,6 @@ unsigned int AbstractNode::sendData(const PKG::AbstractData *resp,
return 0;
}
#ifdef HEART_DEPRECATED_API
bool fOld = node->version().value("HeartLibAbstractAPI").max() <= 0 &&
resp->cmd() != PROTOCKOL_VERSION_RECEIVED_COMMAND &&
resp->cmd() != PROTOCKOL_VERSION_COMMAND;
Package pkg;
bool convert = false;
if (req && req->isValid()) {
if (fOld) {
convert = resp->toPackageOld(pkg, req->hash);
} else {
convert = resp->toPackage(pkg, req->hash);
}
} else {
if (fOld) {
convert = resp->toPackageOld(pkg);
} else {
convert = resp->toPackage(pkg);
}
}
#else
Package pkg;
bool convert = false;
if (req && req->isValid()) {
@ -789,7 +758,6 @@ unsigned int AbstractNode::sendData(const PKG::AbstractData *resp,
} else {
convert = resp->toPackage(pkg);
}
#endif
if (!convert) {

2
src/public/database.cpp
View File

@ -192,7 +192,7 @@ bool DataBase::upgradeDataBase() {
int currentVersion = 0;
bool fsupportUpgrade = db()->doQuery("SELECT COUNT(*) FROM DataBaseAttributes", true);
bool fsupportUpgrade = db()->doQuery("SELECT COUNT(*) FROM DataBaseAttributes", {}, true);
if (!fsupportUpgrade) {

4
src/public/iobjectprovider.h
View File

@ -121,11 +121,13 @@ public:
/**
* @brief doQuery This method execute a @a query in this database.
* @param query This is query that will be executed.
* @param bindValues This is values that need to bind before excute query.
* @param result This is query result value.
* @warning The result works onlt on await mode. Set the @a wait param to true.
* @return true if the query finished successful
*/
virtual bool doQuery(const QString& query, bool wait = false, QSqlQuery* result = nullptr) const = 0;
virtual bool doQuery(const QString& query, const QVariantMap& bindValues = {},
bool wait = false, QSqlQuery* result = nullptr) const = 0;
/**
* @brief doSql This method execute a @a query in this database.

6
src/public/isqldb.cpp
View File

@ -244,14 +244,14 @@ bool ISqlDB::replaceObject(const QSharedPointer<PKG::DBObject> &saveObject, bool
return true;
}
bool ISqlDB::doQuery(const QString &query, bool wait,
QSqlQuery *result) const {
bool ISqlDB::doQuery(const QString &query, const QVariantMap& toBind,
bool wait, QSqlQuery *result) const {
if (!_writer) {
return false;
}
return _writer->doQuery(query, wait, result);
return _writer->doQuery(query, toBind, wait, result);
}
bool ISqlDB::doSql(const QString &sqlFile, bool wait) const {

3
src/public/isqldb.h
View File

@ -108,7 +108,8 @@ public:
bool replaceObject(const QSharedPointer<QH::PKG::DBObject>& saveObject,
bool wait = false) override;
bool doQuery(const QString &query, bool wait = false, QSqlQuery* result = nullptr) const override;
bool doQuery(const QString &query, const QVariantMap& bindValues,
bool wait = false, QSqlQuery* result = nullptr) const override;
bool doSql(const QString &sqlFile, bool wait) const override;

4
src/public/package.cpp
View File

@ -27,11 +27,7 @@ bool Package::isValid() const {
if (hdr.size > maximumSize())
return false;
#ifdef HEART_DEPRECATED_API
return calcHash() == hdr.hash || calcHashOld() == hdr.hash;
#else
return calcHash() == hdr.hash;
#endif
}
void Package::reset() {

21
src/public/packages/abstractdata.cpp
View File

@ -43,27 +43,6 @@ bool AbstractData::toPackage(Package &package,
return package.isValid();
}
bool AbstractData::toPackageOld(Package &package, unsigned int triggerHash) const {
if (!checkCmd()) {
QuasarAppUtils::Params::log("You try send pacakge without QH_PACKAGE macross. Please add QH_PACKAGE macros to this class.",
QuasarAppUtils::Error);
return false;
}
if (!isValid()) {
return false;
}
package.data = toBytes();
package.hdr.command = cmdOld();
package.hdr.triggerHash = triggerHash;
package.hdr.size = package.data.size();
package.hdr.hash = package.calcHashOld();
return package.isValid();
}
bool AbstractData::checkCmd() const {
unsigned int code = typeid (*this).hash_code();
return code == localCode();

19
src/public/packages/abstractdata.h
View File

@ -28,14 +28,12 @@
*/
#define QH_PACKAGE(X, S) \
public: \
static unsigned short commandOld(){return qHash(QString(S)) % 0xFFFF;} \
static unsigned short command(){\
QByteArray ba = QString(S).toLocal8Bit();\
return qa_common::hash16(ba.data(), ba.size());\
} \
static QString commandText(){return S;} \
unsigned short cmd() const override {return X::command();} \
unsigned short cmdOld() const override {return X::commandOld();} \
QString cmdString() const override {return X::commandText();} \
protected: \
unsigned int localCode() const override {return typeid(X).hash_code();} \
@ -111,23 +109,6 @@ public:
*/
bool toPackage(Package &package, unsigned int triggerHash = 0) const;
/**
* @brief toPackageOld This method convert this class object to the package.
* For more info see Package class.
* @param package This is return value of Package class.
* @param triggerHash This is hash of the package the current class is responding to.
* @return True if convert to package finished successful.
*/
bool toPackageOld(Package &package, unsigned int triggerHash = 0) const;
/**
* @brief cmdOld - This is command of this object, (for generate cmd use macross QH_PACKAGE)
* @note Use the QH_PACKAGE macross for implement this method.
* @return global command of package.
* @see QH_PACKAGE
*/
virtual unsigned short cmdOld() const = 0;
/**
* @brief isValid This method check current object to valid.
* @return True if class isValid.

34
src/public/sqldbwriter.cpp
View File

@ -131,17 +131,35 @@ bool SqlDBWriter::initDbPrivate(const QVariantMap &params) {
return initSuccessful;
}
bool SqlDBWriter::doQueryPrivate(const QString &query, QSqlQuery* result) const {
bool SqlDBWriter::doQueryPrivate(const QString &query, const QVariantMap &bindValues, QSqlQuery* result) const {
if (!db()) {
return false;
}
QSqlQuery q(*db());
if (!q.exec(query)) {
QuasarAppUtils::Params::log("request error : " + q.lastError().text(),
QuasarAppUtils::Error);
return false;
if (bindValues.size()) {
if (!q.prepare(query)) {
QuasarAppUtils::Params::log("request error : " + q.lastError().text(),
QuasarAppUtils::Error);
return false;
}
for (auto it = bindValues.begin(); it != bindValues.end(); ++it) {
q.bindValue(it.key(), it.value());
}
if (!q.exec()) {
QuasarAppUtils::Params::log("request error : " + q.lastError().text(),
QuasarAppUtils::Error);
return false;
}
} else {
if (!q.exec(query)) {
QuasarAppUtils::Params::log("request error : " + q.lastError().text(),
QuasarAppUtils::Error);
return false;
}
}
if (result) {
@ -374,13 +392,13 @@ bool SqlDBWriter::replaceQuery(const QSharedPointer<PKG::DBObject> &ptr) const {
return workWithQuery(q, prepare, cb);
}
bool SqlDBWriter::doQuery(const QString &query,
bool SqlDBWriter::doQuery(const QString &query, const QVariantMap &bindValues,
bool wait, QSqlQuery* result) const {
wait = result || wait;
Async::Job job = [this, query, result]() {
return doQueryPrivate(query, result);
Async::Job job = [this, query, bindValues, result]() {
return doQueryPrivate(query, bindValues, result);
};
return asyncLauncher(job, wait);

6
src/public/sqldbwriter.h
View File

@ -71,7 +71,7 @@ public:
bool replaceObject(const QSharedPointer<PKG::DBObject> &ptr, bool wait = false) override;
void setSQLSources(const QStringList &list) override;
bool doQuery(const QString& query, bool wait = false, QSqlQuery *result = nullptr) const override;
bool doQuery(const QString& query, const QVariantMap& bindValues = {}, bool wait = false, QSqlQuery *result = nullptr) const override;
bool doSql(const QString &sqlFile, bool wait) const override;
/**
@ -227,7 +227,9 @@ private:
* @param result This is pointer to result value.
* @return true if query finished successfull
*/
bool doQueryPrivate(const QString& query, QSqlQuery *result) const;
bool doQueryPrivate(const QString& query,
const QVariantMap &bindValues,
QSqlQuery *result) const;
bool doSqlPrivate(const QString &sqlFile) const;