ondra/server-sdk
1
0
Fork 1
mirror of https://gitlab.com/spaceti-app/integrations/common/server-sdk.git synced 2026-07-12 16:30:44 +02:00
Code Issues Projects Releases Wiki Activity

Merge branch 'fix/line-endings' into 'master'

Browse Source 
Fix/line endings

See merge request spaceti-app/integrations/common/server-sdk!2
This commit is contained in:
Filip Bucek 2019-11-08 10:05:41 +00:00
commit 7f84057e1c
15 changed files with 654 additions and 677 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.gitlab-ci.yml
View File

@ -33,6 +33,7 @@ test:
- cd build - cd build
- make check test - make check test
# memory leak check for unittest
valgrind: valgrind:
stage: test stage: test
tags: tags:
@ -46,11 +47,17 @@ cppcheck:
stage: test stage: test
tags: tags:
- shell - shell
# Probably needed to allow failure #allow_failure: true # Probably needed to allow failure
#allow_failure: true script:
script: # run in bash
- scripts/cppcheck.sh - scripts/cppcheck.sh
# Common checks ( Line endings )
lineendings:
stage: test
tags:
- shell
script:
- scripts/check.sh
codecoverage: codecoverage:
stage: test stage: test

20
scripts/check.sh Executable file
View File

@ -0,0 +1,20 @@
#!/bin/bash
CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
source $CURRENT_DIR/common.sh
SOURCE_DIR=$PWD
cd $SOURCE_DIR
info "Checking line ending"
RESULT=$( find . -not -type d -exec file "{}" ";" | grep "ASCII text, with CRLF" | cat)
if [ ! -z "$RESULT" ]; then
echo "----------------------------------"
echo "$RESULT"
echo "----------------------------------"
fail "LF check finished with error"
fi

0
scripts/common.sh Normal file → Executable file
View File

112
src/serversdk/databasemanager.cpp
View File

@ -1,56 +1,56 @@
#include "databasemanager.h" #include "databasemanager.h"
namespace serversdk { namespace serversdk {
DatabaseManager::DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool dryMode) DatabaseManager::DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool dryMode)
: mDryMode(dryMode) : mDryMode(dryMode)
{ {
db = QSqlDatabase::addDatabase("QPSQL"); db = QSqlDatabase::addDatabase("QPSQL");
db.setDatabaseName(dbName); db.setDatabaseName(dbName);
db.setHostName(host); db.setHostName(host);
db.setUserName(user); // home-office stuff -->> db.setPort(80); db.setUserName(user); // home-office stuff -->> db.setPort(80);
db.setPassword(password); db.setPassword(password);
if (db.open()) if (db.open())
{ {
query = QSqlQuery("query", db); query = QSqlQuery("query", db);
} else { } else {
log("Opening error" + db.lastError().text()); log("Opening error" + db.lastError().text());
emit error(); emit error();
} }
} }
bool DatabaseManager::executeQuery(QSqlQuery &query) bool DatabaseManager::executeQuery(QSqlQuery &query)
{ {
if (mDryMode){ if (mDryMode){
QString sqlStatement = getLastQuery(query); QString sqlStatement = getLastQuery(query);
qDebug() << sqlStatement; qDebug() << sqlStatement;
} }
if (!mDryMode || query.isSelect()){ if (!mDryMode || query.isSelect()){
if (!query.exec()){ if (!query.exec()){
QString msg = QString("Source: Database Manager, Error: %1").arg(query.lastError().text()); QString msg = QString("Source: Database Manager, Error: %1").arg(query.lastError().text());
log(QString(msg)); log(QString(msg));
emit error(); emit error();
} }
} }
return true; return true;
} }
QString DatabaseManager::getLastQuery(const QSqlQuery& query) const QString DatabaseManager::getLastQuery(const QSqlQuery& query) const
{ {
QString str = query.lastQuery(); QString str = query.lastQuery();
QMapIterator<QString, QVariant> it(query.boundValues()); QMapIterator<QString, QVariant> it(query.boundValues());
while (it.hasNext()) while (it.hasNext())
{ {
it.next(); it.next();
str.replace(it.key(),it.value().toString()); str.replace(it.key(),it.value().toString());
} }
return str; return str;
} }
void DatabaseManager::log(const QString &msg) const void DatabaseManager::log(const QString &msg) const
{ {
qDebug() << "database logger implement logger"; qDebug() << "database logger implement logger";
} }
} // core } // core

