dev 8

ClientProtocol/dbobject.cpp

@@ -28,20 +28,20 @@ bool DBObject::getSaveQueryString(QSqlQuery *query) const {
 
 bool DBObject::getSelectQueryString(QSqlQuery *query) const {
 
-    if (_dbId < 0) {
+    if (_id < 0) {
         return false;
     }
 
-    QString queryString = "SELECT (%1) from %0 where id=" + QString::number(_dbId);
+    QString queryString = "SELECT (%1) from %0 where id=" + QString::number(_id);
     return getBaseQueryString(queryString, query);
 }
 
 bool DBObject::getDeleteQueryString(QSqlQuery *query) const {
-    if (_dbId < 0) {
+    if (_id < 0) {
         return false;
     }
 
-    QString queryString = "DELETE FROM %0 where id=" + QString::number(_dbId);
+    QString queryString = "DELETE FROM %0 where id=" + QString::number(_id);
     return getBaseQueryString(queryString, query);
 }
 
@@ -145,6 +145,16 @@ QDataStream &DBObject::toStream(QDataStream &stream) const {
     return stream;
 }
 
+QVariantMap &DBObject::fromVariantMap(QVariantMap &map) {
+    _dataTable = map;
+    return map;
+}
+
+QVariantMap &DBObject::toVariantmap(QVariantMap &map) const {
+    map = _dataTable;
+    return map;
+}
+
 int DBObject::getId() const {
     return _id;
 }

ClientProtocol/dbobject.h

@@ -88,13 +88,14 @@ protected:
 
     QVariantMap _dataTable;
     IDbTable * _tableStruct = nullptr;
-    int _dbId = -1;
     int _id = -1;
 
 
     //// StreamBase interface
     QDataStream &fromStream(QDataStream &stream) override;
     QDataStream &toStream(QDataStream &stream) const override;
+    QVariantMap &fromVariantMap(QVariantMap &map) override;
+    QVariantMap &toVariantmap(QVariantMap &map) const override;
 };
 }
 

ClientProtocol/dbtablebase.cpp

@@ -12,35 +12,35 @@ QString DbTableBase::name() const {
     return _name;
 }
 
-QString DbTableBase::toStringQuery() const {
+//QString DbTableBase::toStringQuery() const {
-    QString table = "CREATE TABLE IF NOT EXISTS" + _name + "(%0);";
+//    QString table = "CREATE TABLE IF NOT EXISTS" + _name + "(%0);";
-    QString columns = " id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,";
+//    QString columns = " id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,";
-    columns +=        " updateTime DATETIME NOT NULL DEFAULT NOW(),";
+//    columns +=        " updateTime DATETIME NOT NULL DEFAULT NOW(),";
 
-    for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
+//    for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
-        columns += it.key();
+//        columns += it.key();
 
-        auto val = it.value().toString();
+//        auto val = it.value().toString();
 
-        if (val.isEmpty()) {
+//        if (val.isEmpty()) {
-            columns += "BLOB";
+//            columns += "BLOB";
-        } else {
+//        } else {
-            columns += val;
+//            columns += val;
-        }
+//        }
 
-        columns += ',';
+//        columns += ',';
 
-    }
+//    }
 
-    for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) {
+//    for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) {
-        QString dep =   " FOREIGN KEY(_group) REFERENCES groups(id)
+//        QString dep =   " FOREIGN KEY(_group) REFERENCES groups(id)
-        columns += "    FOREIGN KEY(_group) REFERENCES groups(id)"
+//        columns += "    FOREIGN KEY(_group) REFERENCES groups(id)"
-                ON UPDATE CASCADE
+//                ON UPDATE CASCADE
-                ON DELETE CASCADE,"
+//                ON DELETE CASCADE,"
-    }
+//    }
 
