Not using zlib

* renamed files in script based on their names

scripts/codecoverage.sh

@@ -15,8 +15,8 @@ PRO_FILE=$(ls *.pro)
 
 # Ensuring server-sdk wont be filtered out for server-sdk
 NAME=$( basename $PWD )
-if [ "$NAME" != "server-sdk" ]; then 
+if [ "$NAME" != "serversdk" ]; then 
-  COVERAGE_FILTER+=" *server-sdk*"
+  COVERAGE_FILTER+=" *serversdk*"
 fi
 
 # Ensuring 'src' dir exists

scripts/cppcheck.sh

@@ -7,8 +7,13 @@ SOURCE_DIR=$PWD
 
 EXCLUDE_DIR=build
 CHECK_DIR=$SOURCE_DIR/src
-SUPPRESS="--suppress=missingInclude --suppress=unusedFunction"
+SUPPRESS="--suppress=missingInclude"
 
+# Ensuring server-sdk will supress 'unuseFunction' warning
+NAME=$( basename $PWD )
+if [ "$NAME" == "server-sdk" ]; then 
+  SUPPRESS=$SUPPRESS" --suppress=unusedFunction"
+fi
 
 info cppcheck version: `cppcheck --version`
 if [ ! -d src ]; then

serversdkint.pri

@@ -29,6 +29,9 @@ QT += network sql
 CONFIG += c++14
 INCLUDEPATH += $$PWD/src/
 DEPENDPATH += $$PWD/src/serversdk
+# enable zlib compression on linux
+unix: DEFINES += USE_ZLIB
+
 
 win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$SDKDIR/release/libserversdk.a
 else:win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$SDKDIR/debug/libserversdk.a

src/serversdk/core.cpp

@@ -10,7 +10,7 @@ void installLogger(QtMsgType type, const QMessageLogContext &context, const QStr
 void initAppLogger() {
     auto res = qInstallMessageHandler(serversdk::Logger::outputMessage);
     if (res)
-        qCInfo(sdkcore) << "user message handler qInstallMessageHandler installed sucessfully";
+        qCDebug(sdkcore) << "user message handler qInstallMessageHandler installed sucessfully";
     else
         qCWarning(sdkcore) << "failed to install message handler qInstallMessageHandler";
 }

src/serversdk/databasemanager.cpp

@@ -52,6 +52,8 @@ bool DatabaseManager::openPostgres(const QString &host, const QString &dbName, c
     mDatabase.setHostName(host);
     mDatabase.setUserName(user); // home-office stuff -->> db.setPort(80);
     mDatabase.setPassword(password);
+    // @see https://www.qtcentre.org/threads/39913-QSqlDatabase-connection-timeout
+    mDatabase.setConnectOptions("connect_timeout=10");
 
     int res = mDatabase.open();
 
@@ -93,11 +95,9 @@ QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText
     bool isSelect = false;
     if ( sqlText.isEmpty()) {
         sqlStatement = getLastQuery(query);
-        isSelect = query.isSelect();
+    }
-    } else {
+    if (sqlText.startsWith("SELECT", Qt::CaseInsensitive)) {
-        if (sqlText.startsWith("SELECT", Qt::CaseInsensitive)) {
+        isSelect = true;
-            isSelect = true;
-        }
     }
 
     if (mDryMode) {
@@ -110,20 +110,26 @@ QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText
         if ( ! sqlText.isEmpty()) { // prepared statement.
             res = query.exec(sqlText);
             return processResult(res, query);
-        } else {
-            res = query.exec();
-            return processResult(res, query);
         }
+        res = query.exec();
+        return processResult(res, query);
     }
     return query;
 }
 
+QSqlQuery DatabaseManager::createQuery()
+{
+    QSqlQuery query(mDatabase);
+    return query;
+}
+
 QSqlQuery DatabaseManager::processResult(int res, const QSqlQuery &query) const
 {
     if ( !res ) {
         QString msg = QString("Source: Database Manager \nError --------\n%1\nSQL-------\n%2\n--------")
                 .arg(query.lastError().text(), query.lastQuery());
         qCDebug(sdkdb).noquote() << msg;
+        emit sqlError(query);
         log(msg);
     }
     return query;
@@ -160,7 +166,6 @@ void DatabaseManager::setDryMode(bool dryMode)
 QSqlDatabase DatabaseManager::database() const
 {
     Q_ASSERT(mDatabase.isValid());
-    Q_ASSERT(mDatabase.isOpen());
     return mDatabase;
 }
 

src/serversdk/databasemanager.h

@@ -19,13 +19,12 @@ class DatabaseManager : public QObject
 public:
     DatabaseManager();
     DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool mDryMode = false);
-    ~DatabaseManager();
+    ~DatabaseManager() override;
 
     // Attributes
     bool dryMode() const;
     void setDryMode(bool dryMode);
 
-
     bool openSQLite(const QString &path, const QString &connectionName = QStringLiteral("qt_sql_default_connection"));
     bool openPostgres(const QString& host, const QString& dbName, const QString& user, const QString& password, const QString &connectionName = QStringLiteral("qt_sql_default_connection"));
     bool isValid() const;
@@ -35,6 +34,7 @@ public:
     // SQL handling
     QSqlQuery execPlainSql(const QString &sqlText);
     QSqlQuery executeQuery(QSqlQuery &query, const QString &sqlText = QString());
+    QSqlQuery createQuery();
     QSqlDatabase database() const;
 
 
@@ -45,7 +45,7 @@ private:
     void log(const QString &msg) const;
 
 signals:
-    void error();
+    void sqlError(const QSqlQuery &query) const;
 
 private:
     QString mConnectionName;

src/serversdk/databasetable.cpp

@@ -13,15 +13,38 @@ DatabaseTable::DatabaseTable(QObject *parent) : QObject(parent)
 {
 }
 
-QByteArray DatabaseTable::jsonData() const
+QString DatabaseTable::primaryKey() const
 {
-    QJsonDocument doc = QJsonDocument::fromVariant(this->toVariantMap());
+    const QMetaObject *metaObj = this->metaObject();
+    for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
+        QMetaProperty prop = metaObj->property(i);
+        if (!prop.isUser())
+            continue;
+        return prop.name();
+    }
+    return QString();
+}
+
+QByteArray DatabaseTable::jsonData(const QSet<QString> &filters) const
+{
+    auto variantMap = this->toVariantMap(filters);
+    QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
     return doc.toJson(QJsonDocument::Compact);
 }
 
+bool DatabaseTable::fromJson(const QByteArray &data)
+{
+    // in: JSON ( e.g. {"id": 300} )
+    QJsonDocument doc = QJsonDocument::fromJson(data);
+    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
+
+    // Populate this object data
+    bool res = fromVariantMap(variant);
+    return res;
+}
 
 /** Creates universal variant structure to hold key / value pairs */
-QVariantMap DatabaseTable::toVariantMap() const
+QVariantMap DatabaseTable::toVariantMap(const QSet<QString> &filters) const
 {
     QVariantMap variantMap;
 
@@ -34,6 +57,11 @@ QVariantMap DatabaseTable::toVariantMap() const
 
         // Get key -> value pairs
         QString name = prop.name();
+
+        // Filter property
+        if (filters.contains(name))
+            continue;
+
         QVariant::Type type = prop.type();
         QVariant value(type);
         value.setValue(prop.read(this));
@@ -43,6 +71,7 @@ QVariantMap DatabaseTable::toVariantMap() const
     return variantMap;
 }
 