74
src/serversdk/databasemanager.h
View File

@ -1,37 +1,37 @@
#pragma once #pragma once
#include <QSql> #include <QSql>
#include <QSqlDatabase> #include <QSqlDatabase>
#include <QSqlQuery> #include <QSqlQuery>
#include <QSqlError> #include <QSqlError>
#include <QVariant> #include <QVariant>
#include <QDebug> #include <QDebug>
#include <QDateTime> #include <QDateTime>
//#include "logger.h" //#include "logger.h"
namespace serversdk { namespace serversdk {
class DatabaseManager : public QObject class DatabaseManager : public QObject
{ {
Q_OBJECT Q_OBJECT
friend class Logger; friend class Logger;
public: public:
DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool mDryMode = false); DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool mDryMode = false);
private: private:
bool executeQuery(QSqlQuery &query); bool executeQuery(QSqlQuery &query);
QString getLastQuery(const QSqlQuery &query) const; QString getLastQuery(const QSqlQuery &query) const;
void log(const QString &msg) const; void log(const QString &msg) const;
signals: signals:
void error(); void error();
private: private:
QSqlDatabase db; QSqlDatabase db;
QSqlQuery query; QSqlQuery query;
bool mDryMode = false; bool mDryMode = false;
}; };
} // core } // core

206
src/serversdk/logger.cpp
View File

@ -1,103 +1,103 @@
#include "logger.h" #include "logger.h"
#include "loggermessage.h" #include "loggermessage.h"
#include <QLoggingCategory> #include <QLoggingCategory>
#include <QFileInfo> #include <QFileInfo>
Q_LOGGING_CATEGORY(sdkcore, "sdk.core"); Q_LOGGING_CATEGORY(sdkcore, "sdk.core");
Q_LOGGING_CATEGORY(sdknetwork, "sdk.network"); Q_LOGGING_CATEGORY(sdknetwork, "sdk.network");
Q_LOGGING_CATEGORY(sdkcompress, "sdk.compress"); Q_LOGGING_CATEGORY(sdkcompress, "sdk.compress");
namespace serversdk { namespace serversdk {
Logger* Logger::sConsumer = nullptr; Logger* Logger::sConsumer = nullptr;
//bool Logger::sShowFunction = false; //bool Logger::sShowFunction = false;
void Logger::setConsumer(Logger *consumer) void Logger::setConsumer(Logger *consumer)
{ {
sConsumer = consumer; sConsumer = consumer;
} }
Logger::Logger(QObject *parent) : QObject(parent) Logger::Logger(QObject *parent) : QObject(parent)
{ {
qRegisterMetaType<LoggerMessage>(); qRegisterMetaType<LoggerMessage>();
} }
QList<LoggerMessage> Logger::getNewMessages(int currentCount) QList<LoggerMessage> Logger::getNewMessages(int currentCount)
{ {
QMutexLocker locker(&mMutex); QMutexLocker locker(&mMutex);
QList<LoggerMessage> list; QList<LoggerMessage> list;
int count = mLogMessages.count(); int count = mLogMessages.count();
int total = count - currentCount; int total = count - currentCount;
if (total <= 0) if (total <= 0)
return list; return list;
for (int i = 0; i < total; ++i) { for (int i = 0; i < total; ++i) {
int currentIndex = currentCount; int currentIndex = currentCount;
int row = i + currentIndex; int row = i + currentIndex;
list.append(mLogMessages.at(row)); list.append(mLogMessages.at(row));
} }
return list; return list;
} }
void Logger::outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg) void Logger::outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{ {
QString shortFile = QFileInfo(context.file).fileName(); QString shortFile = QFileInfo(context.file).fileName();
QString text; QString text;
QString textType; QString textType;
switch (type) { switch (type) {
case QtDebugMsg: case QtDebugMsg:
textType = QStringLiteral("debug"); textType = QStringLiteral("debug");
break; break;
case QtWarningMsg: case QtWarningMsg:
textType = QStringLiteral("warning"); textType = QStringLiteral("warning");
break; break;
case QtCriticalMsg: case QtCriticalMsg:
textType = QStringLiteral("critical"); textType = QStringLiteral("critical");
break; break;
case QtFatalMsg: case QtFatalMsg:
textType = QStringLiteral("fatal"); textType = QStringLiteral("fatal");
break; break;
#if QT_VERSION >= 0x050500 #if QT_VERSION >= 0x050500
case QtInfoMsg: case QtInfoMsg:
textType = QStringLiteral("info"); textType = QStringLiteral("info");
break; break;
#endif #endif
} }
if (sConsumer) { if (sConsumer) {
LoggerMessage logmsg(shortFile,context.line,context.function,textType,context.category,msg, QLatin1String("")); LoggerMessage logmsg(shortFile,context.line,context.function,textType,context.category,msg, QLatin1String(""));
sConsumer->pushMessage(logmsg); // emiting message sConsumer->pushMessage(logmsg); // emiting message
} }
// Output message // Output message
//text += QString("%1 %2:%3 %4").arg(context.category).arg(shortFile).arg(context.line).arg(msg); //text += QString("%1 %2:%3 %4").arg(context.category).arg(shortFile).arg(context.line).arg(msg);
// New output syntax // New output syntax
text = QStringLiteral("[%1] %2 [ %3:%4 | %5 | %6 ]") text = QStringLiteral("[%1] %2 [ %3:%4 | %5 | %6 ]")
.arg(textType, msg, shortFile) .arg(textType, msg, shortFile)
.arg(context.line) .arg(context.line)
.arg(context.function, context.category); .arg(context.function, context.category);
QTextStream out(stderr); QTextStream out(stderr);
out << text << "\n"; //.toLocal8Bit() + "\n"; out << text << "\n"; //.toLocal8Bit() + "\n";
//out.flush(); // INVSDK-37 ORK-102 crash on windows when flush() -> possible threading problem //out.flush(); // INVSDK-37 ORK-102 crash on windows when flush() -> possible threading problem
if (type == QtFatalMsg) if (type == QtFatalMsg)
abort(); abort();
} }
/** Passing data to consumer */ /** Passing data to consumer */
void Logger::pushMessage(const LoggerMessage& logmsg) void Logger::pushMessage(const LoggerMessage& logmsg)
{ {
emit sConsumer->messageReceived(logmsg); emit sConsumer->messageReceived(logmsg);
QMutexLocker locker(&sConsumer->mMutex); QMutexLocker locker(&sConsumer->mMutex);
sConsumer->mLogMessages.append(logmsg); sConsumer->mLogMessages.append(logmsg);
emit sConsumer->messageListUpdated(); emit sConsumer->messageListUpdated();
} }
} // core } // core