-    return table.arg(columns);
+//    return table.arg(columns);
-}
+//}
 
 QHash<QString, QVariant::Type> DbTableBase::keys() const {
     return _keys;
@@ -54,57 +54,8 @@ DbTableBase::~DbTableBase() {
 
 }
 
-QVariantMap DbTableBase::tableMap() const {
+void DbTableBase::setKeys(const QHash<QString, QVariant::Type> &keys) {
-    return _tableMap;
+    _keys = keys;
 }
 
-void DbTableBase::setTableMap(const QVariantMap &tableMap) {
-    _tableMap = tableMap;
-
-    for (auto it = _tableMap.begin(); it != _tableMap.end(); ++it) {
-        _keys[it.key()] = getType(it.value().toString());
-    }
-}
-
-QHash<QString, QString> DbTableBase::dependencies() const {
-    return _dependencies;
-}
-
-void DbTableBase::setDependencies(const QHash<QString, QString> &dependencies) {
-    _dependencies = dependencies;
-}
-
-#define c(x) str.contains(x, Qt::CaseInsensitive)
-QVariant::Type DbTableBase::getType(const QString &str) {
-
-    if (str.isEmpty() || c(" BINARY") || c(" BLOB") || c(" TINYBLOB") || c(" MEDIUMBLOB") || c(" LONGBLOB")) {
-        return QVariant::ByteArray;
-    } else if (c(" INT")) {
-        return QVariant::Int;
-    } else if (c(" VARCHAR") || c(" TEXT") || c(" TINYTEXT") || c(" MEDIUMTEXT") || c(" LONGTEXT")) {
-        return QVariant::String;
-    } else if (c(" FLOAT") || c(" DOUBLE") || c(" REAL")) {
-        return QVariant::Double;
-    } else if (c(" BOOL")) {
-        return QVariant::Bool;
-    } else if (c(" DATETIME")) {
-        return QVariant::DateTime;
-    } else if (c(" DATE")) {
-        return QVariant::Date;
-    } else if (c(" TIME")) {
-        return QVariant::Time;
-    }
-
-    return QVariant::ByteArray;
-}
-
-bool DbTableBase::addDependecies(const IDbTable *table, const QString &val) {
-
-    if (table->keys().contains(val)) {
-        _dependencies[table->name()] = val;
-        return true;
-    }
-
-    return false;
-}
 }

ClientProtocol/dbtablebase.h

@@ -20,56 +20,25 @@ public:
 
     // IDbTable interface:
     QString name() const override;
-    QString toStringQuery() const override;
     QHash<QString, QVariant::Type> keys() const override;
+    void setKeys(const QHash<QString, QVariant::Type> &keys) override;
     QString lastIdQuery() const override;
 
     ~DbTableBase() override;
 
-    /**
-     * @brief tableMap
-     * @return
-     */
-    QVariantMap tableMap() const;
-
     /**
      * @brief setTableMap
      * @param tableMap
      */
-    void setTableMap(const QVariantMap &tableMap);
+    void setTableMap(const QHash<QString, QVariant::Type> &);
 
-    /**
-     * @brief dependencies
-     * @return
-     */
-    QHash<QString, QString> dependencies() const;
 
 protected:
-    /**
-     * @brief setDependencies
-     * @param dependencies
-     */
-    void setDependencies(const QHash<QString, QString> &dependencies);
-
-    /**
-     * @brief addDependecies
-     * @param table
-     * @param val
-     * @return
-     */
-    bool addDependecies(const IDbTable* table, const QString &val);
 
     QString _name;
-    QVariantMap _tableMap;
-    QHash<QString, QString> _dependencies;
 
 private:
-    /**
+
-     * @brief getType
-     * @param str
-     * @return
-     */
-    QVariant::Type getType(const QString& str);
 
     QHash<QString, QVariant::Type> _keys;
 };

ClientProtocol/idbtable.cpp

@@ -1 +1,6 @@
 #include "idbtable.h"
+
+ClientProtocol::IDbTable::IDbTable()
+{
+
+}

ClientProtocol/idbtable.h

@@ -24,26 +24,28 @@ public:
      */
     virtual QString name() const = 0;
 
-    /**
-     * @brief toStringQuery
-     * @return
-     */
-    virtual QString toStringQuery() const = 0;
-
     /**
      * @brief keys
      * @return
      */
     virtual QHash<QString, QVariant::Type> keys() const = 0;
 
+    /**
+     * @brief setKeys
+     * @param keys
+     */
+    virtual void setKeys(const QHash<QString, QVariant::Type> &keys) = 0;
+
     /**
      * @brief lastId
      * @return query for get last id of table in db
      */
     virtual QString lastIdQuery() const = 0;
 
+
     virtual ~IDbTable() = 0;
 
+
 };
 }
 #endif // IDBTABLE_H

ClientProtocol/sqldbwriter.cpp

