Herunterladen als
root/src/attributeresolver.cpp @ ebda8fd9
| dbd41a3a | Christian Ehringfeld | #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;
|
|||
}
|