commit e5a0d313053dddd7b78f8c9a2a8bb864bd681249
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Tue Oct 13 00:04:01 2015 +0200

    bugfix

diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index a390f84..796dbc1 100644
--- a/src/entitymanager.cpp
+++ b/src/entitymanager.cpp
@@ -30,7 +30,7 @@ using namespace CuteEntityManager;
 QStringList EntityManager::connectionNames = QStringList();
 
 QHash<QString, EntityManager *> EntityManager::instances =
-    QHash<QString, EntityManager *>();
+        QHash<QString, EntityManager *>();
 
 QStringList EntityManager::getConnectionNames() {
     return EntityManager::connectionNames;
@@ -46,10 +46,10 @@ EntityManager::EntityManager(QSqlDatabase database, bool logQueries,
 void EntityManager::init(bool inspect, const MsgType msgType) {
     EntityInstanceFactory::registerClass<DatabaseMigration>();
     this->schema = QSharedPointer<Schema>(Database::getSchema(Database::getDatabaseType(
-                                          this->db->getDatabase().driverName()), this->db));
+                                                                  this->db->getDatabase().driverName()), this->db));
     this->schema->setTables(this->schema->getTableSchemas());
     this->queryInterpreter = QSharedPointer<QueryInterpreter>(new QueryInterpreter(
-                                 this->schema->getQueryBuilder().data()));
+                                                                  this->schema->getQueryBuilder().data()));
     this->appendToInstanceList();
     if (inspect) {
         EntityInspector inspector = EntityInspector(msgType);
@@ -59,7 +59,7 @@ void EntityManager::init(bool inspect, const MsgType msgType) {
     loggerFile.replace("[", "");
     loggerFile.replace("]", "");
     this->logger = QSharedPointer<Logger>(new Logger(QDir::currentPath() + "/" +
-                                          loggerFile, msgType));
+                                                     loggerFile, msgType));
 }
 
 EntityManager::EntityManager(const QString &databaseType, QString databasename,
@@ -114,7 +114,7 @@ bool EntityManager::mergeObject(QSharedPointer<Entity> &entity,
             }
             this->db->startTransaction();
             QList<QSqlQuery> q = this->schema->getQueryBuilder()->merge(
-                                     entity);
+                        entity);
             ok = this->db->exec(q);
 
             if (!ok || !this->db->commitTransaction()) {
@@ -138,14 +138,14 @@ bool EntityManager::createObject(QSharedPointer<Entity> &entity,
         mergedObjects.append(entity.data());
         rc = false;
         if (this->checkTable(entity) && (!validate || this->validate(entity))
-                && !(checkDuplicate && this->count(entity) > 0)) {
+                && (!checkDuplicate || this->count(entity) <= 0)) {
             if (persistRelations) {
                 this->savePrePersistedRelations(entity, mergedObjects,
                                                 relationsIgnoreHasChanged);
             }
             this->db->startTransaction();
             QList<QSqlQuery> q = this->schema->getQueryBuilder()->create(
-                                     entity);
+                        entity);
             bool first = true;
             QVariant id = -1;
             for (int var = 0; var < q.size(); ++var) {
@@ -200,19 +200,13 @@ bool EntityManager::create(QSharedPointer<Entity> &entity,
 }
 
 bool EntityManager::create(QList<QSharedPointer<Entity> > &entities,
-                           const bool persistRelations, const bool validate,
-                           const bool relationsIgnoreHasChanged, const bool checkDuplicate) {
+                           const bool persistRelations, const bool checkDuplicate, const bool validate,
+                           const bool relationsIgnoreHasChanged) {
     bool ok = true;
     auto merged = QList<Entity *>();
     foreach (QSharedPointer<Entity> ent, entities) {
-        ok = this->createObject(ent, merged, persistRelations,
-                                checkDuplicate, validate, relationsIgnoreHasChanged);
-        if (!ok) {
-            break;
-            this->logger->logMsg("Object " + QString::number(ent->getId()) + " of class  " +
-                                 EntityHelper::getClassName(ent.data()) + " couldn't created!",
-                                 MsgType::WARNING);
-        }
+        this->createObject(ent, merged, persistRelations,
+                           checkDuplicate, validate, relationsIgnoreHasChanged);
     }
     return ok;
 }
@@ -247,7 +241,7 @@ bool EntityManager::save(QList<QSharedPointer<Entity> > &entities,
 bool EntityManager::startup(QString version, QStringList toInitialize,
                             bool createIndices) {
     QSharedPointer<Entity> dbm = QSharedPointer<DatabaseMigration>
-                                 (new DatabaseMigration());
+            (new DatabaseMigration());
     QHash<QString, QVariant> map = QHash<QString, QVariant>();
     bool ok = true;
     map.insert("version", version);
@@ -260,14 +254,14 @@ bool EntityManager::startup(QString version, QStringList toInitialize,
             if (ok) {
                 QString c = toInitialize.at(var);
                 auto entity = QSharedPointer<Entity>
-                              (EntityInstanceFactory::createInstance(c));
+                        (EntityInstanceFactory::createInstance(c));
                 ok = this->createTable(entity, false);
                 entities.append(entity);
             } else {
                 this->logger->logMsg("startup of version " + version + " failed",
                                      MsgType::CRITICAL);
                 this->logger->logMsg( "erroneous entity:" + (var == 0 ?
-                                      "null, this should not happen!" : toInitialize.at(var - 1)), MsgType::CRITICAL);
+                                                                 "null, this should not happen!" : toInitialize.at(var - 1)), MsgType::CRITICAL);
                 break;
             }
         }
@@ -336,7 +330,7 @@ QList<QHash<QString, QVariant> > EntityManager::selectByQuery(Query &query) {
 }
 
 QList<QHash<QString, QVariant> > EntityManager::selectBySql(
-    const QString &sql) {
+        const QString &sql) {
     QSqlQuery q = this->db->select(sql);
     return this->convertQueryResult(q);
 }
@@ -347,12 +341,12 @@ bool EntityManager::validate(QSharedPointer<Entity> &entity) {
     for (int i = 0; i < rules.size(); ++i) {
         ValidationRule rule = rules.at(i);
         QSharedPointer<Validator> validator = ValidatorFactory::getValidatorObject(
-                rule.getValidatorName());
+                    rule.getValidatorName());
         if (validator) {
             for (int var = 0; var < rule.getAttributes().size(); ++var) {
                 QString attr = rule.getAttributes().at(var);
                 QList<ErrorMsg> msgs = validator->validate(entity->getProperty(attr),
-                                       rule.getParams());
+                                                           rule.getParams());
                 for (int i = 0; i < msgs.size(); ++i) {
                     QString emsg = msgs.at(i).getErrorMsg().replace("<property>", attr);
                     ErrorMsg m = msgs.at(i);
@@ -383,10 +377,10 @@ bool EntityManager::hasChanged(QSharedPointer<Entity> &entity) {
         for (auto i = listmap.constBegin(); i != listmap.constEnd(); ++i) {
             if (rels.contains(i.key())) {
                 QString appendix =
-                    this->schema->getQueryBuilder()->columnNameIDAppendix();
+                        this->schema->getQueryBuilder()->columnNameIDAppendix();
                 QString relKey = i.key();
                 QVariant v = entity->getProperty(relKey.remove(relKey.size() - appendix.size(),
-                                                 appendix.size()));
+                                                               appendix.size()));
                 if (!v.isNull()) {
                     auto entity = EntityInstanceFactory::castQVariant(v);
                     if (entity->getProperty(entity->getPrimaryKey()) != i.value()) {
@@ -429,8 +423,8 @@ void EntityManager::removeConnectionName(const QString &name) {
 }
 
 QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
-        QSharedPointer<Entity> &e,
-        const bool refresh) {
+                                               QSharedPointer<Entity> &e,
+                                               const bool refresh) {
     QSharedPointer<Entity> r;
     if (!e.isNull() && (refresh
                         || !(r = this->cache.get(id, EntityHelper::getClassname(e.data()))))) {
@@ -442,9 +436,9 @@ QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
 }
 
 QSharedPointer<Entity> EntityManager::findById(const qint64 &id,
-        const QString &classname) {
+                                               const QString &classname) {
     QSharedPointer<Entity> e = QSharedPointer<Entity>
-                               (EntityInstanceFactory::createInstance(classname));
+            (EntityInstanceFactory::createInstance(classname));
     return this->findById(id, e);
 }
 
@@ -455,7 +449,7 @@ void EntityManager::manyToOne(const QSharedPointer<Entity> &entity,
     bool ok = false;
     if ((convertedId = id.toLongLong(&ok)) && ok && convertedId > -1) {
         QString className = EntityInstanceFactory::extractEntityType(
-                                property.typeName());
+                    property.typeName());
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>();
         if (refresh || !(this->cache.contains(convertedId, className)
                          && (ptr = this->cache.get(convertedId, className)) && ptr)) {
@@ -474,8 +468,8 @@ void EntityManager::oneToMany(const QSharedPointer<Entity> &entity,
                                                 property.typeName())));
         if (e) {
             QSqlQuery q = this->schema->getQueryBuilder()->oneToMany(e->getTablename(),
-                          this->schema->getQueryBuilder()->generateColumnNameID(r.getMappedBy()),
-                          entity->getId());
+                                                                     this->schema->getQueryBuilder()->generateColumnNameID(r.getMappedBy()),
+                                                                     entity->getId());
             auto listMap = this->convertQueryResult(q);
             auto entities = this->convert(listMap, EntityHelper::getClassname(e.data()),
                                           refresh);
@@ -495,10 +489,10 @@ void EntityManager::oneToOne(const QSharedPointer<Entity> &entity,
                                             EntityInstanceFactory::extractEntityType(property.typeName())));
         if (e) {
             QSqlQuery q = this->schema->getQueryBuilder()->oneToMany(
-                              e->getTablename(),
-                              this->schema->getQueryBuilder()->generateColumnNameID(
-                                  r.getMappedBy()),
-                              entity->getProperty(entity->getPrimaryKey()).toLongLong(), 1);
+                        e->getTablename(),
+                        this->schema->getQueryBuilder()->generateColumnNameID(
+                            r.getMappedBy()),
+                        entity->getProperty(entity->getPrimaryKey()).toLongLong(), 1);
             auto listMap = this->convertQueryResult(q);
             auto entities = this->convert(listMap, EntityHelper::getClassname(e.data()),
                                           refresh);
@@ -511,7 +505,7 @@ void EntityManager::oneToOne(const QSharedPointer<Entity> &entity,
 }
 
 void EntityManager::savePrePersistedRelations(const QSharedPointer<Entity>
-        &entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged) {
+                                              &entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged) {
     auto relations = EntityHelper::getRelationProperties(entity.data());
     auto iterator = relations.constBegin();
     while (iterator != relations.constEnd()) {
@@ -540,7 +534,7 @@ void EntityManager::savePrePersistedRelations(const QSharedPointer<Entity>
 }
 
 void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
-        &entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged, bool newItem) {
+                                               &entity, QList<Entity *> &mergedObjects, bool ignoreHasChanged, bool newItem) {
     auto relations = EntityHelper::getRelationProperties(entity.data());
     for (auto i = relations.constBegin(); i != relations.constEnd(); ++i) {
         const Relation r = i.key();
@@ -551,7 +545,7 @@ void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
                                         newItem);
             } else if (r.getType() == RelationType::ONE_TO_MANY) {
                 QList<QSharedPointer<Entity>> list = EntityInstanceFactory::castQVariantList(
-                        var);
+                            var);
                 if (!list.isEmpty()) {
                     auto fkProp = EntityHelper::mappedProperty(r, list.at(0));
                     for (int var = 0; var < list.size(); ++var) {
@@ -575,15 +569,15 @@ void EntityManager::savePostPersistedRelations(const QSharedPointer<Entity>
 }
 
 void EntityManager::persistMappedByRelation(const QList<QSharedPointer<Entity> >
-        &list, QSqlQuery &q, const QSharedPointer<Entity> &entity,
-        const QSharedPointer<Entity> &ptr, const Relation &r,
-        const QString &tblName, QList<Entity *> &mergedObjects) {
+                                            &list, QSqlQuery &q, const QSharedPointer<Entity> &entity,
+                                            const QSharedPointer<Entity> &ptr, const Relation &r,
+                                            const QString &tblName, QList<Entity *> &mergedObjects) {
     q.clear();
     QList<QSharedPointer<Entity>> saved =
-                                   r.getCascadeType().contains(CascadeType::ALL) ||
-                                   r.getCascadeType().contains(CascadeType::MERGE) ||
-                                   r.getCascadeType().contains(CascadeType::PERSIST) ?
-                                   this->saveRelationEntities(list, r, mergedObjects) : list;
+            r.getCascadeType().contains(CascadeType::ALL) ||
+            r.getCascadeType().contains(CascadeType::MERGE) ||
+            r.getCascadeType().contains(CascadeType::PERSIST) ?
+                this->saveRelationEntities(list, r, mergedObjects) : list;
     this->db->startTransaction();
     auto builder = this->schema->getQueryBuilder();
     q = builder->manyToManyInsert(tblName,
@@ -630,7 +624,7 @@ QHash<QString, EntityManager *> EntityManager::getInstances() {
 
 EntityManager *EntityManager::getDefaultInstance() {
     for (auto i = EntityManager::instances.constBegin();
-            i != EntityManager::instances.constEnd(); ++i) {
+         i != EntityManager::instances.constEnd(); ++i) {
         return i.value();
     }
     return nullptr;
@@ -695,7 +689,7 @@ void EntityManager::setNullOneToManyRelation(QVariant &var, const Relation &r) {
 }
 
 void EntityManager::setNullEntityPropertyRelation(QVariant &var,
-        const Relation &r) {
+                                                  const Relation &r) {
     if (r.getCascadeType().contains(CascadeType::REMOVE)
             || r.getCascadeType().contains(CascadeType::ALL)) {
         this->removeEntity(var);
@@ -728,8 +722,8 @@ void EntityManager::removeEntityList(QVariant &var) {
 }
 
 void EntityManager::removeManyToManyEntityList(const QSharedPointer<Entity> &e,
-        const Relation &r,
-        QVariant &var) {
+                                               const Relation &r,
+                                               QVariant &var) {
     if (!var.isNull() && var.canConvert<QVariantList>()) {
         auto list = EntityInstanceFactory::castQVariantList(var);
         if (!list.isEmpty()) {
@@ -738,13 +732,13 @@ void EntityManager::removeManyToManyEntityList(const QSharedPointer<Entity> &e,
             QString tblName = builder->generateManyToManyTableName(e, ptr, r);
             if (this->schema->getTables().contains(tblName)) {
                 QSqlQuery q = builder->manyToManyDelete(
-                                  tblName, builder->generateManyToManyColumnName(e),
-                                  e->getProperty(e->getPrimaryKey()).toLongLong());
+                            tblName, builder->generateManyToManyColumnName(e),
+                            e->getProperty(e->getPrimaryKey()).toLongLong());
                 if (this->db->exec(q)) {
                     bool refresh = r.getCascadeType().contains(CascadeType::REFRESH)
-                                   || r.getCascadeType().contains(CascadeType::ALL);
+                            || r.getCascadeType().contains(CascadeType::ALL);
                     bool remove = r.getCascadeType().contains(CascadeType::REMOVE)
-                                  || r.getCascadeType().contains(CascadeType::ALL);
+                            || r.getCascadeType().contains(CascadeType::ALL);
                     auto fkProp = EntityHelper::mappedProperty(r, ptr);
                     for (int var = 0; var < list.size(); ++var) {
                         auto entity = list.at(var);
@@ -761,8 +755,8 @@ void EntityManager::removeManyToManyEntityList(const QSharedPointer<Entity> &e,
 }
 
 QList<QSharedPointer<Entity>> EntityManager::saveRelationEntities(
-                               const QList<QSharedPointer<Entity> > &list, const Relation &r,
-QList<Entity *> &mergedObjects) {
+        const QList<QSharedPointer<Entity> > &list, const Relation &r,
+        QList<Entity *> &mergedObjects) {
     QList<QSharedPointer<Entity>> saved = QList<QSharedPointer<Entity>>();
     QSharedPointer<Entity> ptr;
     for (int var = 0; var < list.size(); ++var) {
@@ -789,8 +783,8 @@ void EntityManager::persistManyToMany(const QSharedPointer<Entity> &entity,
             QSqlQuery q;
             if (!newItem) {
                 q = builder->manyToManyDelete(
-                        tblName, builder->generateManyToManyColumnName(entity),
-                        entity->getProperty(entity->getPrimaryKey()).toLongLong());
+                            tblName, builder->generateManyToManyColumnName(entity),
+                            entity->getProperty(entity->getPrimaryKey()).toLongLong());
                 ok = this->db->exec(q);
             } else {
                 q = builder->getQuery();
@@ -806,7 +800,7 @@ void EntityManager::persistManyToMany(const QSharedPointer<Entity> &entity,
 }
 
 void EntityManager::missingManyToManyTable(const QString &tblName,
-        const QSharedPointer<Entity> &e, const Relation &r) {
+                                           const QSharedPointer<Entity> &e, const Relation &r) {
     this->logger->logMsg("MANY_TO_MANY Table " + tblName + " is missing.\n" +
                          "Entity " + EntityHelper::getClassName(e.data()) +
                          " is affected.\n" + "Relation of property: " + r.getPropertyName(),
@@ -816,12 +810,12 @@ void EntityManager::missingManyToManyTable(const QString &tblName,
 void EntityManager::manyToMany(const QSharedPointer<Entity> &entity,
                                const QMetaProperty &property, const Relation &relation, const bool refresh) {
     QSharedPointer<Entity> secEntityPtr = QSharedPointer<Entity>
-                                          (EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(
-                                                  QString(property.typeName()))));
+            (EntityInstanceFactory::createInstance(EntityInstanceFactory::extractEntityType(
+                                                       QString(property.typeName()))));
     auto builder = this->schema->getQueryBuilder();
     if (secEntityPtr) {
         QString tblName = builder->generateManyToManyTableName(entity, secEntityPtr,
-                          relation);
+                                                               relation);
         if (this->schema->getTables().contains(tblName)) {
             QSqlQuery q = builder->manyToMany(tblName,
                                               builder->generateManyToManyColumnName(entity),
@@ -851,18 +845,18 @@ void EntityManager::manyToMany(const QSharedPointer<Entity> &entity,
 }
 
 QList<QSharedPointer<Entity> > EntityManager::findEntityByAttributes(
-    const QSharedPointer<Entity>
-    &entity,
-    bool ignoreID) {
+        const QSharedPointer<Entity>
+        &entity,
+        bool ignoreID) {
     auto maps = this->findAllByAttributes(entity, ignoreID);
     return this->convert(maps, EntityHelper::getClassname(entity.data()));
 }
 
 QHash<QString, QVariant> EntityManager::findByPk(qint64 id,
-        const QSharedPointer<Entity>
-        &e) {
+                                                 const QSharedPointer<Entity>
+                                                 &e) {
     QSqlQuery q = this->schema->getQueryBuilder()->find(id, e, 0,
-                  e->getPrimaryKey());
+                                                        e->getPrimaryKey());
     auto listMap  = this->convertQueryResult(q);
     if (!listMap.isEmpty()) {
         return listMap.at(0);
@@ -872,23 +866,23 @@ QHash<QString, QVariant> EntityManager::findByPk(qint64 id,
 
 
 QList<QHash<QString, QVariant> > EntityManager::findAllByAttributes(
-    const QSharedPointer<Entity>
-    &entity,
-    bool ignoreID) {
+        const QSharedPointer<Entity>
+        &entity,
+        bool ignoreID) {
     QSqlQuery q = this->schema->getQueryBuilder()->findByAttributes(
-                      entity, ignoreID);
+                entity, ignoreID);
     return this->convertQueryResult(q);
 }
 
 QList<QHash <QString, QVariant> > EntityManager::findAllByAttributes(
-    const QHash<QString, QVariant> &m, const QString &tblname, bool ignoreID) {
+        const QHash<QString, QVariant> &m, const QString &tblname, bool ignoreID) {
     QSqlQuery q = this->schema->getQueryBuilder()->findByAttributes(m,
-                  tblname, ignoreID);
+                                                                    tblname, ignoreID);
     return this->convertQueryResult(q);
 }
 
 QList<QHash<QString, QVariant> > EntityManager::convertQueryResult(
-    QSqlQuery &q) {
+        QSqlQuery &q) {
     QList<QHash <QString, QVariant> > listmap = QList<QHash <QString, QVariant> >();
     this->db->select(q);
     QSqlRecord rec = q.record();
@@ -908,7 +902,7 @@ QList<QHash<QString, QVariant> > EntityManager::convertQueryResult(
 }
 
 QList<QHash <QString, QVariant> > EntityManager::findAll(
-    const QSharedPointer<Entity> &e) {
+        const QSharedPointer<Entity> &e) {
     QSqlQuery q = this->schema->getQueryBuilder()->findAll(e);
     return this->convertQueryResult(q);
 }
@@ -921,7 +915,7 @@ void EntityManager::resolveRelations(const QSharedPointer<Entity> &entity,
         const Relation r = iterator.key();
         const QMetaProperty property = iterator.value();
         QString colName = this->schema->getQueryBuilder()->generateColumnNameID(
-                              r.getPropertyName());
+                    r.getPropertyName());
         switch (r.getType()) {
         case RelationType::MANY_TO_ONE:
             if (map.contains(colName)) {
@@ -975,12 +969,12 @@ bool EntityManager::removeAll(QString tblname) {
 bool EntityManager::createTable(const QSharedPointer<Entity> &entity,
                                 bool createRelationTables) {
     return this->schema->getQueryBuilder()->createTable(entity,
-            createRelationTables);
+                                                        createRelationTables);
 }
 
 bool EntityManager::createTable(QString className, bool createRelationTables) {
     QSharedPointer<Entity> e = QSharedPointer<Entity>
-                               (EntityInstanceFactory::createInstance(className));
+            (EntityInstanceFactory::createInstance(className));
     return this->schema->getQueryBuilder()->createTable(e, createRelationTables);
 }
 
@@ -992,11 +986,10 @@ quint8 EntityManager::count(const QSharedPointer<Entity> &entity, bool ignoreID,
     if (followInheritance) {
         q.appendJoins(qb->joinBaseClasses(entity));
         values = EntityHelper::getEntityAttributes(EntityHelper::getMetaProperties(
-                     entity.data()), entity);
-
+                                                       entity.data()), entity);
     } else {
         values = EntityHelper::getEntityAttributes(
-                     EntityHelper::getNonInheritedMetaProperties(entity.data()), entity);
+                    EntityHelper::getNonInheritedMetaProperties(entity.data()), entity);
     }
     //maybe filter MANY_TO_MANY and ONE_TO_MANY relations
     q.appendFrom(entity->getTablename());
@@ -1032,8 +1025,8 @@ void EntityManager::setConnectionNames(QStringList list) {
 }
 
 QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant>
-        &map,
-        const char *classname, const bool refresh, const bool resolveRelations) {
+                                              &map,
+                                              const char *classname, const bool refresh, const bool resolveRelations) {
     auto ptr = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
                                           classname, map));
     this->cache.insert(ptr);
@@ -1044,8 +1037,8 @@ QSharedPointer<Entity> EntityManager::convert(const QHash<QString, QVariant>
 }
 
 QList<QSharedPointer<Entity> > EntityManager::convert(
-    QList<QHash<QString, QVariant> > maps,
-    const char *classname, const bool refresh, const bool resolveRelations) {
+        QList<QHash<QString, QVariant> > maps,
+        const char *classname, const bool refresh, const bool resolveRelations) {
     auto list = QList<QSharedPointer<Entity> >();
     for (int var = 0; var < maps.size(); ++var) {
         auto ptr = this->convert(maps.at(var), classname, refresh, resolveRelations);
diff --git a/src/entitymanager.h b/src/entitymanager.h
index 0c5fb0a..f5b49fe 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -48,7 +48,7 @@ class Logger;
 class QueryInterpreter;
 class EntityManager : public QObject {
     Q_OBJECT
-  public slots:
+public slots:
     /**
      * @brief startup
      * @param version must be unique
@@ -60,19 +60,19 @@ class EntityManager : public QObject {
     bool executeQuery(const QString &query);
     QSharedPointer<Entity> findById(const qint64 &id, const QString &classname);
     QList<QSharedPointer<Entity>> findEntityByAttributes(const
-                               QSharedPointer<Entity> &entity,
-                               bool ignoreID = false);
+                                                         QSharedPointer<Entity> &entity,
+                                                         bool ignoreID = false);
     qint64 findId(QSharedPointer<Entity> &entity);
     /**
      * @todo should be an insert statement with many values
+     * @todo error handling
      * @brief EntityManager::create
      * @param entities
      * @return
      */
-    bool create(QList<QSharedPointer<Entity>> &entities,
-                const bool persistRelations = true, const bool validate = true,
-                const bool relationsIgnoreHasChanged = false,
-                const bool checkDuplicate = false);
+    bool create(QList<QSharedPointer<Entity>> &entities, const bool persistRelations = true,
+                const bool checkDuplicate = false, const bool validate = true,
+                const bool relationsIgnoreHasChanged = false);
     /**
      * @brief EntityManager::create
      * Will persist an entity in the database. Before its persisted it has the id -1(invalid id). If database persisting was succesfull it has a valid id.
@@ -140,7 +140,7 @@ class EntityManager : public QObject {
      */
     bool hasChanged(QSharedPointer<Entity> &entity);
 
-  public:
+public:
     EntityManager(QSqlDatabase database, bool logQueries = false,
                   const bool inspectEntities = INSPECTENTITIES,
                   MsgType logActions = DEFAULTMSGTYPE);
@@ -159,9 +159,9 @@ class EntityManager : public QObject {
     QSharedPointer<QueryBuilder> getQueryBuilder() const;
 
     template<class T> QList<QSharedPointer<T>> find(Query &q,
-    const bool joinBaseClasses = false, const bool resolveRelations = true) {
+                                                    const bool joinBaseClasses = false, const bool resolveRelations = true) {
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>
-                                     (EntityInstanceFactory::createInstance<T *>());
+                (EntityInstanceFactory::createInstance<T *>());
         if (ptr) {
             if (q.getFrom().isEmpty()) {
                 q.setFrom(QStringList(ptr->getTablename()));
@@ -180,9 +180,9 @@ class EntityManager : public QObject {
     }
 
     template<class T> QList<QSharedPointer<T>> findAll(const bool resolveRelations =
-    true) {
+            true) {
         QSharedPointer<Entity> ptr = QSharedPointer<Entity>
-                                     (EntityInstanceFactory::createInstance<T *>());
+                (EntityInstanceFactory::createInstance<T *>());
         if (ptr) {
             auto maps = this->findAll(ptr);
             auto converted = this->convert(maps, EntityHelper::getClassname(ptr.data()),
@@ -201,11 +201,11 @@ class EntityManager : public QObject {
 
     template<class T>
     QSharedPointer<T> findEntityByAttributes(
-        const QHash<QString, QVariant>
-        &attributes, const bool joinBaseClasses = false,
-        const bool resolveRelations = true) {
+            const QHash<QString, QVariant>
+            &attributes, const bool joinBaseClasses = false,
+            const bool resolveRelations = true) {
         auto list = this->findAllEntitiesByAttributes<T>(attributes, 1, 0,
-                    joinBaseClasses, resolveRelations);
+                                                         joinBaseClasses, resolveRelations);
         if (list.isEmpty()) {
             return QSharedPointer<T>();
         }
@@ -215,10 +215,10 @@ class EntityManager : public QObject {
 
     template<class T> QList<QSharedPointer<T>> findAllEntitiesByAttributes(
             const QHash<QString, QVariant> &attributes =
-                QHash<QString, QString>(), quint64 limit = 0, quint64 offset = 0,
-    bool joinBaseClasses = false, const bool resolveRelations = true) {
+            QHash<QString, QString>(), quint64 limit = 0, quint64 offset = 0,
+            bool joinBaseClasses = false, const bool resolveRelations = true) {
         QSharedPointer<Entity> e = QSharedPointer<Entity>
-                                   (EntityInstanceFactory::createInstance<T *>());
+                (EntityInstanceFactory::createInstance<T *>());
         if (e) {
             Query query = Query(QStringList(e->getTablename()));
             if (joinBaseClasses) {
@@ -237,7 +237,7 @@ class EntityManager : public QObject {
     }
 
     template<class T> QList<QSharedPointer<T>> findEntitiesBySql(
-    const QString &sql) {
+            const QString &sql) {
         QSharedPointer<T> e = EntityInstanceFactory::createInstance<T *>();
         if (e) {
             QSqlQuery q = this->schema->getDatabase()->getQuery(sql);
@@ -270,7 +270,7 @@ class EntityManager : public QObject {
     }
 
     template<class T> QList<QSharedPointer<T>> convertList(const
-    QList<QSharedPointer<Entity>> &list) {
+                                                           QList<QSharedPointer<Entity>> &list) {
         QList<QSharedPointer<T>> newList = QList<QSharedPointer<T>>();
         for (int i = 0; i < list.size(); ++i) {
             newList.append(list.at(i).objectCast<T>());
@@ -279,7 +279,7 @@ class EntityManager : public QObject {
     }
 
     template<class T> QList<QSharedPointer<Entity>> convertToEntityList(
-    const QList<QSharedPointer<T>> &list) {
+            const QList<QSharedPointer<T>> &list) {
         QList<QSharedPointer<Entity>> newList = QList<QSharedPointer<Entity>>();
         for (int i = 0; i < list.size(); ++i) {
             QSharedPointer<T> entity = list.at(i);
@@ -288,7 +288,7 @@ class EntityManager : public QObject {
         return newList;
     }
 
-  protected:
+protected:
     bool saveObject(QSharedPointer<Entity> &entity, QList<Entity *> &mergedObjects,
                     const bool persistRelations = true,
                     const bool ignoreHasChanged = false, const bool validate = true,
@@ -319,12 +319,12 @@ class EntityManager : public QObject {
                            QVariant &property, QList<Entity *> &mergedObjects,
                            const bool ignoreHasChanged = false, const bool newItem = false);
     QList<QHash<QString, QVariant> > findAllByAttributes(const
-            QSharedPointer<Entity> &entity,
-            bool ignoreID = false);
+                                                         QSharedPointer<Entity> &entity,
+                                                         bool ignoreID = false);
     QList<QHash<QString, QVariant> > findAllByAttributes(const
-            QHash<QString, QVariant> &m,
-            const QString &tblname,
-            bool ignoreID = false);
+                                                         QHash<QString, QVariant> &m,
+                                                         const QString &tblname,
+                                                         bool ignoreID = false);
     QSharedPointer<Entity> findById(const qint64 &id, QSharedPointer<Entity> &e,
                                     const bool refresh = false);
     /**
@@ -346,8 +346,8 @@ class EntityManager : public QObject {
                                     bool newItem = false);
 
     QList<QSharedPointer<Entity>> saveRelationEntities(const
-                               QList<QSharedPointer<Entity>> &list, const Relation &r,
-                               QList<Entity *> &mergedObjects);
+                                                       QList<QSharedPointer<Entity>> &list, const Relation &r,
+                                                       QList<Entity *> &mergedObjects);
     /**
      * @brief EntityManager::persistManyToMany
      * @param entity
@@ -384,7 +384,7 @@ class EntityManager : public QObject {
     QString generateObjectName();
     void appendToInstanceList();
 
-  private:
+private:
     static QStringList connectionNames;
     static QHash<QString, EntityManager *> instances;
     QSharedPointer<Logger> logger;