relation_impl.h

#ifndef QELOQUENT_RELATION_IMPL_H
#define QELOQUENT_RELATION_IMPL_H
 
#include <QEloquent/relation.h>
#include <QEloquent/namingconvention.h>
#include <QEloquent/query.h>
 
namespace QEloquent {
 
template<typename RelatedModel>
class BasicRelationData : public RelationData
{
public:
    BasicRelationData() { relatedObject = MetaObject::from<RelatedModel>(); }
    virtual ~BasicRelationData() = default;
 
    bool exists() override final { return related.count() > 0; }
 
    void *relatedList() const override final
    { return &const_cast<BasicRelationData<RelatedModel> *>(this)->related; }
 
    QList<DataMap> serialize() const override final {
        QList<DataMap> maps;
 
        std::transform(related.begin(), related.end(), std::back_inserter(maps), [](const Serializable &model) {
            const QList<DataMap> maps = model.serialize();
            // Model always return a single map
            return maps.first();
        });
 
        return maps;
    }
 
    QList<RelatedModel> related;
};
 
template<typename RelatedModel>
class HasRelationData : public BasicRelationData<RelatedModel>
{
public:
    virtual ~HasRelationData() = default;
 
    void init(NamingConvention *) override
    {
        if (foreignKey.isEmpty())
            foreignKey = this->primaryObject.foreignProperty().fieldName();
 
        if (localKey.isEmpty())
            localKey = this->primaryObject.primaryProperty().fieldName();
    }
 
    bool get() override
    {
        Query q;
        q.where(foreignKey, this->parentField(localKey));
        if (!this->multiple()) q.limit(1);
 
        auto result = RelatedModel::find(q);
        if (result) {
            this->related = result.value();
            this->conserve(q);
            return true;
        } else {
            this->conserve(q, result.error());
            return false;
        }
    }
 
    QString foreignKey;
    QString localKey;
};
 
template<typename RelatedModel>
class HasOneRelationData final : public HasRelationData<RelatedModel>
{
public:
    HasOneRelationData *clone() const override { return new HasOneRelationData(*this); }
    bool multiple() const override { return false; }
};
 
template<typename RelatedModel>
class HasManyRelationData final : public HasRelationData<RelatedModel>
{
public:
    HasManyRelationData *clone() const override { return new HasManyRelationData(*this); }
    bool multiple() const override { return true; }
};
 
template<typename RelatedModel, typename ThroughModel>
class HasManyThroughRelationData final : public BasicRelationData<RelatedModel>
{
public:
    void init(NamingConvention *) override
    {
        const MetaObject through = MetaObject::from<ThroughModel>();
 
        if (localKey.isEmpty())
            localKey = this->primaryObject.primaryProperty().fieldName();
 
        if (throughForeignKey.isEmpty()) {
            RelatedModel m;
            throughForeignKey = m.metaObject().foreignProperty().fieldName();
        }
 
        if (throughLocalKey.isEmpty()) {
            throughLocalKey = through.primaryProperty().fieldName();
        }
 
        if (foreignKey.isEmpty()) {
            foreignKey = through.foreignProperty().fieldName();
        }
    }
 
    bool get() override
    {
        // SELECT related.* FROM related
        // INNER JOIN through ON related.through_foreign_key = through.through_local_key
        // WHERE through.foreign_key = parent.local_key
 
        const MetaObject through = MetaObject::from<ThroughModel>();
 
        Query q;
        q.join(through.tableName(),
               this->relatedObject.tableName() + "." + throughForeignKey,
               "=",
               through.tableName() + "." + throughLocalKey);
 
        q.where(through.tableName() + "." + foreignKey, this->parentField(localKey));
 
        auto result = RelatedModel::find(q);
        if (result) {
            this->related = result.value();
            this->conserve(q);
            return true;
        } else {
            this->conserve(q, result.error());
            return false;
        }
    }
 
    bool multiple() const override { return true; }
 
    HasManyThroughRelationData *clone() const override { return new HasManyThroughRelationData(*this); }
 
    QString foreignKey;
    QString localKey;
    QString throughForeignKey;
    QString throughLocalKey;
};
 
template<typename RelatedModel>
class BelongsToRelationData final : public BasicRelationData<RelatedModel>
{
public:
    void init(NamingConvention *) override
    {
        if (foreignKey.isEmpty())
            foreignKey = this->relatedObject.foreignProperty().fieldName();
 
        if (ownerKey.isEmpty())
            ownerKey = this->relatedObject.primaryProperty().fieldName();
    }
 
