added support for Postgresql database

src/serversdk/databasemanager.cpp

@@ -10,22 +10,7 @@ DatabaseManager::DatabaseManager()
 {
 }
 
-DatabaseManager::DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password, bool dryMode)
+
-    : mDryMode(dryMode)
-{
-    mDatabase = QSqlDatabase::addDatabase("QPSQL");
-    mDatabase.setDatabaseName(dbName);
-    mDatabase.setHostName(host);
-    mDatabase.setUserName(user); // home-office stuff -->> db.setPort(80);
-    mDatabase.setPassword(password);
-    if (mDatabase.open())
-    {
-        query = QSqlQuery("query", mDatabase);
-    } else {
-        log("Opening error" + mDatabase.lastError().text());
-        emit error();
-    }
-}
 
 DatabaseManager::~DatabaseManager()
 {
@@ -48,6 +33,7 @@ bool DatabaseManager::openSQLite(const QString &path, const QString &connectionN
     mConnectionName = connectionName;
     mDatabase = QSqlDatabase::addDatabase("QSQLITE", mConnectionName);
     mDatabase.setDatabaseName(path);
+
     int res = mDatabase.open();
 
     if (!res) {
@@ -56,6 +42,25 @@ bool DatabaseManager::openSQLite(const QString &path, const QString &connectionN
     return res;
 }
 
+bool DatabaseManager::openPostgres(const QString &host, const QString &dbName, const QString &user, const QString &password, const QString &connectionName)
+{
+    Q_ASSERT_X(mConnectionName.isEmpty(), "open postgres", "Expecting only one database per DatabaseManager");
+    mConnectionName = connectionName;
+    mDatabase = QSqlDatabase::addDatabase("QPSQL", mConnectionName);
+
+    mDatabase.setDatabaseName(dbName);
+    mDatabase.setHostName(host);
+    mDatabase.setUserName(user); // home-office stuff -->> db.setPort(80);
+    mDatabase.setPassword(password);
+
+    int res = mDatabase.open();
+
+    if (!res) {
+        qInfo(sdkdb) << "Not possible to open database from url:" << host;
+    }
+    return res;
+}
+
 
 bool DatabaseManager::isValid() const
 {
@@ -116,8 +121,9 @@ QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText
 QSqlQuery DatabaseManager::processResult(int res, const QSqlQuery &query) const
 {
     if ( !res ) {
-        QString msg = QString("Source: Database Manager, Error: %1").arg(query.lastError().text());
+        QString msg = QString("Source: Database Manager \nError --------\n%1\nSQL-------\n%2\n--------")
-        qCWarning(sdkdb) << msg;
+                .arg(query.lastError().text(), query.lastQuery());
+        qCDebug(sdkdb).noquote() << msg;
         log(msg);
     }
     return query;

src/serversdk/databasemanager.h

@@ -27,6 +27,7 @@ public:
 
 
     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;
     bool isOpen() const;
     void close();

src/serversdk/databaseutils.cpp

@@ -15,7 +15,7 @@ namespace serversdk {
  * @return
  *
  * @code{sql}
- * "CREATE TABLE colnod_subject ("
+ * "CREATE TABLE colsunod_bject ("
                         "id character(36) primary key NOT NULL,"
                         "description character varying(255),"
                         "last_update timestamp NOT NULL,"
@@ -66,9 +66,8 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
         if (sqlType() == "SQLITE") {
             textType = this->textSQLIteType(type);
         } else if (sqlType() == "PSQL") {
-            qCDebug(sdkdb) << "Implemented only for SQLITE";
+            textType = this->textSQLIteType(type);
-            return QString();
+            //return QString();
-
         } else {
             qCDebug(sdkdb) << "Implemented only for SQLITE";
             return QString();
@@ -130,7 +129,7 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri
     }
 
     QSqlQuery query(mDatabaseManager->database());
-    QString queryText = QString("INSERT OR IGNORE INTO %1 ( %2 ) VALUES ( %3 );").arg(table_name).arg(columns).arg(values);
+    QString queryText = QString("INSERT INTO %1 ( %2 ) VALUES ( %3 );").arg(table_name).arg(columns).arg(values);
     query.prepare(queryText);
 
     for (auto key : keys ) {
@@ -193,6 +192,30 @@ QString DatabaseUtils::textSQLIteType(QVariant::Type type) const
     }
 }
 
+QString DatabaseUtils::textPostgresType(QVariant::Type type) const
+{
+    switch (type) {
+    case QVariant::Int:
+        return QStringLiteral("INTEGER");
+        break;
+    case QVariant::Uuid:
+        return QStringLiteral("TEXT");
+        break;
+    case QVariant::String:
+        return QStringLiteral("TEXT");
+        break;
+    case QVariant::DateTime:
+        return QStringLiteral("INTEGER");
+        break;
+    case QVariant::Bool:
+        return QStringLiteral("INTEGER");
+        break;
+    default:
+        return QString();
+        break;
+    }
+}
+
 
 
 } // namespace serversdk

src/serversdk/databaseutils.h

@@ -32,6 +32,7 @@ private:
 
 
     QString textSQLIteType(QVariant::Type type) const;
+    QString textPostgresType(QVariant::Type type) const;
 private:
     DatabaseManager *mDatabaseManager = nullptr;
     QString mSqlType;

test/auto/auto.pro

@@ -6,6 +6,7 @@ SUBDIRS += \
     request/tst_requestmanager.pro \
     database/tst_databasemanager.pro \
     database/tst_sqlite.pro \
+    database/tst_postgresql.pro \
     database/tst_databasetable.pro \
     database/tst_databaseutils.pro \
     tst_utils

test/auto/database/tst_postgresql.cpp

@@ -0,0 +1,102 @@
+#include <QtTest>
+
+#include "serversdk/databasemanager.h"
+#include "serversdk/databaseutils.h"
+#include "serversdk/core.h"
+// add necessary includes here
+
+
+class Names : public serversdk::DatabaseTable {
+    Q_OBJECT
+    TABLE_PROPERTY(int, id, set_id, 0);
+    TABLE_PROPERTY(QString, name, set_name, 0);
+};
+
+
+class PostgresqlTest : public QObject
+{
+    Q_OBJECT
+
+public:
+    PostgresqlTest();
+    ~PostgresqlTest();
+
+private slots:
+    void opendb_test();
+    void createTable_test();
+
+};
+
+PostgresqlTest::PostgresqlTest()
+{
+
+}
+
+PostgresqlTest::~PostgresqlTest()
+{
+
+}
+
+void PostgresqlTest::opendb_test()
+{
+    // Prepare temporary path for database
+    const QString host = "192.168.1.94";
+    const QString databaseName = "serversdk";
+    const QString user = "postgres";
+    const QString password = "34rjkciea12";
+
+    serversdk::DatabaseManager db;
+    db.openPostgres(host, databaseName, user, password);
+    QVERIFY(db.isValid());
+    QVERIFY(db.isOpen());
+
+    // Closing database
+    db.close();
+    QVERIFY(!db.isOpen());
+}
+
+void PostgresqlTest::createTable_test()
+{
+    // Prepare temporary path for database
+    const QString host = "192.168.1.94";
+    const QString databaseName = "serversdk";
+    const QString user = "postgres";
+    const QString password = "34rjkciea12";
+
+    serversdk::DatabaseManager db;
+    db.openPostgres(host, databaseName, user, password);
+    QVERIFY(db.isValid());
+    QVERIFY(db.isOpen());
+
+    Names names;
+
+    //Have to drop tabel
+    QSqlQuery dropQuery = db.execPlainSql("DROP TABLE names");
+    //QVERIFY(dropQuery.isValid());
+
+    // CREATE TABLE
+    serversdk::DatabaseUtils utils(&db, "PSQL");
+    QSqlQuery query = utils.createTable(&names, "names");
+    //QVERIFY(query.isValid());
+
+    // INSERT INTO TABLE
+    names.set_id(2);
+    names.set_name("Testname");
+
+    utils.insertIntoTable(&names, "names");
+
+    // SELECT FROM TABLE
+    QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
+    auto listVariantMap = utils.listMapFromQuery(selectSQL);
+    auto list = Names::fromListVariantMap(listVariantMap);
+
+    // ENSURE SAME
+    QCOMPARE(list.count(), 1);
+    QCOMPARE(list.first()->name(), QStringLiteral("Testname"));
+
+    QCOMPARE(list.first()->jsonData(), names.jsonData());
+}
+
+QTEST_APPLESS_MAIN(PostgresqlTest)
+
+#include "tst_postgresql.moc"

test/auto/database/tst_postgresql.pro

@@ -0,0 +1,11 @@
+QT += testlib
+QT -= gui
+
+CONFIG += qt console warn_on depend_includepath testcase
+CONFIG -= app_bundle
+
+TEMPLATE = app
+
+SOURCES +=  tst_postgresql.cpp
+
+include(../../test.pri)

test/auto/database/tst_sqlite.cpp

@@ -41,26 +41,26 @@ void SqliteTest::createDb_test()
 {
     // Prepare temporary path for database
     QTemporaryDir dir;
-    Q_ASSERT(dir.isValid());
+    QVERIFY(dir.isValid());
     QString dbpath = dir.path() + "/testdb.sqlite";
-    Q_ASSERT(!dbpath.isEmpty());
+    QVERIFY(!dbpath.isEmpty());
-    Q_ASSERT(!QFileInfo::exists(dbpath));
+    QVERIFY(!QFileInfo::exists(dbpath));
 
     serversdk::DatabaseManager db;
     db.openSQLite(dbpath);
-    Q_ASSERT(db.isValid());
+    QVERIFY(db.isValid());
-    Q_ASSERT(db.isOpen());
+    QVERIFY(db.isOpen());
-    Q_ASSERT(QFileInfo::exists(dbpath));
+    QVERIFY(QFileInfo::exists(dbpath));
 
     // Closing database
     db.close();
-    Q_ASSERT(!db.isOpen());
+    QVERIFY(!db.isOpen());
 
 
     // Temporary dir cleanup
-    Q_ASSERT(dir.remove());
+    QVERIFY(dir.remove());
 
-    Q_ASSERT(!QFileInfo::exists(dbpath));
+    QVERIFY(!QFileInfo::exists(dbpath));
 }
 
 void SqliteTest::createTable_test()
@@ -70,7 +70,7 @@ void SqliteTest::createTable_test()
     QString dbpath = dir.path() + "/testdb.sqlite";
     serversdk::DatabaseManager db;
     db.openSQLite(dbpath);
-    Q_ASSERT(db.isOpen());
+    QVERIFY(db.isOpen());