186
src/serversdk/logger.h
View File

@ -1,93 +1,93 @@
#pragma once #pragma once
#include "loggermessage.h" #include "loggermessage.h"
// Qt // Qt
#include <QObject> #include <QObject>
#include <QLoggingCategory> #include <QLoggingCategory>
#include <QMutex> #include <QMutex>
Q_DECLARE_LOGGING_CATEGORY(sdkcore) Q_DECLARE_LOGGING_CATEGORY(sdkcore)
Q_DECLARE_LOGGING_CATEGORY(sdknetwork) Q_DECLARE_LOGGING_CATEGORY(sdknetwork)
Q_DECLARE_LOGGING_CATEGORY(sdkcompress) Q_DECLARE_LOGGING_CATEGORY(sdkcompress)
namespace serversdk { namespace serversdk {
/** /**
* # Loggger * # Loggger
* *
* Class for logging qDebug qWarning qInfo and qCritical messages * Class for logging qDebug qWarning qInfo and qCritical messages
* *
* *
* ## Basic usage * ## Basic usage
* *
* @code * @code
* int main() { * int main() {
* serversdk::initAppLogger(); // <-- then Logger::outputMessage will handle all messages * serversdk::initAppLogger(); // <-- then Logger::outputMessage will handle all messages
* // Log messge Filtering * // Log messge Filtering
* QStringList filters; * QStringList filters;
* filters << "qt.*=false"; * filters << "qt.*=false";
* filters << "sdk.core.*=true"; * filters << "sdk.core.*=true";
* QLoggingCategory::setFilterRules(filters.join(QStringLiteral("\n"))); * QLoggingCategory::setFilterRules(filters.join(QStringLiteral("\n")));
* } * }
* @endcode * @endcode
* *
* @see https://doc.qt.io/qt-5/qdebug.html * @see https://doc.qt.io/qt-5/qdebug.html
* @see https://doc.qt.io/qt-5/qloggingcategory.html * @see https://doc.qt.io/qt-5/qloggingcategory.html
* *
*/ */
class Logger : public QObject class Logger : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
// User defined consumer ( messages will be sent there using insertMessage ) // User defined consumer ( messages will be sent there using insertMessage )
static Logger* sConsumer; static Logger* sConsumer;
/// Default constructor /// Default constructor
explicit Logger(QObject *parent = nullptr); explicit Logger(QObject *parent = nullptr);
/** /**
* @brief User specific consumer of logger messages * @brief User specific consumer of logger messages
* @param consumer - sublass of serversdk::Loger * @param consumer - sublass of serversdk::Loger
* *
* @code * @code
* #include "core.h" * #include "core.h"
* int main() { * int main() {
* serversdk::initAppLogger(); * serversdk::initAppLogger();
* serversdk::Logger logger; * serversdk::Logger logger;
* serversdk::Logger::setConsumer(&logger); * serversdk::Logger::setConsumer(&logger);
* } * }
* @endcode * @endcode
* *
*/ */
static void setConsumer(Logger *consumer); static void setConsumer(Logger *consumer);
/** Only Message handler for Qt /** Only Message handler for Qt
* *
* @code * @code
* #include "core.h" * #include "core.h"
* int main() { * int main() {
* serversdk::initAppLogger(); * serversdk::initAppLogger();
* } * }
* @endcode * @endcode
*/ */
static void outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg); static void outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg);
/** Pusing messges from installed message handler */ /** Pusing messges from installed message handler */
virtual void pushMessage(const LoggerMessage& logmsg); virtual void pushMessage(const LoggerMessage& logmsg);
QList<serversdk::LoggerMessage> getNewMessages(int currentCount); QList<serversdk::LoggerMessage> getNewMessages(int currentCount);
signals: signals:
void messageReceived(const serversdk::LoggerMessage &message); void messageReceived(const serversdk::LoggerMessage &message);
void messageListUpdated(); void messageListUpdated();
private: private:
QList<LoggerMessage> mLogMessages; QList<LoggerMessage> mLogMessages;
QMutex mMutex; QMutex mMutex;
}; };
} // core } // core