    bool get() override
    {
        Query q;
        q.where(ownerKey, this->parentField(foreignKey));
 
        auto result = RelatedModel::find(q);
        if (result) {
            this->related = { result.value() };
            return true;
        }
        return false;
    }
 
    bool multiple() const override { return false; }
 
    BelongsToRelationData *clone() const override { return new BelongsToRelationData(*this); }
 
    QString foreignKey;
    QString ownerKey;
};
 
template<typename RelatedModel>
class BelongsToManyRelationData final : public BasicRelationData<RelatedModel>
{
public:
    void init(NamingConvention *convention) override
    {
        if (table.isEmpty()) {
            QStringList tables = { this->primaryObject.tableName(), this->relatedObject.tableName() };
            tables.sort();
            table = convention->pivotTableName(tables.first(), tables.last());
        }
 
        if (foreignPivotKey.isEmpty())
            foreignPivotKey = this->primaryObject.foreignProperty().fieldName();
 
        if (relatedPivotKey.isEmpty())
            relatedPivotKey = this->relatedObject.foreignProperty().fieldName();
 
        if (parentKey.isEmpty())
            parentKey = this->primaryObject.primaryProperty().fieldName();
 
        if (relatedKey.isEmpty())
            relatedKey = this->relatedObject.primaryProperty().fieldName();
    }
 
    bool get() override
    {
        // SELECT related.* FROM related
        // INNER JOIN pivot ON related.related_key = pivot.related_pivot_key
        // WHERE pivot.foreign_pivot_key = parent.parent_key
        
        Query q;
        q.join(table, 
               this->relatedObject.tableName() + "." + relatedKey,
               "=", 
               table + "." + relatedPivotKey);
        
        q.where(table + "." + foreignPivotKey, this->parentField(parentKey));
 
        QString s = q.toString(this->parent->connection());
 
        auto result = RelatedModel::find(q);
        if (result) {
            this->related = result.value();
            this->conserve(q);
            return true;
        } else {
            this->conserve(q, result.error());
            return false;
        }
    }
 
    bool multiple() const override { return true; }
 
    BelongsToManyRelationData *clone() const override { return new BelongsToManyRelationData(*this); }
 
    QString table;
    QString foreignPivotKey;
    QString relatedPivotKey;
    QString parentKey;
    QString relatedKey;
};
 
template<typename RelatedModel, typename ThroughModel>
class BelongsToManyThroughRelationData final : public BasicRelationData<RelatedModel>
{
public:
    void init(NamingConvention *convention) override
    {
        const MetaObject through = MetaObject::from<ThroughModel>();
 
        if (table.isEmpty()) {
            table = convention->pivotTableName(through.tableName(), this->relatedObject.tableName());
        }
 
        if (foreignPivotKey.isEmpty())
            foreignPivotKey = through.foreignProperty().fieldName();
 
        if (relatedPivotKey.isEmpty())
            relatedPivotKey = this->relatedObject.foreignProperty().fieldName();
 
        if (parentKey.isEmpty())
            parentKey = through.foreignProperty().fieldName();
 
        if (relatedKey.isEmpty())
            relatedKey = this->relatedObject.primaryProperty().fieldName();
    }
 
    bool get() override
    {
        // SELECT related.* FROM related
        // INNER JOIN pivot ON related.related_key = pivot.related_pivot_key
        // WHERE pivot.foreign_pivot_key = parent.parent_key
        
        Query q;
        q.join(table, 
               this->relatedObject.tableName() + "." + relatedKey,
               "=", 
               table + "." + relatedPivotKey);
        
        q.where(table + "." + foreignPivotKey, this->parentField(parentKey));
 
        auto result = RelatedModel::find(q);
        if (result) {
            this->related = result.value();
            this->conserve(q);
            return true;
        } else {
            this->conserve(q, result.error());
            return false;
        }
    }
 
    bool multiple() const override { return true; }
 
    BelongsToManyThroughRelationData *clone() const override { return new BelongsToManyThroughRelationData(*this); }
 
    QString table;
    QString foreignPivotKey;
    QString relatedPivotKey;
    QString parentKey;
    QString relatedKey;
};
 
} // namespace QEloquent
 
#endif // QELOQUENT_RELATION_IMPL_H