commit 81c23b56b61ddaaf7faef6f303dcfbfdd3479602 Author: Christian Ehringfeld Date: Thu Mar 19 14:45:00 2015 +0100 init diff --git a/EntityManager.pro b/EntityManager.pro new file mode 100644 index 0000000..f1147cf --- /dev/null +++ b/EntityManager.pro @@ -0,0 +1,34 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2013-08-01T15:03:24 +# +#------------------------------------------------- + +QT += core +QT += sql + +QT -= gui + +TARGET = EntityManager +CONFIG += console +CONFIG -= app_bundle + +TEMPLATE = app + + +HEADERS += \ +src/base/entity.h \ + src/base/entitymanager.h \ + src/base/enums/persistencetype.h \ + src/base/database.h \ + src/base/enums/databasetype.h \ + src/models/artikel.h \ + src/base/enums/relationtype.h \ + src/base/relation.h + +SOURCES += main.cpp \ +src/base/entity.cpp \ + src/base/entitymanager.cpp \ + src/base/database.cpp \ + src/models/artikel.cpp \ + src/base/relation.cpp diff --git a/example/models/artikel.cpp b/example/models/artikel.cpp new file mode 100644 index 0000000..28f270c --- /dev/null +++ b/example/models/artikel.cpp @@ -0,0 +1,78 @@ +/* + Small test class + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#include "artikel.h" +namespace OpenTeacherTool { + +Artikel::Artikel() +{ +} + +Artikel::Artikel(double preis, QString name) { + this->preis = preis; + this->name = name; +} + +QHash Artikel::getProperties(DatabaseType type) { + QHash h = QHash(); + h.insert("id",this->idColumnSQL()); + h.insert("preis","DOUBLE"); + h.insert("name","TEXT"); + return h; +} + +PersistenceType Artikel::getPersistenceType() { + return OpenTeacherTool::LOCAL; +} + +QHash *Artikel::getRelations() { + return this->relations; +} + +QHash *Artikel::getAttributeValues() { + this->attributeValues->insert("id",this->id); + this->attributeValues->insert("name",this->name); + this->attributeValues->insert("preis",this->preis); + return this->attributeValues; +} + +void Artikel::setAttributes(QHash h) { + this->id = h.value("id").toInt(); + this->name = h.value("name").toString(); + this->preis = h.value("preis").toDouble(); +} + +QString Artikel::getTablename() { + return "artikel"; +} + +void Artikel::setPreis(double preis) { + this->preis = preis; +} + +void Artikel::setName(QString name) { + this->name = name; +} + +Artikel::~Artikel() { + +} + +} diff --git a/example/models/artikel.h b/example/models/artikel.h new file mode 100644 index 0000000..1a9502c --- /dev/null +++ b/example/models/artikel.h @@ -0,0 +1,48 @@ +/* + Small test class + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#ifndef ARTIKEL_H +#define ARTIKEL_H +#include "src/base/entity.h" +#include +#include + +namespace OpenTeacherTool { +class Artikel : public Entity +{ +private: + double preis; + QString name; + +public: + ~Artikel(); + QHash getProperties(DatabaseType type); + PersistenceType getPersistenceType(); + QHash* getRelations(); + QHash* getAttributeValues(); + void setAttributes(QHash h); + QString getTablename(); + void setPreis(double preis); + void setName(QString name); + Artikel(); + Artikel(double preis, QString name); +}; +} +#endif // ARTIKEL_H diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..0bf888f --- /dev/null +++ b/main.cpp @@ -0,0 +1,32 @@ +#include +#include "src/base/entity.h" +#include "src/models/artikel.h" +#include "src/base/entitymanager.h" +#include +#include +#include +/** + * create,remove und merge funktionieren + */ + +int main(int argc, char *argv[]) +{ + OpenTeacherTool::EntityManager *e = new OpenTeacherTool::EntityManager("QSQLITE",QDir::currentPath() + "/db.sqlite"); + + OpenTeacherTool::Artikel *b= new OpenTeacherTool::Artikel(30,"Peter123"); + OpenTeacherTool::Entity *entity = b->getEntity(); + qDebug() << "findByAttributes:" << e->findByAttributes(entity,true); + qDebug() << "create:" << e->create(entity); + qDebug() << "findAll:" << e->findAll(entity->getTablename()); + entity->setAttributes(e->findByAttributes(entity,true).at(0)); + qDebug() << "AttributeValues, Artikel:" << *b->getAttributeValues(); + b->setName("Peter"); + b->setPreis(20); + e->remove(entity); + qDebug() << "TypID:" << typeid(entity).name(); + qDebug() << entity->getId(); + qDebug() << "merge:" << e->merge(entity); + delete entity; + + return 0; +} diff --git a/src/database.cpp b/src/database.cpp new file mode 100644 index 0000000..346993f --- /dev/null +++ b/src/database.cpp @@ -0,0 +1,324 @@ +/* + Database Class for managing a database connection + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#include "database.h" +namespace OpenTeacherTool { + +Database::Database(QSqlDatabase database) { + this->database = database; + this->init(); + this->connectionName = this->database.connectionName(); + +} + +Database::Database(QString databaseType, QString connectionName, QString databasename) { + this->database = QSqlDatabase::addDatabase(databaseType,connectionName); + this->connectionName = connectionName; + this->database.setDatabaseName(databasename); + this->init(); +} + +Database::Database(QString databaseType, QString connectionName, QString hostname, QString databasename, QString username, QString password, qint64 port) { + this->database = QSqlDatabase::addDatabase(databaseType,connectionName); + this->connectionName = connectionName; + this->database.setHostName(hostname); + this->database.setDatabaseName(databasename); + this->database.setUserName(username); + this->database.setPassword(password); + this->database.setPort(port); + this->init(); +} + +void Database::init() { + this->database.open(); + this->databasetype = this->getDatabaseType(); + this->supportTransactions = this->database.driver()->hasFeature(QSqlDriver::Transactions); + this->tableList = new QStringList(); + this->getTableListFromDatabase(); + this->createSequenceTable(); +} + + +DatabaseType Database::getDatabaseType() { + QString d = this->database.driverName(); + if(d == "qmysql") { + return OpenTeacherTool::MYSQL; + } else if(d == "qpgsql") { + return OpenTeacherTool::PGSQL; + } else { + return OpenTeacherTool::SQLITE; + } +} + +void Database::getTableListFromDatabase() { + if(this->database.open()) { + QString q = ""; + if(this->databasetype == OpenTeacherTool::SQLITE) { + q = this->sqliteTableList(); + } else if(this->databasetype == OpenTeacherTool::MYSQL){ + q = this->mysqlTableList(); + } else if(this->databasetype == OpenTeacherTool::PGSQL) { + q = this->pgsqlSeqTable(); + } + QSqlQuery query = QSqlQuery(this->database); + query.prepare(q); + this->select(query); + this->setTableList(query); + } +} + +void Database::setTableList(QSqlQuery &q) { + while(q.next()) { + this->tableList->append(q.value(0).toString()); + } +} + + +QString Database::sqliteTableList() { + return "SELECT tbl_name FROM sqlite_master WHERE type='table';"; +} + +QString Database::mysqlTableList() { + return "SHOW TABLES;"; +} + +QString Database::pgsqlTableList() { + return "SELECT table_name FROM information_schema.tables WHERE table_catalog = '"+this->database.databaseName()+"';"; +} + +Database::~Database() { + if(this->database.isOpen()) { + this->database.close(); + } + QSqlDatabase::removeDatabase(this->connectionName); + delete this->tableList; +} + +QString Database::getConnectionName() { + return this->connectionName; +} + +void Database::setSeqTable(bool seqTable) { + this->seqTable = seqTable; +} + +bool Database::isSeqTable() { + return this->seqTable; +} + +QString Database::pgsqlSeqTable() { + return "CREATE TABLE IF NOT EXISTS sequence (SEQ_NAME varchar(255) NOT NULL UNIQUE , SEQ_COUNT bigint NOT NULL);"; +} + +QString Database::mysqlSeqTable() { + return "CREATE TABLE IF NOT EXISTS `sequence` (`SEQ_NAME` varchar(255) NOT NULL UNIQUE , `SEQ_COUNT` bigint(20) unsigned NOT NULL) CHARSET = utf8"; +} + +QString Database::sqliteSeqTable() { + return "CREATE TABLE IF NOT EXISTS \"sequence\" (\"SEQ_NAME\" TEXT PRIMARY KEY NOT NULL , \"SEQ_COUNT\" INTEGER NOT NULL );"; +} + +QChar Database::escapeChar() { + QChar c = QChar(); + if(this->databasetype == OpenTeacherTool::SQLITE) { + c = '\''; + } else if(this->databasetype == OpenTeacherTool::MYSQL) { + c = '`'; + } + return c; +} + + +bool Database::transaction(const QString &query) { + bool rc = false; + if(supportTransactions) { + this->database.transaction(); + QSqlQuery sqlquery = QSqlQuery(this->database); + sqlquery.exec(query); + if(!this->database.commit()) { + this->database.rollback(); + } + } else { + rc = this->exec(query); + } + return rc; +} + +QSqlQuery Database::getQuery() { + return QSqlQuery(this->database); +} + +QSqlQuery Database::getQuery(const QString &prepare) { + QSqlQuery q = QSqlQuery(this->database); + q.prepare(prepare); + return q; +} + +bool Database::transaction(const QStringList &queries) { + bool ok = false; + if(this->supportTransactions) { + this->database.transaction(); + QSqlQuery sqlquery = QSqlQuery(this->database); + for (int var = 0; var < queries.size(); ++var) { + sqlquery.exec(queries.at(var)); + } + if(!this->database.commit()) { + this->database.rollback(); + } else { + ok = true; + } + } else { + ok = this->exec(queries); + } + return ok; +} + +bool Database::transaction(QSqlQuery &query) { + this->database.transaction(); + query.exec(); + if(!this->database.commit()) { + this->database.rollback(); + return false; + } + return true; +} + +bool Database::transaction(QList &queries) { + this->database.transaction(); + QSqlQuery q; + for (int var = 0; var < queries.size(); ++var) { + q = queries.at(var); + q.exec(); + } + if(!this->database.commit()) { + this->database.rollback(); + return false; + } + return true; +} + +bool Database::exec(QString query) { + this->database.transaction(); + QSqlQuery q = QSqlQuery(this->database); + q.exec(query); + if(!this->database.commit()) { + this->database.rollback(); + return false; + } + return true; +} + +bool Database::exec(QStringList queries){ + QSqlQuery q = QSqlQuery(this->database); + bool ok = true; + for (int var = 0; var < queries.size() && ok; ++var) { + ok = q.exec(queries.at(var)); + if(!ok) { + break; + } + } + return ok; +} + +bool Database::exec(QSqlQuery query) { + return query.exec(); +} + +bool Database::exec(QList queries) { + bool ok = true; + QSqlQuery q = QSqlQuery(this->database); + for (int var = 0; var < queries.size() && ok; ++var) { + q = queries.at(var); + ok = q.exec(); + if(!ok) { + break; + } + } + return ok; +} + +bool Database::select(QSqlQuery &query) { + query.setForwardOnly(true); + return query.exec(); +} + +QSqlQuery Database::select(const QString &query) { + QSqlQuery q = QSqlQuery(this->database); + q.exec(query); + return q; +} + +QString Database::querySequenceCounter() { + return "INSERT INTO sequence (SEQ_NAME, SEQ_COUNT) VALUES(\'id_count\',\'0\');"; +} + +void Database::refreshTableList() { + this->tableList->clear(); + this->getTableListFromDatabase(); +} + +bool Database::containsTable(QString tblname) { + return this->tableList->contains(tblname); +} + +void Database::createSequenceTable() { + if(this->database.open() && this->getLastId() == -1) { + QString query = ""; + QStringList l = QStringList(); + if(this->databasetype == OpenTeacherTool::MYSQL) { + query = this->mysqlSeqTable(); + } else if(this->databasetype == OpenTeacherTool::SQLITE) { + query = this->sqliteSeqTable(); + } else if(this->databasetype == OpenTeacherTool::PGSQL) { + query = this->pgsqlSeqTable(); + } + l.append(query); + l.append(this->querySequenceCounter()); + if(this->transaction(l)) { + this->setSeqTable(true); + } else { + this->setSeqTable(false); + } + } else { + this->setSeqTable(true); + } +} + +bool Database::updateSequenceCounter(QSqlQuery &q) { + QList l = QList(); + l.append(QSqlQuery("UPDATE sequence SET SEQ_COUNT=(SEQ_COUNT+1);",this->database)); + l.append(q); + return this->transaction(l); +} + +qint64 Database::getLastId() { + qint64 id = -1; + QSqlQuery q = this->select("SELECT SEQ_COUNT FROM sequence WHERE SEQ_NAME=\'id_count\';"); + if(q.next()) { + id = q.value(0).toInt(); + } + return id; +} + +QSqlDatabase Database::getDatabase() { + return this->database; +} + +} diff --git a/src/database.h b/src/database.h new file mode 100644 index 0000000..f895f2b --- /dev/null +++ b/src/database.h @@ -0,0 +1,88 @@ +/* + Header File Database + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#ifndef DATABASE_H +#define DATABASE_H +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "enums/databasetype.h" +namespace OpenTeacherTool { + +class Database +{ +private: + QSqlDatabase database; + QString connectionName; + bool seqTable; + DatabaseType databasetype; + bool supportTransactions; + void setSeqTable(bool seqTable); + void init(); + void createSequenceTable(); + QString querySequenceCounter(); + QStringList *tableList; + +protected: + inline QString pgsqlSeqTable(); + inline QString mysqlSeqTable(); + inline QString sqliteSeqTable(); + inline QString sqliteTableList(); + inline QString mysqlTableList(); + inline QString pgsqlTableList(); + +public: + Database(QSqlDatabase database); + ~Database(); + Database(QString databaseType, QString databasename); + Database(QString databaseType, QString connectionName, QString databasename); + Database(QString databaseType, QString connectionName= "", QString hostname="",QString databasename = "" , QString username ="", QString password="", qint64 port=0); + QSqlDatabase getDatabase(); + QString getConnectionName(); + QSqlQuery getQuery(); + QSqlQuery getQuery(const QString &prepare); + bool transaction(const QString &query); + bool transaction(const QStringList &queries); + bool transaction(QSqlQuery &query); + bool transaction(QList &queries); + bool exec(QString query); + bool exec(QStringList queries); + bool exec(QSqlQuery query); + bool exec(QList queries); + bool select(QSqlQuery &query); + QSqlQuery select(const QString &query); + bool isSeqTable(); + qint64 getLastId(); + void getTableListFromDatabase(); + void setTableList(QSqlQuery &q); + void refreshTableList(); + bool containsTable(QString tblname); + bool updateSequenceCounter(QSqlQuery &q); + DatabaseType getDatabaseType(); + QChar escapeChar(); +}; +} +#endif // DATABASE_H diff --git a/src/entity.cpp b/src/entity.cpp new file mode 100644 index 0000000..19f2e10 --- /dev/null +++ b/src/entity.cpp @@ -0,0 +1,70 @@ +/* + Base class for all models + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#include "entity.h" + +namespace OpenTeacherTool { + +Entity::Entity() { + this->id = -1; + this->relations = new QHash(); + this->attributeValues = new QHash(); +} + +qint64 Entity::getId() { + return this->id; +} + +void Entity::setId(qint64 id) { + this->id = id; +} + +Entity::~Entity() { + delete this->relations; + delete this->attributeValues; +} + +Entity* Entity::getEntity() { + return this; +} + +QString Entity::idColumnSQL() { + return "id BIGINT NOT NULL"; +} + +//QHash OpenTeacherTool::Entity::getProperties(Datebasetype t) { +// QMap map = QMap(); +// map.insert("id",this->idColumnSQL()); +// return map; +//} + +//OpenTeacherTool::PersistenceType OpenTeacherTool::Entity::getPersistenceType() { +// OpenTeacherTool::PersistenceType type = SQLITE; +// return type; +//} + +//QMap OpenTeacherTool::Entity::getRelations() { +// QMap map; +// return map; +//} + + + +} diff --git a/src/entity.h b/src/entity.h new file mode 100644 index 0000000..c3d1c6f --- /dev/null +++ b/src/entity.h @@ -0,0 +1,53 @@ +/* + Header File Entity + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#ifndef MODEL_H +#define MODEL_H +#include +#include +#include +#include "enums/persistencetype.h" +#include "enums/databasetype.h" +namespace OpenTeacherTool { + +class Entity +{ +public: + qint64 getId(); + void setId(qint64 id); + Entity* getEntity(); + void addAttributeVal(const QString name, QVariant *var); + virtual ~Entity(); + virtual QHash getProperties(DatabaseType type) = 0; + virtual PersistenceType getPersistenceType() = 0; + virtual QHash* getRelations() = 0; + virtual QHash* getAttributeValues() = 0; + virtual void setAttributes(QHash) = 0; + virtual QString getTablename() = 0; + virtual QString idColumnSQL(); + // virtual QMap getManyToManyRelations() = 0; //Key = Table, Value = joined Table Column +protected: + Entity(); + qint64 id; + QHash *attributeValues; + QHash *relations; +}; +} +#endif // MODEL_H diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp new file mode 100644 index 0000000..6d594ae --- /dev/null +++ b/src/entitymanager.cpp @@ -0,0 +1,300 @@ +/* + Entity Manager for crud operations of entities + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#include "entitymanager.h" + +/** + * Relationen fehlen noch + * Fehlermeldungen erstellen am besten eine Exception Klasse diesbzgl. erstellen + */ + +namespace OpenTeacherTool { + + +QStringList EntityManager::connectionNames = QStringList(); + +EntityManager::EntityManager(QSqlDatabase database) { + this->db = new Database(database); +} + +EntityManager::EntityManager(const QString &databaseType,QString databasename , QString hostname,QString username, QString password, QString port) { + this->db = new Database(databaseType,this->createConnection(),hostname,databasename,username,password,port.toInt()); +} + +inline bool EntityManager::checkTable(Entity *entity) { + bool rc = true; + if(!this->db->containsTable(entity->getTablename())) { + qDebug() << "Tabelle" << entity->getTablename() << "existiert noch nicht."; + if(this->createTable(entity)) { + this->db->refreshTableList(); + rc = this->db->containsTable(entity->getTablename()); + } + } + return rc; +} + +QString EntityManager::createConnection() { + QStringList l = EntityManager::getConnectionNames(); + QString conName = ""; + bool ok = false; + qint16 i = 0; + while(!ok) { + if(l.contains("con"+QString::number(i))) { + ++i; + } else { + l.append("con"+QString::number(i)); + ok = true; + conName = "con"+QString::number(i); + EntityManager::setConnectionNames(l); + } + } + return conName; +} + +void EntityManager::removeConnectionName(const QString &name) { + EntityManager::connectionNames.removeOne(name); +} + +EntityManager::~EntityManager() { + EntityManager::removeConnectionName(this->db->getConnectionName()); + delete db; +} + +QStringList EntityManager::getConnectionNames() { + return EntityManager::connectionNames; +} + +void EntityManager::setConnectionNames(QStringList list) { + EntityManager::connectionNames = list; +} + +void EntityManager::bindValues(const QHash *h, QSqlQuery &q, bool ignoreID) { + QHash::const_iterator i = h->constBegin(); + while(i != h->constEnd()) { + if(!ignoreID || (ignoreID && !(i.key() == "id"))) { + q.bindValue(":"+i.key(),i.value()); + } + ++i; + } +} + +qint8 EntityManager::count(Entity* entity, bool ignoreID) { + qint8 rc = 0; + QSqlQuery q = this->db->getQuery("SELECT COUNT(*) FROM " + entity->getTablename() + this->where(entity->getAttributeValues(),"AND",ignoreID)); + this->bindValues(entity->getAttributeValues(),q); + this->db->select(q); + if(q.next()) { + rc = q.value(0).toInt(); + } + return rc; +} + +QString EntityManager::buildCreateQuery(QHash::const_iterator i, QHash::const_iterator end, QString &p1, QString &p2) { + bool first = true; + while(i != end) { + if(!first) { + p1 += ","; + p2 += ","; + } else { + first = false; + } + p1 += i.key(); + p2 += ":"+i.key(); + ++i; + } + p1 += ")"; + p2 += ");"; + return p1 + p2; +} + +bool EntityManager::create(Entity *entity) { + bool rc = false; + if(this->checkTable(entity) && this->count(entity) == 0) { + QSqlQuery q = this->db->getQuery(); + QString p1 = "INSERT INTO " + entity->getTablename() + "("; + QString p2 = "VALUES("; + entity->setId(this->db->getLastId()); + if(!entity->getAttributeValues()->isEmpty()) { + q.prepare(this->buildCreateQuery(entity->getAttributeValues()->constBegin(),entity->getAttributeValues()->constEnd(),p1,p2)); + } + this->bindValues(entity->getAttributeValues(),q); + if(this->db->updateSequenceCounter(q)) { + entity->setId(this->findId(entity)); + rc = true; + } + } + return rc; +} + +QHash EntityManager::find(qint64 id, QString tblname) { + QSqlQuery q = this->db->getQuery("SELECT * FROM " + tblname +" WHERE id= :id LIMIT 1;"); + q.bindValue(":id",id); + this->db->select(q); + QSqlRecord rec = q.record(); + QHash map = QHash(); + if(q.next()) { + for (int var = 0; var < rec.count(); ++var) { + map.insert(rec.fieldName(var),q.value(rec.indexOf(rec.fieldName(var)))); // parameters of q.value can maybe replaced with var + } + } + return map; +} + +QList > EntityManager::findByAttributes(QHash *m, const QString &tblname, bool ignoreID) { + QSqlQuery q = this->db->getQuery("SELECT * FROM " + tblname + this->where(m,"AND",ignoreID)); + this->bindValues(m,q,true); + return this->convertQueryResult(q); +} + +QList > EntityManager::convertQueryResult(QSqlQuery &q) { + QList > listmap = QList >(); + this->db->select(q); + QSqlRecord rec = q.record(); + QStringList l = QStringList(); + qint16 field_count = rec.count(); + for (int var = 0; var < field_count; ++var) { + l.append(rec.fieldName(var)); + } + QHash map = QHash(); + while(q.next()) { + for (int var = 0; var < field_count; ++var) { + map.insert(l.at(var),q.value(rec.indexOf(l.at(var)))); + } + listmap.append(map); + } + return listmap; +} + +QList > EntityManager::findAll(QString tblname) { + QSqlQuery q =this->db->getQuery("SELECT * FROM " + tblname + ";"); + return this->convertQueryResult(q); +} + +bool EntityManager::merge(Entity *entity) { + if(this->count(entity) == 0 && entity->getId() != -1) { + QSqlQuery q = this->db->getQuery("UPDATE " + entity->getTablename() + " SET " +this->attributes(entity->getAttributeValues()) + " WHERE id=:idM;"); + this->bindValues(entity->getAttributeValues(),q); + q.bindValue(":idM",entity->getId()); + return this->db->transaction(q); + } else { + return false; + } +} + + +qint64 EntityManager::findId(Entity *entity) { + qint64 r = -1; + QSqlQuery q = this->db->getQuery("SELECT id FROM " + entity->getTablename() + this->where(entity->getAttributeValues(),"AND",true) + " LIMIT 1"); + this->bindValues(entity->getAttributeValues(),q); + this->db->select(q); + if(q.next()) { + r = q.value(0).toInt(); + } + return r; +} + +QString EntityManager::attributes(QHash *m, QString conjunction, bool ignoreID) { + QString rc = ""; + if(!m->isEmpty()) { + QHash::const_iterator i = m->constBegin(); + while(i != m->constEnd()) { + if(!ignoreID || (ignoreID && !(i.key() == "id"))) { + if(!(rc == "")) { + rc += " " + conjunction + " "; + } + rc += i.key() + "= :" +i.key(); + } + ++i; + } + } + return rc; +} + + +QString EntityManager::where(QHash *m, QString conjunction, bool ignoreID) { + if(m->size() == 0 || (ignoreID && m->contains("id") && m->size() == 1)) { + return ""; + } + return " WHERE " + this->attributes(m,conjunction,ignoreID); +} + +QString EntityManager::where(Entity *entity, QString conjunction, bool ignoreID) { + return this->where(entity->getAttributeValues(),conjunction,ignoreID); +} + +QList > EntityManager::findByAttributes(Entity *entity, bool ignoreID) { + return this->findByAttributes(entity->getAttributeValues(), entity->getTablename(),ignoreID); +} + +bool EntityManager::save(Entity *entity) { + if(entity->getId() > -1) { + return this->merge(entity); + } else { + return this->create(entity); + } +} + + +bool EntityManager::remove(Entity *&entity) { + bool rc = false; + QSqlQuery q = this->db->getQuery("DELETE FROM " + entity->getTablename() + " WHERE id= :id;"); + q.bindValue(":id",entity->getId()); + if(this->db->transaction(q)) { + delete entity; + entity = 0; + rc = true; + } + return rc; +} + +QString EntityManager::createTableQuery(Entity *entity) { + QChar c = this->db->escapeChar(); + QHash m = entity->getProperties(this->db->getDatabaseType()); + bool first = true; + QString s = "CREATE TABLE IF NOT EXISTS "; + s.append(c).append(entity->getTablename()).append(c).append("("); + QHash::const_iterator i = m.constBegin(); + while (i != m.constEnd()) { + if(first) { + first = false; + } else { + s.append(','); + } + s.append(c).append(i.key()).append(c).append(" " + i.value()); + ++i; + } + s.append(");"); + return s; +} + +bool EntityManager::createTable(Entity *entity) { + bool rc = false; + this->db->containsTable(entity->getTablename()) ? rc = true : rc = false; + if(!rc) { + QSqlQuery q = this->db->getQuery(this->createTableQuery(entity)); + if(this->db->transaction(q)) { + this->db->refreshTableList(); + rc = true; + } + } + return rc; +} + +} diff --git a/src/entitymanager.h b/src/entitymanager.h new file mode 100644 index 0000000..fba157c --- /dev/null +++ b/src/entitymanager.h @@ -0,0 +1,73 @@ +/* + Header File Entity Manager + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#ifndef ENTITYMANAGER_H +#define ENTITYMANAGER_H +#include +#include +#include +#include +#include +#include +#include +#include "entity.h" +#include "database.h" + +namespace OpenTeacherTool { + +class EntityManager +{ +private: + static QStringList connectionNames; + static void setConnectionNames(QStringList list); + Database *db; + QString createConnection(); + QString createTableQuery(Entity *entity); + QString attributes(QHash *m, QString conjunction=",", bool ignoreID = false); + QList > convertQueryResult(QSqlQuery &q); + bool checkTable(Entity *entity); + QString buildCreateQuery(QHash::const_iterator i, QHash::const_iterator end,QString &p1, QString &p2); + void bindValues(const QHash *h, QSqlQuery &q, bool ignoreID = false); + +protected: + QString where(Entity *entity,QString conjunction=",",bool ignoreID = false); + QString where(QHash *m,QString conjunction=",", bool ignoreID = false); + +public: + EntityManager(QSqlDatabase database); + EntityManager(const QString &databaseType, QString databasename = "" , QString hostname="", QString username ="", QString password="", QString port=""); + ~EntityManager(); + static QStringList getConnectionNames(); + static void removeConnectionName(const QString &name); + bool create(Entity *entity); + bool save(Entity *entity); + qint64 findId(Entity *entity); + QList > findAll(QString tblname); + QHash find(qint64 id, QString tblname); + QList > findByAttributes(Entity *entity,bool ignoreID = false); + QList > findByAttributes(QHash *m, const QString &tblname, bool ignoreID = false); + bool merge(Entity *entity); + bool remove(Entity *&entity); + bool removeAll(QString tblname); + bool createTable(Entity *entity); + qint8 count(Entity* entity, bool ignoreID= true); +}; +} +#endif // ENTITYMANAGER_H diff --git a/src/enums/databasetype.h b/src/enums/databasetype.h new file mode 100644 index 0000000..154ad69 --- /dev/null +++ b/src/enums/databasetype.h @@ -0,0 +1,31 @@ +/* + Enum DatabaseType + Copyright (C) 2013 Christian Ehringfeld + + This file is part of OpenTeacherTool. + + OpenTeacherTool is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenTeacherTool is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with OpenTeacherTool. If not, see . +*/ + +#ifndef DATABASETYPE_H +#define DATABASETYPE_H + +namespace OpenTeacherTool { + enum DatabaseType { + SQLITE=0, + PGSQL=1, + MYSQL=2 + }; +} +#endif // DATABASETYPE_H diff --git a/src/enums/persistencetype.h b/src/enums/persistencetype.h new file mode 100644 index 0000000..9c6b78c --- /dev/null +++ b/src/enums/persistencetype.h @@ -0,0 +1,47 @@ +/* + OpenTeacherTool, a platform independent tool for schoolteacher + Copyright (C) 2013 Yves Bodenheimer, Christian Ehringfeld, David Mock + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef PERSISTENCETYPE_H +#define PERSISTENCETYPE_H +#include +#include +#include + +namespace OpenTeacherTool { +enum PersistenceType { + LOCAL=0, + XML=1, + REMOTEDATABASE=2 +}; + +static QMap initMap() { + QMap map; + map[LOCAL] = QObject::tr("LocalDatabase"); + map[XML] = QObject::tr("XMLFile"); + map[REMOTEDATABASE] = QObject::tr("RemoteDatabase"); + return map; +} + +static QString toString(const PersistenceType &type) { + static QMap map = initMap(); + return map[type]; +} + +} + +#endif // PERSISTENCETYPE_H diff --git a/src/enums/relationtype.h b/src/enums/relationtype.h new file mode 100644 index 0000000..7aebc33 --- /dev/null +++ b/src/enums/relationtype.h @@ -0,0 +1,34 @@ +/* + OpenTeacherTool, a platform independent tool for schoolteacher + Copyright (C) 2013 Yves Bodenheimer, Christian Ehringfeld, David Mock + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef RELATIONTYPE_H +#define RELATIONTYPE_H + +namespace OpenTeacherTool{ + +enum Relationtype { + ONETOONE=0, + ONETOMANY=1, + MANYTOONE=2, + MANYTOMANY=3 +}; + +} + + +#endif // RELATIONTYPE_H diff --git a/src/relation.cpp b/src/relation.cpp new file mode 100644 index 0000000..95b1f72 --- /dev/null +++ b/src/relation.cpp @@ -0,0 +1,28 @@ +/* + OpenTeacherTool, a platform independent tool for schoolteacher + Copyright (C) 2013 Yves Bodenheimer, Christian Ehringfeld, David Mock + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "relation.h" + +namespace OpenTeacherTool { + +Relation::Relation() +{ +} + + +} diff --git a/src/relation.h b/src/relation.h new file mode 100644 index 0000000..5ca959f --- /dev/null +++ b/src/relation.h @@ -0,0 +1,34 @@ +/* + OpenTeacherTool, a platform independent tool for schoolteacher + Copyright (C) 2013 Yves Bodenheimer, Christian Ehringfeld, David Mock + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef RELATION_H +#define RELATION_H +#include "entity.h" +#include "src/base/enums/relationtype.h" +namespace OpenTeacherTool { + +class Relation +{ +public: + Relation(); +private: + Entity* foreignEntity; + OpenTeacherTool::Relationtype Relationtype; +}; +} +#endif // RELATION_H