commit 3214951e8a390dd06d586fed73bac4c84132b8fa
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Tue Oct 27 02:02:05 2015 +0100

    bug in many to many :O

diff --git a/src/entityinstancefactory.cpp b/src/entityinstancefactory.cpp
index 538e89f..ccc6b19 100644
--- a/src/entityinstancefactory.cpp
+++ b/src/entityinstancefactory.cpp
@@ -132,9 +132,8 @@ Entity *EntityInstanceFactory::createInstance(const QMetaObject *object) {
     auto o = object->newInstance();
     if(o) {
         return qobject_cast<Entity *>(o);
-    } else {
-        return EntityInstanceFactory::createInstance(object->className());
     }
+    return EntityInstanceFactory::createInstance(object->className());
 }
 
 QList<QSharedPointer<Entity>> EntityInstanceFactory::castQVariantList(
diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp
index af74941..3cd7409 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,
@@ -67,10 +67,10 @@ EntityManager::EntityManager(const QString &databaseType, QString databasename,
                              bool logQueries, QString databaseOptions, const bool inspectEntities,
                              CuteEntityManager::MsgType logActions) : QObject() {
     this->db = QSharedPointer<Database>(new Database(databaseType, this->createConnection(),
-                                        hostname,
-                                        databasename, username,
-                                        password,
-                                        port.toInt(), true, logQueries, databaseOptions, logActions));
+                                                     hostname,
+                                                     databasename, username,
+                                                     password,
+                                                     port.toInt(), true, logQueries, databaseOptions, logActions));
     this->init(inspectEntities, logActions);
 }
 
@@ -115,7 +115,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()) {
                 this->db->rollbackTransaction();
@@ -145,7 +145,7 @@ bool EntityManager::createObject(QSharedPointer<Entity> &entity,
             }
             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) {
@@ -240,7 +240,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);
@@ -253,14 +253,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;
             }
         }
@@ -330,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);
 }
@@ -341,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);
@@ -377,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() && v.data()) {
                     auto e = EntityInstanceFactory::castQVariant(v);
                     if (e && e->getProperty(e->getPrimaryKey()) != i.value()) {
@@ -423,21 +423,20 @@ 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 && (refresh
-              || !(r = this->cache.get(id, EntityHelper::getClassname(e.data()))))) {
+    if (e && (refresh || !(r = this->cache.get(id, EntityHelper::getClassname(e.data()))))) {
         auto map  = this->findByPk(id, e);
-        r = this->convert(map, EntityHelper::getClassname(e.data()), refresh);
+        r = this->convert(map, e->getClassname(), refresh);
     }
     return r;
 }
 
 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);
 }
 
@@ -448,7 +447,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)) {
@@ -467,8 +466,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);
@@ -488,10 +487,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);
@@ -504,7 +503,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()) {
@@ -535,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();
@@ -545,7 +544,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) {
@@ -569,15 +568,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,
@@ -641,10 +640,10 @@ EntityManager *EntityManager::getInstance(QString name) {
 bool EntityManager::shouldBeSaved(QSharedPointer<Entity> &entity,
                                   const Relation &r) {
     return entity && (r.getCascadeType().contains(CascadeType::ALL)
-           || (entity->getProperty(entity->getPrimaryKey()) > -1
-               && r.getCascadeType().contains(CascadeType::MERGE))
-           || (entity->getProperty(entity->getPrimaryKey()) <= -1
-               && r.getCascadeType().contains(CascadeType::PERSIST)));
+                      || (entity->getProperty(entity->getPrimaryKey()) > -1
+                          && r.getCascadeType().contains(CascadeType::MERGE))
+                      || (entity->getProperty(entity->getPrimaryKey()) <= -1
+                          && r.getCascadeType().contains(CascadeType::PERSIST)));
 }
 
 void EntityManager::removeRelations(const QSharedPointer<Entity> &entity) {
@@ -689,7 +688,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);
@@ -724,8 +723,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()) {
@@ -734,13 +733,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);
@@ -757,8 +756,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) {
@@ -787,8 +786,8 @@ void EntityManager::persistManyToMany(const QSharedPointer<Entity> &entity,
               * @todo diff and remove entity from relational object when association is deleted
               */
             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();
@@ -803,7 +802,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(),
@@ -813,13 +812,13 @@ 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();
     EntityHelper::clearEntityListProperty(entity, property);
     if (secEntityPtr) {
         QString tblName = builder->generateManyToManyTableName(entity, secEntityPtr,
-                          relation);
+                                                               relation);
         if (this->schema->getTables().contains(tblName)) {
             QSqlQuery q = builder->manyToMany(tblName,
                                               builder->generateManyToManyColumnName(entity),
@@ -827,16 +826,11 @@ void EntityManager::manyToMany(const QSharedPointer<Entity> &entity,
             auto listMap = this->convertQueryResult(q);
             QSharedPointer<Entity> e = QSharedPointer<Entity>();
             for (int var = 0; var < listMap.size(); ++var) {
-                auto id = listMap.at(var).value(builder->generateManyToManyColumnName(
-                                                    secEntityPtr));
-                if (!refresh
-                        && this->cache.contains(id.toLongLong(),
-                                                EntityHelper::getClassname(secEntityPtr.data()))) {
-                    e = this->cache.get(id.toLongLong(),
-                                        EntityHelper::getClassname(secEntityPtr.data()));
+                auto id = listMap.at(var).value(builder->generateManyToManyColumnName(secEntityPtr));
+                if (!refresh && this->cache.contains(id.toLongLong(), EntityHelper::getClassname(secEntityPtr.data()))) {
+                    e = this->cache.get(id.toLongLong(), EntityHelper::getClassname(secEntityPtr.data()));
                 } else {
-                    e = this->findById(id.toLongLong(),
-                                       EntityHelper::getClassname(secEntityPtr.data()));
+                    e = this->findById(id.toLongLong(), EntityHelper::getClassname(secEntityPtr.data()));
                 }
                 if (e) {
                     EntityHelper::addEntityToListProperty(entity, e, property);
@@ -849,18 +843,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);
@@ -870,23 +864,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();
@@ -906,7 +900,7 @@ QSqlQuery &q) {
 }
 
 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);
 }
@@ -919,7 +913,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)) {
@@ -973,12 +967,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);
 }
 
@@ -994,10 +988,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());
@@ -1033,8 +1027,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);
@@ -1055,8 +1049,8 @@ void EntityManager::convert(const QHash<QString, QVariant> &map,
 }
 
 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 6c949e1..2f00cad 100644
--- a/src/entitymanager.h
+++ b/src/entitymanager.h
@@ -362,8 +362,9 @@ class EntityManager : public QObject {
     QSharedPointer<Entity> convert(const QHash<QString, QVariant> &map,
                                    const char *classname, const bool refresh = false,
                                    const bool resolveRelations = true);
-    void convert(const QHash<QString, QVariant> &map, QSharedPointer<Entity> &entity, const bool refresh = false,
-                                   const bool resolveRelations = true);
+    void convert(const QHash<QString, QVariant> &map, QSharedPointer<Entity> &entity,
+                 const bool refresh = false,
+                 const bool resolveRelations = true);
     QList<QSharedPointer<Entity>> convert(QList<QHash<QString, QVariant>> maps,
                                           const char *classname, const bool refresh = false,
                                           const bool resolveRelations = true);