+
 bool DatabaseTable::fromVariantMap(const QVariantMap &variantMap)
 {
 
@@ -64,6 +93,7 @@ bool DatabaseTable::fromVariantMap(const QVariantMap &variantMap)
     return true;
 }
 
+
 QList<std::shared_ptr<DatabaseTable> > DatabaseTable::fromListVariantMap(const QList<QVariantMap> &listMap)
 {
     QList<std::shared_ptr<DatabaseTable>> list;
@@ -75,16 +105,6 @@ QList<std::shared_ptr<DatabaseTable> > DatabaseTable::fromListVariantMap(const Q
     return list;
 }
 
-bool DatabaseTable::fromJson(const QByteArray &data)
-{
-    // in: JSON ( e.g. {"id": 300} )
-    QJsonDocument doc = QJsonDocument::fromJson(data);
-    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
-
-    // Populate this object data
-    bool res = fromVariantMap(variant);
-    return res;
-}
 
 QString DatabaseTable::textSQLIteType(QVariant::Type type) const
 {
@@ -134,5 +154,4 @@ QString DatabaseTable::textPostgresType(QVariant::Type type) const
     }
 }
 
-
 } // namespace serversdk

src/serversdk/databasetable.h

@@ -2,6 +2,7 @@
 
 #include <QObject>
 #include <QVariantMap>
+#include <QSet>
 
 #include <memory>
 
