Projekt

Allgemein

Profil

Herunterladen als
Herunterladen (6,69 KB) Statistiken
| Zweig: | Revision:
#include "attributeresolver.h"
#include "entityhelper.h"
#include "querybuilder.h"
#include <QDebug>
using namespace CuteEntityManager;

AttributeResolver::AttributeResolver(QSharedPointer<QueryBuilder> queryBuilder) {
this->qb = queryBuilder;
}

AttributeResolver::~AttributeResolver() {
this->qb = QSharedPointer<QueryBuilder>(nullptr);
if(!this->attributes.isEmpty()) {
QMutableHashIterator<QString, QHash<QString, Attribute*>> i(this->attributes);
while(i.hasNext()) {
i.next();
auto embeddedHash = i.value();
QMutableHashIterator<QString, Attribute*> i2(embeddedHash);
while(i2.hasNext()) {
i2.next();
auto attr = i2.value();
delete attr;
i2.remove();
}
i.remove();
}
}
}

QHash<QString, QHash<QString, Attribute *>> AttributeResolver::getAttributes() const {
return attributes;
}

void AttributeResolver::setAttributes(const QHash<QString, QHash<QString, Attribute*>>
&value) {
attributes = value;
}

Attribute *AttributeResolver::resolveManyToManyAttribute(const QSharedPointer<Entity> &e,
const QString &attr, const Relation &r, const QSharedPointer<Entity> &target) {
auto ptr = e;
QString attributeName = r.getPropertyName();
QString foreignColumnName = target->getTablename();
auto baseObj = EntityHelper::getBaseClassObject(e, attributeName);
Entity* foreignBaseObj = target.data();
if (!r.getMappedBy().isEmpty()) {
ptr = target;
attributeName = r.getMappedBy();
foreignBaseObj = EntityHelper::getBaseClassObject(ptr, attributeName);
foreignColumnName = foreignBaseObj->getTablename();
}
Attribute *attrObj = new Attribute(attr,
this->qb->generateColumnNameID(baseObj->getTablename()),
baseObj->getTablename(), e->metaObject());
this->resolveInheritance(e, attrObj);
attrObj->setRelation(foreignBaseObj->getTablename(), target->metaObject(), r,
this->qb->generateManyToManyTableName((r.getMappedBy().isEmpty() ? baseObj->getTablename()
: foreignBaseObj->getTablename()), attributeName),
this->qb->generateColumnNameID(foreignColumnName));
delete baseObj;
if(foreignBaseObj != target.data()) {
delete foreignBaseObj;
}
return attrObj;
}

Attribute *AttributeResolver::resolveManyToOneAttribute(const QSharedPointer<Entity> &e,
const QString &attr, const Relation &r, const QSharedPointer<Entity> &target) {
Q_UNUSED(r);
auto obj = EntityHelper::getBaseClassObject(e, attr);
Attribute *attrObj = new Attribute(attr,
this->qb->generateColumnNameID(attr),
e->getTablename(), e->metaObject());
this->resolveInheritance(e, attrObj);
attrObj->setRelation(target->getTablename(), target->metaObject(), r, "", "id");
delete obj;
return attrObj;
}

Attribute *AttributeResolver::resolveOneToManyAttribute(const QSharedPointer<Entity> &e,
const QString &attr, const Relation &r, const QSharedPointer<Entity> &target) {
auto obj = EntityHelper::getBaseClassObject(e, attr);
Attribute *attrObj = new Attribute(attr, "id",
e->getTablename(), e->metaObject());
this->resolveInheritance(e, attrObj);
attrObj->setRelation(target->getTablename(), target->metaObject(), r, "",
this->qb->generateColumnNameID(r.getMappedBy()));
delete obj;
return attrObj;
}

Attribute *AttributeResolver::resolveNonRelatedAttribute(const QSharedPointer<Entity> &e,
const QString &attr) {
Attribute *obj = new Attribute(attr, attr, e->getTablename(), e->metaObject());
this->resolveInheritance(e, obj);
return obj;
}

const QMetaObject *AttributeResolver::resolveInheritance(const QSharedPointer<Entity> &e,
Attribute *&attribute) {
auto obj = EntityHelper::getBaseClassObject(e, attribute->getName());
if(obj && obj->getTablename() != e->getTablename()) {
attribute->setInheritance(obj->getTablename(), obj->metaObject());
}
return obj->metaObject();
}

void AttributeResolver::addAttribute(const QString &className, Attribute *&attr) {
auto attrs = this->attributes.value(className);
attrs.insert(attr->getName(), attr);
this->attributes.insert(className, attrs);
}

Attribute *AttributeResolver::resolveExplicitAttribute(const QSharedPointer<Entity>
&classObj, const QString &attribute, QSharedPointer<Entity> related) {
Attribute* a = nullptr;
if(classObj->getRelations().contains(attribute)) {
auto relation = classObj->getRelations().value(attribute);
if(relation.getType() == RelationType::MANY_TO_MANY) {
a = this->resolveManyToManyAttribute(classObj, attribute, relation, related);
} else if(relation.getType() == RelationType::MANY_TO_ONE ||
(relation.getType() == RelationType::ONE_TO_ONE && relation.getMappedBy().isEmpty())) {
a = this->resolveManyToOneAttribute(classObj, attribute, relation, related);
} else {
a = this->resolveOneToManyAttribute(classObj, attribute, relation, related);
}
} else {
a = this->resolveNonRelatedAttribute(classObj, attribute);
}
return a;
}

QSharedPointer<QueryBuilder> AttributeResolver::getQb() const {
return qb;
}

bool AttributeResolver::containsAttribute(const QString &className,
const QString &attribute) const {
bool r = false;
auto attributes = this->getAttributes();
if(!this->attributes.isEmpty() && attributes.contains(className) &&
!attributes.value(className).isEmpty() &&
attributes.value(className).contains(attribute)) {
r = true;
}
return r;
}

Attribute *AttributeResolver::resolveAttribute(const QString &className,
const QString &attribute, const QString related) {
Attribute *attr = nullptr;
if(!className.isEmpty()) {
if(this->containsAttribute(className, attribute)) {
attr = this->attributes.value(className).value(attribute);
} else {
QSharedPointer<Entity> e = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
className));
QSharedPointer<Entity> rel = QSharedPointer<Entity>(EntityInstanceFactory::createInstance(
related));
attr = this->resolveExplicitAttribute(e, attribute, rel);
this->addAttribute(className, attr);
}
}
return attr;
}
(4-4/44)