@@ -23,16 +23,24 @@ bool SqlDBWriter::exec(QSqlQuery *sq,const QString& sqlFile) {
         stream.setCodec("UTF8");
 
         while(!stream.atEnd()) {
+
             temp += stream.readLine();
+
             if (temp.lastIndexOf("delimiter", -1, Qt::CaseInsensitive) > -1) {
+
                 temp.remove("delimiter", Qt::CaseInsensitive);
+
                 int last = temp.indexOf(QRegularExpression("[^ \f\n\r\t\v]")) + 1;
+
                 int begin = temp.lastIndexOf(QRegularExpression("[^ \f\n\r\t\v]"));
+
                 delimiter = temp.mid(begin, last - begin);
+
                 temp = "";
             } else {
                 if (temp.lastIndexOf(delimiter) >- 1) {
                     temp.remove(delimiter);
+
                     result = result && sq->exec(temp);
 
                     if (!result) {
@@ -41,6 +49,18 @@ bool SqlDBWriter::exec(QSqlQuery *sq,const QString& sqlFile) {
                         return false;
                     }
 
+                    if (temp.contains("CREATE TABLE ", Qt::CaseInsensitive)) {
+                        int tableBegin = temp.indexOf('(');
+                        int tableEnd = temp.indexOf(')');
+
+                        QStringList columns = temp.mid(tableBegin, tableEnd - tableBegin).split(',');
+
+                        for (QString & col : columns) {
+                            getType(col);
+                        }
+
+                    }
+
                     temp = "";
                 }
             }
@@ -105,6 +125,11 @@ QVariantMap SqlDBWriter::defaultInitPararm() const {
     return params;
 }
 
+QHash<QString, IDbTable *> SqlDBWriter::getDbStruct() const
+{
+    return _dbStruct;
+}
+
 SqlDBWriter::SqlDBWriter() {
 }
 
@@ -173,4 +198,28 @@ SqlDBWriter::~SqlDBWriter() {
 }
 
 
+#define c(x) str.contains(x, Qt::CaseInsensitive)
+QVariant::Type SqlDBWriter::getType(const QString &str) {
+
+    if (str.isEmpty() || c(" BINARY") || c(" BLOB") || c(" TINYBLOB") || c(" MEDIUMBLOB") || c(" LONGBLOB")) {
+        return QVariant::ByteArray;
+    } else if (c(" INT")) {
+        return QVariant::Int;
+    } else if (c(" VARCHAR") || c(" TEXT") || c(" TINYTEXT") || c(" MEDIUMTEXT") || c(" LONGTEXT")) {
+        return QVariant::String;
+    } else if (c(" FLOAT") || c(" DOUBLE") || c(" REAL")) {
+        return QVariant::Double;
+    } else if (c(" BOOL")) {
+        return QVariant::Bool;
+    } else if (c(" DATETIME")) {
+        return QVariant::DateTime;
+    } else if (c(" DATE")) {
+        return QVariant::Date;
+    } else if (c(" TIME")) {
+        return QVariant::Time;
+    }
+
+    return QVariant::ByteArray;
+}
+
 }

ClientProtocol/sqldbwriter.h

@@ -7,6 +7,7 @@
 #include <QSqlQuery>
 #include "clientprotocol_global.h"
 #include "config.h"
+#include <QVariant>
 
 class QSqlQuery;
 class QSqlDatabase;
@@ -15,6 +16,8 @@ class PlayerDBData;
 
 namespace ClientProtocol {
 
+class IDbTable;
+
 /**
  * @brief The SqlDBWriter class
  */
@@ -27,6 +30,12 @@ private:
 
 protected:
 
+    /**
+     * @brief getDbStruct
+     * @return structure of the data base
+     */
+    QHash<QString, IDbTable*> getDbStruct() const;
+
     /**
      * @brief enableFK - enavle forign ke for sqlite db
      * @return return true if all good
@@ -64,8 +73,16 @@ protected:
      */
     virtual QVariantMap defaultInitPararm() const;
 
+    /**
+     * @brief getType
+     * @param str
+     * @return
+     */
+    virtual QVariant::Type getType(const QString& str);
+
     QSqlQuery query;
     QSqlDatabase db;
+    QHash<QString, IDbTable *> _dbStruct;
 
 
 public:

ClientProtocol/streambase.h

@@ -4,7 +4,7 @@
 #include <QByteArray>
 #include "clientprotocol_global.h"
 
-
+class QVariantMap;
 class QDataStream;
 namespace ClientProtocol {
 
@@ -42,6 +42,20 @@ public:
      */
     virtual QDataStream& toStream(QDataStream& stream) const = 0;
 
+    /**
+     * @brief fromVariantMap
+     * @param map
+     * @return
+     */
+    virtual QVariantMap& fromVariantMap(QVariantMap& map) = 0;
+
+    /**
+     * @brief toVariantmap
+     * @param map
+     * @return
+     */
+    virtual QVariantMap& toVariantmap(QVariantMap& map) const = 0;
+
 };
 }
 #endif // STREAMBASE_H