@@ -10,13 +11,13 @@
     Q_PROPERTY(TYPE NAME READ NAME WRITE SETNAME NOTIFY NAME ## Changed USER true) \
     public: \
        TYPE NAME() const { return a_ ## NAME ; } \
-       Q_SLOT void SETNAME(TYPE value) { \
+       Q_SLOT void SETNAME(const TYPE &value) { \
           if (a_ ## NAME == value)  return; \
           a_ ## NAME = value; \
           emit NAME ## Changed(value); \
         } \
        Q_SIGNAL void NAME ## Changed(TYPE value);\
-    protected: \
+    private: \
        TYPE a_ ## NAME = INITVAL;
 
 namespace serversdk {
@@ -59,12 +60,14 @@ namespace serversdk {
 
       // SELECT FROM TABLE
       QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
-      auto listVariantMap = utils.listMapFromQuery(selectSQL);
+      auto list = utils.tableFromQuery<Names>(selectSQL);
-      auto list = Names::fromListVariantMap(listVariantMap);
    }
  *
  * @endcode
  *
+ * ## Warning
+ *
+ * Derivation of derived class from DatabaseTable does not work ( missing properties )
  *
  * @code
  *  in: TABLE_PROPERTY
@@ -78,29 +81,28 @@ namespace serversdk {
 class DatabaseTable : public QObject
 {
     Q_OBJECT
-    TABLE_PROPERTY(int, id, setId, 0);
-    TABLE_PROPERTY(QString, name, setName, QString());
 public:
     explicit DatabaseTable(QObject *parent = nullptr);
 
+    QString primaryKey() const;
 
     /**
      * @brief Creates JSON from QMetaObject data ( Q_PROPERTY ) -> TABLE_PROPERTY
      * @return text json e.g. { "id": 00344 }
      */
-    QByteArray jsonData() const;
+    virtual QByteArray jsonData(const QSet<QString> &filters = {}) const;
 
     /**
      * @brief Populates object with JSON {"id": 300} )
      * @return true if success TODO: not implemented corrrectly
      */
-    bool fromJson(const QByteArray &data);
+    virtual bool fromJson(const QByteArray &data);
 
     /**
      * @brief Creates VariantMap from QMetaObject data ( Q_PROPERTY )
      * @return QVariantMap containing property with key/value pairs
      */
-    QVariantMap toVariantMap() const;
+    virtual QVariantMap toVariantMap(const QSet<QString> &filters = {}) const;
 
 
     /**
@@ -129,10 +131,36 @@ public:
      * @brief Convert QVariant type to SQL type
      * @param QVariant type ( QString, int, QDateTime )
      * @return text form of database type ( INTEGER, TEXT )
+     *
+     * # Sublassing
+     *
+     * When it is neccessary to use different type it is possible to subclass and override this method.
+     *
+     * @code
+        class BackendTable : public serversdk::DatabaseTable
+        {
+          QString textPostgresType(QVariant::Type type) const override;
+        }
+
+        BackendTable::textPostgresType(QVariant::Type type) const override
+        {
+            // For case when saving date time as ms since epoch
+            if (type == QVariant::DateTime) {
+                return QStringLiteral("INTEGER");
+            }
+            return DatabaseTable::textPostgresType(type);
+        }
+
+     * @endcode
+     *
+     *
+     *
+     *
      */
     virtual QString textPostgresType(QVariant::Type type) const;
 
 };
 
+
 } // namespace serversdk
 

src/serversdk/databaseutils.cpp

@@ -4,7 +4,7 @@
 #include "logger.h"
 
 #include <QMetaProperty>
-#include <QSqlRecord>
+#include <utility>
 
 
 namespace serversdk {
@@ -30,14 +30,14 @@ namespace serversdk {
  *
  *
  */
-DatabaseUtils::DatabaseUtils(DatabaseManager *manager, const QString type)
+DatabaseUtils::DatabaseUtils(DatabaseManager *manager, QString type)
-    : mDatabaseManager(manager), mSqlType(type)
+    : mDatabaseManager(manager), mSqlType(std::move(type))
 {
     Q_ASSERT(mDatabaseManager);
 }
 
 
-QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString table_name) const
+QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString &table_name) const
 {
     QString userData;
 
@@ -57,7 +57,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
         if (!prop.isUser())
             continue;
 
-        QString name = prop.name();
+        QString name = fromCamelCase(prop.name());
         QVariant::Type type = prop.type();
         QString textType;
 
@@ -80,7 +80,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
         // in: PRIMARY KEY
         // out: "CREATE TABLE colnod_subject ( id TEXT PRIMARY KEY"
         if (first) { // first row
-            sql += " PRIMARY KEY";
+            sql += " PRIMARY KEY NOT NULL";
             first = false;
         }
 
@@ -102,24 +102,35 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
     return sql;
 }
 
-QSqlQuery DatabaseUtils::createTable(const DatabaseTable *table, const QString tableName) const
+QSqlQuery DatabaseUtils::createTable(const DatabaseTable *table, const QString &table_name) const
 {
     // CREATE TABLE ...
-    QString sql = createTableText(table, tableName);
+    QString sql = createTableText(table, table_name);
+    qCDebug(sdkdb) << "SQL:" << sql;
     return mDatabaseManager->execPlainSql(sql);
 }
 
-
+/**
-QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QString table_name) const
+ * @brief DatabaseUtils::insertIntoTable
+ * @param table
+ * @param table_name
+ * @return
+ *
+ * @todo Loop VariantMap change to Loop over propertiess
+ */
+QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QString &table_name) const
 {
     QString columns;
     QString values;
 
     QVariantMap valueMap = table->toVariantMap();
 
-
+    // in: id / 23233
+    // out: columns: id
+    // out: values: :id
     auto keys = valueMap.keys();
-    for (auto key : keys) {
+    for (const auto& _key : keys) {
+        QString key = fromCamelCase(_key);
         if (!columns.isEmpty()) {
             columns += ", ";
             values += ", ";
@@ -132,8 +143,9 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri
     QString queryText = QString("INSERT INTO %1 ( %2 ) VALUES ( %3 );").arg(table_name).arg(columns).arg(values);
     query.prepare(queryText);
 
-    for (auto key : keys ) {
+    for (const auto& _key : keys ) {
-        auto value = valueMap.value(key);
+        QString key = fromCamelCase(_key);
+        auto value = valueMap.value(_key);
         query.bindValue(":"+key, value);
     }
 
@@ -142,21 +154,45 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri
 }
 
 
-QList<QMap<QString, QVariant>> DatabaseUtils::listMapFromQuery(QSqlQuery query) const
+QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString &table_name, const QSet<QString> &filters) const
 {
-    QList<QMap<QString, QVariant>> list;
+    QString columnsAndValues;
-    while (query.next()) {
+    QString primaryKeyCondition;
-        auto rec = query.record();
+
-        int total = rec.count();
+    QVariantMap valueMap = table->toVariantMap(filters);
-        QMap<QString, QVariant> map;
+    auto keys = valueMap.keys();
-        for (int column = 0; column < total; ++column) {
+
-            map.insert(rec.fieldName(column), query.value(column));
+    Q_ASSERT(!keys.isEmpty());
+    // Primary key is first user property ( first VariantMap item )
+    // in ( primary key ): id
+    // out: id = :id
+    const QString primaryKey = table->primaryKey();
+    primaryKeyCondition = primaryKey + " = :" + primaryKey;
+
+    for (const auto& _key : keys) {
+        QString key = fromCamelCase(_key);
+        if (!columnsAndValues.isEmpty()) {
+            columnsAndValues += ", ";
         }
-        list << map;
+        columnsAndValues += key + " = :" + key;
     }
-    return list;
+
+    QSqlQuery query(mDatabaseManager->database());
+    QString queryText = QString("UPDATE %1 SET %2 WHERE %3;").arg(table_name).arg(columnsAndValues).arg(primaryKeyCondition);
+    query.prepare(queryText);
+
+    for (const auto& _key : keys ) {
+        QString key = fromCamelCase(_key);
+        auto value = valueMap.value(_key);
+        query.bindValue(":"+key, value);
+    }
+
+    QSqlQuery res = mDatabaseManager->executeQuery(query);
+    return res;
 }
 
+
+
 QString DatabaseUtils::sqlType() const
 {
     return mSqlType;
@@ -167,6 +203,27 @@ void DatabaseUtils::setSqlType(const QString &sqlType)
     mSqlType = sqlType;
 }
 
+QString DatabaseUtils::fromCamelCase(const QString &s)
+{
+    static QRegularExpression regExp1 {"(.)([A-Z][a-z]+)"};
+    static QRegularExpression regExp2 {"([a-z0-9])([A-Z])"};
+
+    QString result = s;
+    result.replace(regExp1, "\\1_\\2");
+    result.replace(regExp2, "\\1_\\2");
+
+    return result.toLower();
+}
+
+QString serversdk::DatabaseUtils::toCamelCase(const QString &s)
+{
+    QStringList parts = s.split('_', QString::SkipEmptyParts);
+    for (int i=1; i<parts.size(); ++i)
+        parts[i].replace(0, 1, parts[i][0].toUpper());
+
+    return parts.join("");
+}
+
 
 
 } // namespace serversdk

src/serversdk/databaseutils.h

@@ -3,7 +3,9 @@
 #include "databasetable.h"
 
 #include <QObject>
+#include <QRegularExpression>
 #include <QSqlQuery>
+#include <QSqlRecord>
 
 class DatabaseUtilsTest;
 
@@ -17,23 +19,49 @@ class DatabaseUtils : public QObject
     Q_OBJECT
     friend class ::DatabaseUtilsTest;
 public:
-    explicit DatabaseUtils(DatabaseManager *manager = nullptr, const QString type = "SQLITE");
+    explicit DatabaseUtils(DatabaseManager *manager = nullptr, QString type = "SQLITE");
 
-    QSqlQuery createTable(const DatabaseTable *table, const QString table_name) const;
+    QSqlQuery createTable(const DatabaseTable *table, const QString &table_name) const;
+
+    QSqlQuery insertIntoTable(const DatabaseTable *table, const QString &table_name) const;
+
+    QSqlQuery updateTable(const DatabaseTable *table, const QString &table_name, const QSet<QString> &filters = {}) const;
+
+    template <class T>
+    QList<std::shared_ptr<T>> tableFromQuery(QSqlQuery query) const {
+        QList<std::shared_ptr<T>> list;
+        while (query.next()) {
+            auto rec = query.record();
+            int total = rec.count();
+            QMap<QString, QVariant> map;
+            for (int column = 0; column < total; ++column) {
+                QString columnName = rec.fieldName(column);
+                QString propertyName = toCamelCase(columnName);
+                map.insert(propertyName, query.value(column));
+            }
+
+            auto data = std::make_shared<T>();
+            data->fromVariantMap(map);
+            list << data;
+        }
+        return list;
+    }
 
-    QSqlQuery insertIntoTable(const DatabaseTable *table, const QString table_name) const;
-    QList<QMap<QString, QVariant>> listMapFromQuery(QSqlQuery query) const;
 
     QString sqlType() const;
     void setSqlType(const QString &sqlType);
 
+    static QString fromCamelCase(const QString &s);
+    static QString toCamelCase(const QString& s);
+
 private:
-    QString createTableText(const DatabaseTable *table, const QString table_name) const;
+    QString createTableText(const DatabaseTable *table, const QString &table_name) const;
 
 private:
     DatabaseManager *mDatabaseManager = nullptr;
     QString mSqlType;
 };
 
+
 } // namespace serversdk
 

src/serversdk/logger.cpp

@@ -3,16 +3,22 @@
 
 #include <QLoggingCategory>
 #include <QFileInfo>
+#include <QDateTime>
 
 Q_LOGGING_CATEGORY(sdkcore, "sdk.core");
 Q_LOGGING_CATEGORY(sdknetwork, "sdk.network");
 Q_LOGGING_CATEGORY(sdkutils, "sdk.utils");
+Q_LOGGING_CATEGORY(sdkutilsdb, "sdk.utils.db");
 Q_LOGGING_CATEGORY(sdkdb, "sdk.db");
 
 namespace serversdk {
 
 Logger* Logger::sConsumer = nullptr;
-//bool Logger::sShowFunction = false;
+#ifdef Q_OS_UNIX
+    bool Logger::mColorOutput = true;
+#else
+    bool Logger::mColorOutput = false;
+#endif
 
 
 void Logger::setConsumer(Logger *consumer)
@@ -23,6 +29,7 @@ void Logger::setConsumer(Logger *consumer)
 Logger::Logger(QObject *parent) : QObject(parent)
 {
     qRegisterMetaType<LoggerMessage>();
+
 }
 
 QList<LoggerMessage> Logger::getNewMessages(int currentCount)
@@ -43,6 +50,16 @@ QList<LoggerMessage> Logger::getNewMessages(int currentCount)
     return list;
 }
 
+QString Logger::toColor(const QString &color, const QString &text)
+{
+    return color + text + "\033[0m";
+}
+
+void Logger::setColorOutput(bool colorOutput)
+{
+    mColorOutput = colorOutput;
+}
+
 
 void Logger::outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
@@ -50,23 +67,29 @@ void Logger::outputMessage(QtMsgType type, const QMessageLogContext &context, co
 
     QString text;
     QString textType;
+    QString colorTextType;
 
     switch (type) {
     case QtDebugMsg:
-        textType = QStringLiteral("debug");
+        textType = QStringLiteral("DEBUG");
+        colorTextType = Logger::toColor("\033[0;31m", textType);
         break;
     case QtWarningMsg:
-        textType = QStringLiteral("warning");
+        textType = QStringLiteral("WARN");
+        colorTextType = Logger::toColor("\033[0;33m", textType);
         break;
     case QtCriticalMsg:
-        textType = QStringLiteral("critical");
+        textType = QStringLiteral("CRITICAL");
+        colorTextType = Logger::toColor("\033[0;31m", textType);
         break;
     case QtFatalMsg:
-        textType = QStringLiteral("fatal");
+        textType = QStringLiteral("FATAL");
+        colorTextType = Logger::toColor("\033[0;31m", textType);
         break;
 #if QT_VERSION >= 0x050500
     case QtInfoMsg:
-        textType = QStringLiteral("info");
+        textType = QStringLiteral("INFO");
+        colorTextType = Logger::toColor("\033[0;34m", textType);
         break;
 #endif
     }
@@ -78,14 +101,19 @@ void Logger::outputMessage(QtMsgType type, const QMessageLogContext &context, co
     // Output message
     //text += QString("%1 %2:%3 %4").arg(context.category).arg(shortFile).arg(context.line).arg(msg);
     // New output syntax
-    text = QStringLiteral("[%1] %2 [ %3:%4 | %5 | %6 ]")
+
-            .arg(textType, msg, shortFile)
+    QDateTime now = QDateTime::currentDateTime();
-            .arg(context.line)
+
-            .arg(context.function, context.category);
+    const QString textTypeUni = mColorOutput ? colorTextType : textType;
+
+    text = QStringLiteral("[%1 %2 %3] %4") // [ %3:%4 | %5 | %6 ]")
+            .arg(now.toString("dd-MM-yyyy hh:mm:ss.z"))
+            .arg(textTypeUni)
+            .arg(context.category)
+            .arg(msg);
 
     QTextStream out(stderr);
     out << text << "\n"; //.toLocal8Bit() + "\n";
-    //out.flush(); // INVSDK-37 ORK-102 crash on windows when flush() -> possible threading problem
 
     if (type == QtFatalMsg)
         abort();

src/serversdk/logger.h

@@ -11,6 +11,7 @@
 Q_DECLARE_LOGGING_CATEGORY(sdkcore)
 Q_DECLARE_LOGGING_CATEGORY(sdknetwork)
 Q_DECLARE_LOGGING_CATEGORY(sdkutils)
+Q_DECLARE_LOGGING_CATEGORY(sdkutilsdb)
 Q_DECLARE_LOGGING_CATEGORY(sdkdb)
 
 namespace serversdk {
@@ -94,6 +95,10 @@ public:
     virtual void pushMessage(const LoggerMessage& logmsg);
     QList<serversdk::LoggerMessage> getNewMessages(int currentCount);
 
+    static QString toColor(const QString &color, const QString &text);
+
+    /** I will enable color output for terminal ( linux only ) */
+    void setColorOutput(bool colorOutput);
 
 signals:
     void messageReceived(const serversdk::LoggerMessage &message);
@@ -101,6 +106,7 @@ signals:
 private:
     QList<LoggerMessage> mLogMessages; //!< Test
     QMutex mMutex;
+    static bool mColorOutput;
 };
 
 

src/serversdk/request.cpp

@@ -7,7 +7,7 @@
 namespace serversdk {
 
 Request::Request(QString type, QString url, QByteArray requestData)
-    : mType(type), mUrl(url), mRequestData(requestData)
+    : mType(std::move(type)), mUrl(std::move(url)), mRequestData(std::move(requestData))
 {
 }
 
@@ -40,10 +40,19 @@ QNetworkRequest Request::networkRequest() const
     return request;
 }
 
+
 int Request::status() const
 {
     Q_ASSERT(mNetworkReply);
-    return mNetworkReply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+    if (!mNetworkReply->isFinished())
+        return 0;
+
+    auto variant = mNetworkReply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    if (!variant.isValid()) {
+        return -1;
+    }
+    return variant.toInt();
 }
 
 
@@ -143,4 +152,19 @@ QString Request::bearerAuthorization() const
     return QString();
 }
 
+qint64 Request::getProcessTime()
+{
+    if (!mStartTime.isNull() && !mFinishTime.isNull()) {
+        return mStartTime.msecsTo(mFinishTime);
+    }
+    return -1;
+}
+
 } // core
+
+
+QDebug operator <<(QDebug dbg, serversdk::Request *request)
+{
+    dbg.noquote() << request->type() << request->url() << "data:" << request->requestData() << "header:" << request->networkReply()->rawHeaderList();
+    return dbg.maybeSpace();
+}

src/serversdk/request.h

@@ -4,6 +4,7 @@
 #include <QNetworkRequest>
 #include <QDateTime>
 #include <QNetworkReply>
+#include <memory>
 
 namespace serversdk {
 
@@ -43,17 +44,19 @@ public:
     QString basicAuthorization() const;
     QString bearerAuthorization() const;
 
-    // Additional attributes
+    qint64 getProcessTime();
-    void logStartTime() { mStartTime = QDateTime::currentDateTime(); }
+
-    void logFinishTime() { mStartTime = QDateTime::currentDateTime(); }
 
 private:
+    // Additional attributes
+    void logStartTime() { mStartTime = QDateTime::currentDateTime(); }
+    void logFinishTime() { mFinishTime = QDateTime::currentDateTime(); }
     // Data handling
     void appendResponseData(const QByteArray &array);
 
 
 signals:
-    void finished();
+    void finished(std::shared_ptr<Request> request);
 
 private:
     QString mType = "GET"; // POST, GET
@@ -79,3 +82,4 @@ private:
 
 } // core
 
+QDebug operator<<(QDebug dbg, serversdk::Request *request);

src/serversdk/requestmanager.cpp

@@ -27,7 +27,7 @@ RequestManager::RequestManager(QObject *parent)
  *
  * @param Request
  */
-void RequestManager::processRequest(const std::shared_ptr<Request>& request)
+bool RequestManager::processRequest(const std::shared_ptr<Request>& request)
 {
     QNetworkReply *reply = nullptr;
     request->logStartTime();
@@ -46,9 +46,11 @@ void RequestManager::processRequest(const std::shared_ptr<Request>& request)
         reply = mNetworkAccessManager.put(request->networkRequest(), request->requestData());
     } else {
         qCritical(sdknetwork) << "Using request type:" << request->type() << "is not implemented";
-        return;
+        return false;
     }
 
+
+    Q_ASSERT(reply);
     // Adding reply to final request
     reply->setParent(nullptr); // ensure QNetworkreply wont be deleted by QNetworkAccessManager ( it is parent of reply )
     request->setNetworkReply(reply);
@@ -56,15 +58,19 @@ void RequestManager::processRequest(const std::shared_ptr<Request>& request)
     // Add to map to get correct request when reply is used in signal
     mRequestMap.insert(reply, request);
 
+    connect(reply, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error),
+             this, &RequestManager::replyError);
     connect(reply, &QNetworkReply::downloadProgress, this, &RequestManager::downloadProgress);
 
     connect(reply, &QNetworkReply::finished, this, [=]() {
         std::shared_ptr<Request> request = mRequestMap.value(reply);
         request->logFinishTime();
         mRequestMap.remove(reply);
-        emit request->finished();
+        emit request->finished(request);
         emit downloadFinished(request);
     });
+
+    return true;
 }
 
 /**
@@ -119,6 +125,16 @@ void RequestManager::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
     emit progresss(bytesReceived, bytesTotal);
 }
 
+void RequestManager::replyError(QNetworkReply::NetworkError code)
+{
+    auto *reply = qobject_cast<QNetworkReply*>(sender());
+    Q_ASSERT(mRequestMap.contains(reply));
+    std::shared_ptr<Request> request = mRequestMap.value(reply);
+
+
+    qCWarning(sdknetwork) << request.get() << "reply error: " << code;
+}
+
 bool RequestManager::ignoreSsl() const
 {
     return mIgnoreSsl;

src/serversdk/requestmanager.h

@@ -19,7 +19,7 @@ class RequestManager : public QObject
 public:
     explicit RequestManager(QObject *parent = nullptr);
 
-    void processRequest(const std::shared_ptr<Request>& request);
+    bool processRequest(const std::shared_ptr<Request>& request);
 
 
     bool ignoreSsl() const;
@@ -28,7 +28,7 @@ public:
 private:
     Q_SLOT void sslErrors(QNetworkReply *reply, const QList<QSslError> &sslErrors);
     Q_SLOT void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
-
+    Q_SLOT void replyError(QNetworkReply::NetworkError code);
 
 signals:
     void downloadFinished(std::shared_ptr<Request> request);

src/serversdk/serversdk.pro

@@ -7,6 +7,8 @@ CONFIG += c++14
 
 INCLUDEPATH += $$PWD
 
+#unix: DEFINES += USE_ZLIB
+
 SOURCES += \
     core.cpp \
     databasemanager.cpp \
@@ -30,3 +32,4 @@ HEADERS += \
     utils.h \
     soaprequest.h \
     databasetable.h
+

src/serversdk/soaprequest.cpp

@@ -1,9 +1,11 @@
 #include "soaprequest.h"
 
+#include <utility>
+
 namespace serversdk {
 
-SoapRequest::SoapRequest(QString action, QString endpoint, QByteArray data)
+SoapRequest::SoapRequest(QString action, const QString& endpoint, const QByteArray& data)
-    : mSoapAction(action)
+    : mSoapAction(std::move(action))
 {
     setType("POST");
     setUrl(endpoint);

src/serversdk/soaprequest.h

@@ -8,7 +8,7 @@ class SoapRequest : public Request
 {
     Q_OBJECT
 public:
-    SoapRequest(QString action, QString endpoint, QByteArray data);
+    SoapRequest(QString action, const QString& endpoint, const QByteArray& data);
     QNetworkRequest networkRequest() const override;
 
     QString soapAction() const;

src/serversdk/utils.cpp

@@ -3,11 +3,14 @@
 #include <QFileInfo>
 #include <QDir>
 
+#ifdef USE_ZLIB
 #include <zlib.h> // gzip decompress
-
+#endif
 
 namespace serversdk {
 
+
+#ifdef USE_ZLIB
 /**
  * @brief Decompress gzip data
  * @param compressed gzip data
@@ -16,7 +19,7 @@ namespace serversdk {
 QByteArray Utils::decompress(const QByteArray &compressed)
 {
     if (compressed.size() <= 4) {
-        qWarning("gUncompress: Input data is truncated");
+        qCCritical(sdkutils) << "gUncompress: Input data is truncated";
         return QByteArray();
     }
 
@@ -74,6 +77,7 @@ QByteArray Utils::decompress(const QByteArray &compressed)
 
     return result;
 }
+#endif
 
 
 } // namespace core

src/serversdk/utils.h

@@ -9,7 +9,10 @@ namespace serversdk {
 class Utils
 {
 public:
+#ifdef USE_ZLIB
     static QByteArray decompress(const QByteArray &compressed);
+#endif
+
 };
 
 } // namespace serversdk

src/testapp/main.cpp

@@ -3,15 +3,13 @@
 #include <QCoreApplication>
 #include <QCommandLineParser>
 
-
 int main(int argc, char *argv[])
 {
     serversdk::initAppLogger();
 
-    qCDebug(sdkcore) << "test message";
+    qCDebug(sdkcore) << "Application starting";
 
     QCoreApplication app(argc, argv);
     QCoreApplication::setApplicationName("example-app");
     QCoreApplication::setApplicationVersion("0.1.0");
-
 }

test/auto/auto.pro

@@ -9,4 +9,5 @@ SUBDIRS += \
     database/tst_postgresql.pro \
     database/tst_databasetable.pro \
     database/tst_databaseutils.pro \
-    tst_utils
+
+unix: SUBDIRS += tst_utils

test/auto/database/tst_databasetable.cpp

@@ -1,4 +1,4 @@
-#include "serversdk/databasetable.h"
+#include "serversdk/databasetable.h"
 
 #include <QtTest>
 
@@ -7,12 +7,72 @@
 class BookTable : public serversdk::DatabaseTable
 {
     Q_OBJECT
-    TABLE_PROPERTY(QUuid, uuid, setUuid, QUuid());
+    TABLE_PROPERTY(QString, uuid, setUuid, QString());
     TABLE_PROPERTY(int, id, setId, 0);
     TABLE_PROPERTY(QString, name, setName, "Test");
+    TABLE_PROPERTY(QString, author, setAuthor, "Me");
+public:
+    QByteArray filteredJson() {
+        auto variant = this->toVariantMap();
+        variant.remove("author");
+        QJsonDocument doc = QJsonDocument::fromVariant(variant);
+        return doc.toJson(QJsonDocument::Compact);
+    }
 };
 
 
+QString enumjson = R"({"authErrors":255,"flags":["Enabled","NoValidity"],"subjectId":"1438aade-3aa6-4885-8e0f-138dedae727a"})";
+
+
+class EnumTest : public serversdk::DatabaseTable
+{
+    Q_OBJECT
+    TABLE_PROPERTY(int, authErrors, setAuthErrors, 0);
+    TABLE_PROPERTY(bool, enabled, setEnabled, false);
+    TABLE_PROPERTY(bool, noValidity, setNoValidity, false);
+    TABLE_PROPERTY(QString, subjectId, setSubjectId, QString());
+public:
+    QByteArray jsonData(const QSet<QString> &filters = QSet<QString>()) const override
+    {
+        auto variantMap = this->toVariantMap(filters);
+        auto enabled = variantMap["enabled"].toBool();
+        auto noValidity = variantMap["noValidity"].toBool();
+        variantMap.remove("enabled");
+        variantMap.remove("noValidity");
+        QVariantList flags;
+        if ( enabled ) {
+            flags << "Enabled";
+        }
+        if ( noValidity ) {
+            flags << "NoValidity";
+        }
+        variantMap.insert("flags", flags);
+
+        QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
+        return doc.toJson(QJsonDocument::Compact);
+    }
+    bool fromJson(const QByteArray &data) override
+    {
+        QJsonDocument doc = QJsonDocument::fromJson(data);
+        QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
+
+        QVariantList flags = variant["flags"].toList();
+        for (auto value : flags) {
+            if ( value.toString() == "Enabled") {
+                variant.insert("enabled", true);
+            }
+            if ( value.toString() == "NoValidity") {
+                variant.insert("noValidity", true);
+            }
+        }
+        variant.remove("flags");
+
+        // Populate this object data
+        bool res = fromVariantMap(variant);
+        return res;
+    }
+};
+
 
 class DatabaseTableTest : public QObject
 {
@@ -26,6 +86,9 @@ private slots:
     void constructor_test();
     void qvariant_test();
     void json_test();
+    void enum_test();
+
+    void filter_json_test();
 
 };
 
@@ -42,13 +105,16 @@ void DatabaseTableTest::constructor_test()
     auto table = std::make_unique<BookTable>();
     QCOMPARE(table->id(), 0);
     QCOMPARE(table->name(), QStringLiteral("Test"));
+
+    QCOMPARE(table->primaryKey(), QStringLiteral("uuid"));
 }
 
+
 void DatabaseTableTest::qvariant_test()
 {
     auto table = std::make_unique<BookTable>();
     QVariantMap map = table->toVariantMap();
-    QCOMPARE(map.count(), 3);
+    QCOMPARE(map.count(), 4);
 }
 
 void DatabaseTableTest::json_test()
@@ -57,10 +123,47 @@ void DatabaseTableTest::json_test()
     QCOMPARE(table->id(), 0);
     QCOMPARE(table->name(), QStringLiteral("Test"));
 
-    QByteArray expected(R"({"id":0,"name":"Test","uuid":"{00000000-0000-0000-0000-000000000000}"})");
+    QByteArray expected(R"({"author":"Me","id":0,"name":"Test","uuid":""})");
     QCOMPARE(table->jsonData(), expected);
 }
 
+void DatabaseTableTest::enum_test()
+{
+    auto table = std::make_unique<EnumTest>();
+    table->setAuthErrors(255);
+    table->setNoValidity(true);
+    table->setEnabled(true);
+    table->setSubjectId("1438aade-3aa6-4885-8e0f-138dedae727a");
+
+    QCOMPARE(table->jsonData(), enumjson.toUtf8());
+
+    EnumTest jsonTest;
+
+    jsonTest.fromJson(enumjson.toUtf8());
+
+    QCOMPARE(jsonTest.authErrors(), 255);
+    QCOMPARE(jsonTest.noValidity(), true);
+    QCOMPARE(jsonTest.enabled(), true);
+    QCOMPARE(jsonTest.subjectId(), QStringLiteral("1438aade-3aa6-4885-8e0f-138dedae727a"));
+
+}
+
+/** Baseclass must not contain property of derived class ( extended class ) */
+void DatabaseTableTest::filter_json_test()
+{
+    auto book = std::make_shared<BookTable>();
+    QCOMPARE(book->jsonData(), QByteArray(R"({"author":"Me","id":0,"name":"Test","uuid":""})"));
+
+
+    const QByteArray filtered(R"({"id":0,"name":"Test","uuid":""})");
+    QCOMPARE(book->filteredJson(), filtered);
+    QCOMPARE(book->jsonData({"author"}), filtered);
+}
+
+
+
+
+
 QTEST_APPLESS_MAIN(DatabaseTableTest)
 
 #include "tst_databasetable.moc"

test/auto/database/tst_databaseutils.cpp

@@ -33,6 +33,8 @@ public:
 
 private slots:
     void createTable_test();
+    void toCamelCase_test();
+    void fromCamelCase_test();
 
 };
 
@@ -53,7 +55,7 @@ void DatabaseUtilsTest::createTable_test()
     QString sql = utils.createTableText(table.get(), "subjects");
 
     QString expected = "CREATE TABLE subjects ( "
-                       "id TEXT PRIMARY KEY, "
+                       "id TEXT PRIMARY KEY NOT NULL, "
                        "description TEXT, "
                        "last_update INTEGER, "
                        "name TEXT, "
@@ -64,6 +66,18 @@ void DatabaseUtilsTest::createTable_test()
     QCOMPARE(sql, expected);
 }
 
+void DatabaseUtilsTest::toCamelCase_test()
+{
+    QString test1 = "id_name";
+    QCOMPARE(serversdk::DatabaseUtils::toCamelCase(test1), QStringLiteral("idName"));
+}
+
+void DatabaseUtilsTest::fromCamelCase_test()
+{
+    QString test1 = "idName";
+    QCOMPARE(serversdk::DatabaseUtils::fromCamelCase(test1), QStringLiteral("id_name"));
+}
+
 
 
 QTEST_APPLESS_MAIN(DatabaseUtilsTest)

test/auto/database/tst_postgresql.cpp

@@ -6,7 +6,7 @@
 // add necessary includes here
 
 
-class Names : public serversdk::DatabaseTable {
+class Name : public serversdk::DatabaseTable {
     Q_OBJECT
     TABLE_PROPERTY(int, id, set_id, 0);
     TABLE_PROPERTY(QString, name, set_name, 0);
@@ -68,7 +68,7 @@ void PostgresqlTest::createTable_test()
     QVERIFY(db.isValid());
     QVERIFY(db.isOpen());
 
-    Names names;
+    Name names;
 
     //Have to drop tabel
     QSqlQuery dropQuery = db.execPlainSql("DROP TABLE names");
@@ -87,12 +87,15 @@ void PostgresqlTest::createTable_test()
 
     // SELECT FROM TABLE
     QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
-    auto listVariantMap = utils.listMapFromQuery(selectSQL);
+    auto list = utils.tableFromQuery<Name>(selectSQL);
-    auto list = Names::fromListVariantMap(listVariantMap);
 
     // ENSURE SAME
+    auto first = list.first();
+    // Problem is that fromListvariantMap returns shared_ptr of class DataTable
+    // Must subclass.
+    auto names_tab = std::dynamic_pointer_cast<Name>(first);
     QCOMPARE(list.count(), 1);
-    QCOMPARE(list.first()->name(), QStringLiteral("Testname"));
+    QCOMPARE(names_tab->name(), QStringLiteral("Testname"));
 
     QCOMPARE(list.first()->jsonData(), names.jsonData());
 }

test/auto/database/tst_sqlite.cpp

@@ -5,11 +5,12 @@
 #include "serversdk/core.h"
 // add necessary includes here
 
-
+class Name : public serversdk::DatabaseTable {
-class Names : public serversdk::DatabaseTable {
     Q_OBJECT
+    TABLE_PROPERTY(QString, uuid, set_uuid, QString());
     TABLE_PROPERTY(int, id, set_id, 0);
-    TABLE_PROPERTY(QString, name, set_name, 0);
+    TABLE_PROPERTY(QString, name, set_name, "");
+    TABLE_PROPERTY(QString, vehicleName, set_vehicle_name, "Škodouliňkaťoučký");
 };
 
 
@@ -18,24 +19,15 @@ class SqliteTest : public QObject
     Q_OBJECT
 
 public:
-    SqliteTest();
+    SqliteTest() = default;
-    ~SqliteTest();
 
 private slots:
     void createDb_test();
     void createTable_test();
-
+    void updateTable_test();
+    void fail_updateTable_test();
 };
 
-SqliteTest::SqliteTest()
-{
-
-}
-
-SqliteTest::~SqliteTest()
-{
-
-}
 
 void SqliteTest::createDb_test()
 {
@@ -72,28 +64,117 @@ void SqliteTest::createTable_test()
     db.openSQLite(dbpath);
     QVERIFY(db.isOpen());
 
-    Names names;
+    Name name_A, name_B;
 
     // CREATE TABLE
     serversdk::DatabaseUtils utils(&db);
-    QSqlQuery query = utils.createTable(&names, "names");
+    QSqlQuery query = utils.createTable(&name_A, "names");
 
     // INSERT INTO TABLE
-    names.set_id(2);
+    const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6";
-    names.set_name("Testname");
+    const QString uuidB = "d70143ab-8c14-4ee0-85cb-f0d1b72df104";
+    name_A.set_uuid(uuidA);
+    name_A.set_id(2);
+    name_A.set_name("TestnameA");
+    name_B.set_uuid(uuidB);
+    name_B.set_id(2);
+    name_B.set_name("TestnameB");
 
-    utils.insertIntoTable(&names, "names");
+    utils.insertIntoTable(&name_A, "names");
+    utils.insertIntoTable(&name_B, "names");
 
     // SELECT FROM TABLE
     QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
-    auto listVariantMap = utils.listMapFromQuery(selectSQL);
+    auto list = utils.tableFromQuery<Name>(selectSQL);
-    auto list = Names::fromListVariantMap(listVariantMap);
+
 
     // ENSURE SAME
-    QCOMPARE(list.count(), 1);
+    QCOMPARE(list.count(), 2);
-    QCOMPARE(list.first()->name(), QStringLiteral("Testname"));
+    auto names_tab = list.first();
+    qDebug() << "Uuid" << names_tab->uuid();
+    QVERIFY(names_tab);
+    QCOMPARE(names_tab->name(), QStringLiteral("TestnameA"));
 
-    QCOMPARE(list.first()->jsonData(), names.jsonData());
+    QCOMPARE(list.first()->jsonData(), name_A.jsonData());
+}
+
+void SqliteTest::updateTable_test()
+{
+    // Prepare temporary path for database
+    QTemporaryDir dir;
+    QString dbpath = dir.path() + "/testdb.sqlite";
+    serversdk::DatabaseManager db;
+    db.openSQLite(dbpath);
+    QVERIFY(db.isOpen());
+
+    Name name_A, name_B;
+
+    // CREATE TABLE
+    serversdk::DatabaseUtils utils(&db);
+    QSqlQuery query = utils.createTable(&name_A, "names");
+
+    // INSERT INTO TABLE
+    const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6";
+    const QString uuidB = "d70143ab-8c14-4ee0-85cb-f0d1b72df104";
+    name_A.set_uuid(uuidA);
+    name_A.set_id(2);
+    name_A.set_name("TestnameA");
+    name_B.set_uuid(uuidB);
+    name_B.set_id(2);
+    name_B.set_name("TestnameB");
+
+
+    QVERIFY2(utils.insertIntoTable(&name_A, "names").isActive(), "Successfull insert must return isActive sqlQuery");
+    QVERIFY2(utils.insertIntoTable(&name_B, "names").isActive(), "Successfull insert must return isActive sqlQuery");
+
+
+    // NOW UPDATING TABLE WITH name: NewName
+    name_A.set_name("TestnameA-new");
+    utils.updateTable(&name_A, "names");
+    name_B.set_name("TestnameB-new");
+    utils.updateTable(&name_B, "names");
+
+    // SELECT FROM TABLE
+    QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
+    auto list = utils.tableFromQuery<Name>(selectSQL);
+    QCOMPARE(list.count(), 2);
+
+    auto dbA = list.first();
+    auto dbB = list.last();
+    QCOMPARE(dbA->name(), name_A.name());
+    QCOMPARE(dbB->name(), name_B.name());
+
+    QCOMPARE(dbA->jsonData(), name_A.jsonData());
+    QCOMPARE(dbB->jsonData(), name_B.jsonData());
+}
+
+/** # Fail Update test
+ *
+ * Test isActive must be FALSE when not possible to update database table
+ */
+void SqliteTest::fail_updateTable_test()
+{
+    // Prepare temporary path for database
+    QTemporaryDir dir;
+    QString dbpath = dir.path() + "/testdb.sqlite";
+    serversdk::DatabaseManager db;
+    db.openSQLite(dbpath);
+    QVERIFY(db.isOpen());
+
+    Name name_A, name_B;
+
+    // CREATE TABLE
+    serversdk::DatabaseUtils utils(&db);
+    QSqlQuery query = utils.createTable(&name_A, "names");
+
+    // INSERT INTO TABLE
+    const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6";
+    name_A.set_uuid(uuidA);
+    name_A.set_id(2);
+    name_A.set_name("TestnameA");
+
+
+    QVERIFY2(!utils.insertIntoTable(&name_A, "nonexistenttable").isActive(), "Successfull insert must return isActive sqlQuery");
 }
 
 QTEST_APPLESS_MAIN(SqliteTest)

test/auto/request/tst_requestmanager.cpp

@@ -26,10 +26,16 @@ namespace serversdk {
 class RequestManagerTest : public QObject
 {
     Q_OBJECT
+public:
+    RequestManagerTest() {
+        qRegisterMetaType<std::shared_ptr<serversdk::Request>>("std::shared_ptr<Request>");
+    }
 private:
     Q_SLOT void colnodAuthorization_test();
     Q_SLOT void colnodGetUpdatedTokens_test();
 
+    Q_SLOT void notConncetion_test();
+
     std::shared_ptr<Request> colnodLoginRequest();
 };
 
@@ -55,6 +61,7 @@ void RequestManagerTest::colnodAuthorization_test()
     QCOMPARE(loginRequest->basicAuthorization(), QStringLiteral("Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA=="));
 
     QSignalSpy loginFinished(loginRequest.get(), &serversdk::Request::finished);
+    QTest::ignoreMessage(QtDebugMsg, "\"SSL error:\" \"The host name did not match any of the valid hosts for this certificate\"");
     reqMan.processRequest(loginRequest);
 
     QVERIFY(loginFinished.wait());
@@ -79,6 +86,7 @@ void RequestManagerTest::colnodGetUpdatedTokens_test()
     QCOMPARE(loginRequest->basicAuthorization(), QStringLiteral("Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA=="));
 
     QSignalSpy spyFinished(loginRequest.get(), &serversdk::Request::finished);
+    QTest::ignoreMessage(QtDebugMsg, "\"SSL error:\" \"The host name did not match any of the valid hosts for this certificate\"");
     reqMan.processRequest(loginRequest);
 
     QVERIFY(spyFinished.wait());
@@ -102,7 +110,25 @@ void RequestManagerTest::colnodGetUpdatedTokens_test()
     QCOMPARE(tokensFinished.count(), 1 );
 
     QVERIFY(tokensRequest->status() == 200);
-    qDebug() << tokensRequest->responseData();
+    //qDebug() << tokensRequest->responseData();
+}
+
+void RequestManagerTest::notConncetion_test()
+{
+    serversdk::RequestManager reqMan;
+    reqMan.setIgnoreSsl(true);
+
+    auto tokensRequest = std::make_shared<serversdk::Request>("POST", "https://localhost:9999/TokenManager/getTokensUpdated", QByteArray("{}"));
+    //QTest::ignoreMessage(QtWarningMsg, QRegularExpression("POST.*error.*"));
+    reqMan.processRequest(tokensRequest);
+    QTest::ignoreMessage(QtWarningMsg, "POST https://localhost:9999/TokenManager/getTokensUpdated data: {} header: ()  reply error:  QNetworkReply::NetworkError(ConnectionRefusedError)");
+    QVERIFY(tokensRequest->networkReply());
+
+    QSignalSpy tokensFinished(tokensRequest.get(), &serversdk::Request::finished);
+    QVERIFY(tokensFinished.wait());
+    QCOMPARE(tokensFinished.count(), 1 );
+
+    QCOMPARE(tokensRequest->status(), -1);
 }
 
 

test/auto/request/tst_soaptest.cpp

@@ -18,9 +18,11 @@ public:
 private:
     Q_SLOT void construct();
 
-    Q_SLOT void public_soap_xml();
+    /*Q_SLOT*/ void geocode_soap();
 
-    Q_SLOT void public_soap_test();
+    /*Q_SLOT*/ void public_soap_xml();
+
+    /*Q_SLOT*/ void public_soap_test();
     Q_SLOT void public_soap_test_data();
 };
 
@@ -42,10 +44,58 @@ void SoapTest::construct()
     //QCOMPARE(Utils::sourceData("test/cmd/LatLonListSubgrid-response.xml").count(), 1298);
 }
 
+void SoapTest::geocode_soap()
+{
+    const QString soapAction = "https://geoservices.tamu.edu/GeocodeAddressNonParsed";
+    const QString host = "https://geoservices.tamu.edu";
+    const QString endpoint = "/Services/Geocode/WebService/GeocoderService_V04_01.asmx";
+    const QString url = host + endpoint;
+
+    QString xml = QString(R"(<?xml version="1.0" encoding="utf-8"?>
+                          <soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
+                            <soap12:Body>
+                              <GeocodeAddressNonParsed xmlns="https://geoservices.tamu.edu/">
+                                <streetAddress>string</streetAddress>
+                                <city>string</city>
+                                <state>string</state>
+                                <zip>string</zip>
+                                <apiKey>string</apiKey>
+                                <version>double</version>
+                                <shouldCalculateCensus>boolean</shouldCalculateCensus>
+                                <censusYear>Unknown or NineteenNinety or TwoThousand or TwoThousandTen or AllAvailable</censusYear>
+                                <shouldReturnReferenceGeometry>boolean</shouldReturnReferenceGeometry>
+                                <shouldNotStoreTransactionDetails>boolean</shouldNotStoreTransactionDetails>
+                              </GeocodeAddressNonParsed>
+                            </soap12:Body>
+                          </soap12:Envelope>)");
+
+    QByteArray xmlRequest = xml.toUtf8();
+
+    // SOAP download
+    RequestManager soap;
+    auto response = std::make_shared<SoapRequest>(soapAction, url, xmlRequest);
+    QCOMPARE(response.use_count(), 1L );
+    soap.processRequest(response);
+    QVERIFY(soap.mRequestMap.count() == 1);
+    QSignalSpy spyFinished(&soap, &RequestManager::downloadFinished);
+
+    QVERIFY(spyFinished.wait());
+    //QCOMPARE(response.use_count(), 2L ); // this context + Soap
+    spyFinished.clear();
+    QCOMPARE(response.use_count(), 1L ); // this context + Soap
+
+    // Response
+    QByteArray xmlResponse = Test::sourceData("soap/bankapi-response.xml");
+    QVERIFY( ! xmlResponse.isEmpty());
+
+    QCOMPARE(response.use_count(), 1L ); // this context + Soap
+    QCOMPARE(response->responseData(), xmlResponse);
+}
+
 void SoapTest::public_soap_xml()
 {
     QString soapAction = "blz:getBank";
-    QString endpoint = "http://www.thomas-bayer.com/axis2/services/BLZService";
+    QString url = "http://www.thomas-bayer.com/axis2/services/BLZService";
     QString xml = QString("<soapenv:Envelope "
         "xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" "
         "xmlns:blz=\"http://thomas-bayer.com/blz/\">"
@@ -61,7 +111,7 @@ void SoapTest::public_soap_xml()
 
     // SOAP download
     RequestManager soap;
-    auto response = std::make_shared<SoapRequest>(soapAction, endpoint, xmlRequest);
+    auto response = std::make_shared<SoapRequest>(soapAction, url, xmlRequest);
     QCOMPARE(response.use_count(), 1L );
     soap.processRequest(response);
     QVERIFY(soap.mRequestMap.count() == 1);
@@ -123,11 +173,9 @@ void SoapTest::public_soap_test()
     //    QVERIFY(fileWrite.open(QIODevice::WriteOnly));
     //    fileWrite.write(req->responseData());
     //    fileWrite.close();
-    QProcess process;
+//    QProcess process;
-    process.start("hostname");
+//    process.start("hostname");
-    process.waitForFinished(-1); // will wait forever until finished
+//    process.waitForFinished(-1); // will wait forever until finished
-
-    QString stdout = process.readAllStandardOutput();
 
     QCOMPARE(req->responseData(), xmlResponse);
 }

test/data/soap/bankapi-1.2-response.xml

@@ -1 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?><soapenv:Envelope xmlns:soapenv="http://www.w3.org/2003/05/soap-envelope"><soapenv:Body><ns1:getBankResponse xmlns:ns1="http://thomas-bayer.com/blz/"><ns1:details><ns1:bezeichnung>BHF-BANK</ns1:bezeichnung><ns1:bic>BHFBDEFF100</ns1:bic><ns1:ort>Berlin</ns1:ort><ns1:plz>10117</ns1:plz></ns1:details></ns1:getBankResponse></soapenv:Body></soapenv:Envelope>

test/data/soap/bankapi-1.2.sh

@@ -4,11 +4,11 @@
 
 ACTION_YOU_WANT_TO_CALL="blz:getBank"
 
-XMLFILENAME=test03-1.2.xml
+XMLFILENAME=bankapi-1.2.xml
 
 URL_OF_THE_SOAP_WEB_SERVICE_ENDPOINT="http://www.thomas-bayer.com/axis2/services/BLZService"
 
 curl -X POST $URL_OF_THE_SOAP_WEB_SERVICE_ENDPOINT \
   -H 'Content-Type: application/soap+xml;action=$ACTION_YOU_WANT_TO_CALL' \
   -H 'SOAPAction: $ACTION_YOU_WANT_TO_CALL' \
-  --data @$XMLFILENAME > test03-1.2-response.xml
+  --data @$XMLFILENAME > bankapi-1.2-response.xml

test/data/soap/bankapi.sh

@@ -4,11 +4,11 @@
 
 ACTION_YOU_WANT_TO_CALL="blz:getBank"
 
-XMLFILENAME=test03.xml
+XMLFILENAME=bankapi.xml
 
 URL_OF_THE_SOAP_WEB_SERVICE_ENDPOINT="http://www.thomas-bayer.com/axis2/services/BLZService"
 
 curl -X POST $URL_OF_THE_SOAP_WEB_SERVICE_ENDPOINT \
   -H 'Content-Type: text/xml' \
   -H 'SOAPAction: $ACTION_YOU_WANT_TO_CALL' \
-  --data @$XMLFILENAME > test03-response.xml
+  --data @$XMLFILENAME > bankapi-response.xml