226
src/serversdk/request.cpp
View File

@ -1,113 +1,113 @@
#include "request.h" #include "request.h"
#include "logger.h" #include "logger.h"
#include "requestmanager.h" // to get logger class #include "requestmanager.h" // to get logger class
#include <QDebug> #include <QDebug>
#include <utility> #include <utility>
namespace serversdk { namespace serversdk {
Request::~Request() Request::~Request()
{ {
} }
QNetworkRequest Request::networkRequest() const QNetworkRequest Request::networkRequest() const
{ {
QNetworkRequest request(QUrl(this->mUrl)); QNetworkRequest request(QUrl(this->mUrl));
if ( !userName().isEmpty() && !password().isEmpty() ) if ( !userName().isEmpty() && !password().isEmpty() )
request.setRawHeader("Authorization", this->basicAuthorization().toUtf8()); request.setRawHeader("Authorization", this->basicAuthorization().toUtf8());
if ( !token().isEmpty() ) { if ( !token().isEmpty() ) {
request.setRawHeader("Authorization", this->bearerAuthorization().toUtf8()); request.setRawHeader("Authorization", this->bearerAuthorization().toUtf8());
} }
// Enabled compression // Enabled compression
#ifdef CORESDK_ZLIB #ifdef CORESDK_ZLIB
request.setRawHeader("Accept-Encoding", "gzip, deflate"); request.setRawHeader("Accept-Encoding", "gzip, deflate");
#endif #endif
// Enabling HTTP/2 ( not supported on Ubuntu 16.04 ) // Enabling HTTP/2 ( not supported on Ubuntu 16.04 )
// request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, true); // request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, true);
return request; return request;
} }
void Request::appendData(const QByteArray &array) void Request::appendData(const QByteArray &array)
{ {
mResponseData += array; mResponseData += array;
} }
QString Request::url() const QString Request::url() const
{ {
return mUrl; return mUrl;
} }
void Request::setUrl(const QString &url) void Request::setUrl(const QString &url)
{ {
mUrl = url; mUrl = url;
} }
QByteArray Request::responseData() const QByteArray Request::responseData() const
{ {
return mResponseData; return mResponseData;
} }
QByteArray Request::requestData() const QByteArray Request::requestData() const
{ {
return mRequestData; return mRequestData;
} }
void Request::setRequestData(const QByteArray &requestData) void Request::setRequestData(const QByteArray &requestData)
{ {
mRequestData = requestData; mRequestData = requestData;
} }
QString Request::token() const QString Request::token() const
{ {
return mToken; return mToken;
} }
void Request::setToken(const QString &token) void Request::setToken(const QString &token)
{ {
mToken = token; mToken = token;
} }
QString Request::userName() const QString Request::userName() const
{ {
return mUserName; return mUserName;
} }
void Request::setUserName(const QString &username) void Request::setUserName(const QString &username)
{ {
mUserName = username; mUserName = username;
} }
QString Request::password() const QString Request::password() const
{ {
return mPassword; return mPassword;
} }
void Request::setPassword(const QString &password) void Request::setPassword(const QString &password)
{ {
mPassword = password; mPassword = password;
} }
QString Request::basicAuthorization() const QString Request::basicAuthorization() const
{ {
// HTTP Basic authentication header value: base64(username:password) // HTTP Basic authentication header value: base64(username:password)
QString concatenated = userName() + ":" + password(); QString concatenated = userName() + ":" + password();
QByteArray data = concatenated.toLocal8Bit().toBase64(); QByteArray data = concatenated.toLocal8Bit().toBase64();
QString headerData = "Basic " + data; QString headerData = "Basic " + data;
return headerData; return headerData;
//request.setRawHeader("Authorization", headerData.toLocal8Bit()); //request.setRawHeader("Authorization", headerData.toLocal8Bit());
} }
QString Request::bearerAuthorization() const QString Request::bearerAuthorization() const
{ {
qCDebug(sdknetwork) << "not implemented yet"; qCDebug(sdknetwork) << "not implemented yet";
return QString(); return QString();
} }
} // core } // core

128
src/serversdk/request.h
View File

@ -1,64 +1,64 @@
#pragma once #pragma once
#include <QString> #include <QString>
#include <QNetworkRequest> #include <QNetworkRequest>
namespace serversdk { namespace serversdk {
class Request : public QObject { class Request : public QObject {
Q_OBJECT Q_OBJECT
friend class RequestManager; friend class RequestManager;
friend class RequestTest; friend class RequestTest;
public: public:
Request() = default; Request() = default;
~Request() override; ~Request() override;
Request(QString type, QString url, QByteArray responseData = QByteArray()); Request(QString type, QString url, QByteArray responseData = QByteArray());
virtual QNetworkRequest networkRequest() const; virtual QNetworkRequest networkRequest() const;
// Data handling data // Data handling data
QByteArray requestData() const; QByteArray requestData() const;
void setRequestData(const QByteArray &requestData); void setRequestData(const QByteArray &requestData);
QByteArray responseData() const; QByteArray responseData() const;
// Attributes // Attributes
QString url() const; QString url() const;
void setUrl(const QString &url); void setUrl(const QString &url);
// Authorization // Authorization
QString userName() const; QString userName() const;
void setUserName(const QString &userName); void setUserName(const QString &userName);
QString password() const; QString password() const;
void setPassword(const QString &password); void setPassword(const QString &password);
QString token() const; QString token() const;
void setToken(const QString &token); void setToken(const QString &token);
// Authorization headers // Authorization headers
QString basicAuthorization() const; QString basicAuthorization() const;
QString bearerAuthorization() const; QString bearerAuthorization() const;
private: private:
// Data handling // Data handling
void appendData(const QByteArray &array); void appendData(const QByteArray &array);
signals: signals:
void finished(); void finished();
private: private:
QString mType; // POST, GET QString mType; // POST, GET
QString mUrl; QString mUrl;
// Authorization // Authorization
QString mUserName; QString mUserName;
QString mPassword; QString mPassword;
QString mToken; QString mToken;
// Data // Data
QByteArray mRequestData; QByteArray mRequestData;
QByteArray mResponseData; QByteArray mResponseData;
}; };
} // core } // core

190
src/serversdk/requestmanager.cpp
View File

@ -1,95 +1,95 @@
#include "requestmanager.h" #include "requestmanager.h"
#include "request.h" #include "request.h"
#ifdef CORESDK_ZLIB #ifdef CORESDK_ZLIB
#include "compression.h" #include "compression.h"
#endif #endif
#include <memory> #include <memory>
namespace serversdk { namespace serversdk {
/** /**
* @brief Wrapper around QNetworkAccessManger to handle soap protocol * @brief Wrapper around QNetworkAccessManger to handle soap protocol
* @param parent * @param parent
*/ */
RequestManager::RequestManager(QObject *parent) RequestManager::RequestManager(QObject *parent)
: QObject(parent) : QObject(parent)
{ {
connect(&mNetworkAccessManager, &QNetworkAccessManager::authenticationRequired, [](){ connect(&mNetworkAccessManager, &QNetworkAccessManager::authenticationRequired, [](){
qCWarning(sdknetwork) << "server need authentication"; qCWarning(sdknetwork) << "server need authentication";
}); });
} }
/** /**
* @brief Soap::downloadRequest * @brief Soap::downloadRequest
* @param soapRequest * @param soapRequest
*/ */
void RequestManager::processRequest(const std::shared_ptr<Request>& request) void RequestManager::processRequest(const std::shared_ptr<Request>& request)
{ {
QNetworkReply *reply = mNetworkAccessManager.post(request->networkRequest(), request->requestData()); QNetworkReply *reply = mNetworkAccessManager.post(request->networkRequest(), request->requestData());
mRequestMap.insert(reply, request); mRequestMap.insert(reply, request);
connect(reply, &QNetworkReply::sslErrors, this, &RequestManager::sslErrors); connect(reply, &QNetworkReply::sslErrors, this, &RequestManager::sslErrors);
connect(reply, &QNetworkReply::downloadProgress, this, &RequestManager::downloadProgress); connect(reply, &QNetworkReply::downloadProgress, this, &RequestManager::downloadProgress);
connect(reply, &QNetworkReply::finished, this, [=]() { connect(reply, &QNetworkReply::finished, this, [=]() {
std::shared_ptr<Request> request = mRequestMap.value(reply); std::shared_ptr<Request> request = mRequestMap.value(reply);
mRequestMap.remove(reply); mRequestMap.remove(reply);
reply->deleteLater(); reply->deleteLater();
emit request->finished(); emit request->finished();
emit downloadFinished(request); emit downloadFinished(request);
}); });
} }
/** /**
* @brief Handle sslErrors -> only debug output * @brief Handle sslErrors -> only debug output
* @param sslErrors ( from QNetworkReply::sslErrors ) * @param sslErrors ( from QNetworkReply::sslErrors )
*/ */
void RequestManager::sslErrors(const QList<QSslError> &sslErrors) void RequestManager::sslErrors(const QList<QSslError> &sslErrors)
{ {
for (const QSslError &error : sslErrors) { for (const QSslError &error : sslErrors) {
qCDebug(sdknetwork) << QStringLiteral("SSL error:") << error.errorString(); qCDebug(sdknetwork) << QStringLiteral("SSL error:") << error.errorString();
} }
} }
/** /**
* @brief called upon download progess -> adding data into QByteArray * @brief called upon download progess -> adding data into QByteArray
* @param bytesReceived ( can be different from actual data -> compression ) * @param bytesReceived ( can be different from actual data -> compression )
* @param bytesTotal ( can be different from actual data -> compression ) * @param bytesTotal ( can be different from actual data -> compression )
*/ */
void RequestManager::downloadProgress(qint64 bytesReceived, qint64 bytesTotal) void RequestManager::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
{ {
// Get Reply ( now only one ) // Get Reply ( now only one )
//Q_ASSERT(mCurrentReply); //Q_ASSERT(mCurrentReply);
auto *reply = qobject_cast<QNetworkReply*>(sender()); auto *reply = qobject_cast<QNetworkReply*>(sender());
Q_ASSERT(mRequestMap.contains(reply)); Q_ASSERT(mRequestMap.contains(reply));
std::shared_ptr<Request> request = mRequestMap.value(reply); std::shared_ptr<Request> request = mRequestMap.value(reply);
//Q_ASSERT(reply == mCurrentReply); //Q_ASSERT(reply == mCurrentReply);
QString encoding; QString encoding;
// Check encoding // Check encoding
for (const auto & pair : reply->rawHeaderPairs()) { for (const auto & pair : reply->rawHeaderPairs()) {
if (pair.first == QStringLiteral("Content-Encoding")) { if (pair.first == QStringLiteral("Content-Encoding")) {
encoding = pair.second; encoding = pair.second;
} }
} }
QByteArray data = reply->readAll(); QByteArray data = reply->readAll();
// Decompress gzip data // Decompress gzip data
#ifdef CORESDK_ZLIB #ifdef CORESDK_ZLIB
if (encoding.toLower() == "gzip" && !data.isEmpty() ) { if (encoding.toLower() == "gzip" && !data.isEmpty() ) {
data = Compression::decompress(data); data = Compression::decompress(data);
} }
#endif #endif
// Append data to request // Append data to request
request->appendData(data); request->appendData(data);
emit progresss(bytesReceived, bytesTotal); emit progresss(bytesReceived, bytesTotal);
} }
} // core } // core

78
src/serversdk/requestmanager.h
View File

@ -1,39 +1,39 @@
#pragma once #pragma once
#include "logger.h" #include "logger.h"
#include "request.h" #include "request.h"
#include <QtNetwork> #include <QtNetwork>
#include <memory> #include <memory>
namespace serversdk { namespace serversdk {
/** /**
* @brief Will download only ONE ITEM at a time * @brief Will download only ONE ITEM at a time
*/ */
class RequestManager : public QObject class RequestManager : public QObject
{ {
Q_OBJECT; Q_OBJECT;
friend class SoapTest; friend class SoapTest;
public: public:
explicit RequestManager(QObject *parent = nullptr); explicit RequestManager(QObject *parent = nullptr);
void processRequest(const std::shared_ptr<Request>& request); void processRequest(const std::shared_ptr<Request>& request);
private: private:
Q_SLOT void sslErrors(const QList<QSslError> &sslErrors); Q_SLOT void sslErrors(const QList<QSslError> &sslErrors);
Q_SLOT void downloadProgress(qint64 bytesReceived, qint64 bytesTotal); Q_SLOT void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
signals: signals:
void downloadFinished(std::shared_ptr<Request> request); void downloadFinished(std::shared_ptr<Request> request);
void progresss(qint64 bytesReceived, qint64 bytesTotal); void progresss(qint64 bytesReceived, qint64 bytesTotal);
private: private:
QNetworkAccessManager mNetworkAccessManager; QNetworkAccessManager mNetworkAccessManager;
QMap<QNetworkReply*, std::shared_ptr<Request>> mRequestMap; QMap<QNetworkReply*, std::shared_ptr<Request>> mRequestMap;
}; };
} // core } // core

34
src/testapp/main.cpp
View File

@ -1,17 +1,17 @@
#include "serversdk/core.h" #include "serversdk/core.h"
#include <QCoreApplication> #include <QCoreApplication>
#include <QCommandLineParser> #include <QCommandLineParser>
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
serversdk::initAppLogger(); serversdk::initAppLogger();
qCDebug(sdkcore) << "test message"; qCDebug(sdkcore) << "test message";
QCoreApplication app(argc, argv); QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName("example-app"); QCoreApplication::setApplicationName("example-app");
QCoreApplication::setApplicationVersion("0.1.0"); QCoreApplication::setApplicationVersion("0.1.0");
} }

14
src/testapp/testapp.pro
View File

@ -1,7 +1,7 @@
TEMPLATE = app TEMPLATE = app
QT += core sql network QT += core sql network
SOURCES += main.cpp SOURCES += main.cpp
include(../../serversdkint.pri) include(../../serversdkint.pri)

9
test/auto/UtilsTest/UtilsTest.pro
View File

@ -1,9 +0,0 @@
QT += testlib
QT -= gui
CONFIG += qt console warn_on depend_includepath testcase
CONFIG -= app_bundle
TEMPLATE = app
SOURCES += tst_utilstest.cpp

41
test/auto/UtilsTest/tst_utilstest.cpp
View File

@ -1,41 +0,0 @@
/*
* Copyright (C) Filip Bucek - All Rights Reserved
* Unauthorized copying of this file, via any medium is strictly prohibited
* Proprietary and confidential
* Written by Filip Bucek <fbucek@invloop.cz>, 2019
*/
#include <QtTest>
// add necessary includes here
class UtilsTest : public QObject
{
Q_OBJECT
public:
UtilsTest();
~UtilsTest();
private slots:
void test_case1();
};
UtilsTest::UtilsTest()
{
}
UtilsTest::~UtilsTest()
{
}
void UtilsTest::test_case1()
{
}
QTEST_APPLESS_MAIN(UtilsTest)
#include "tst_utilstest.moc"