Thinktomorrow\Chief\Relations\Relation

Complexity

Total Complexity

14

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Test Coverage

Coverage

81.63%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	parent()	0	3	1
A	parents()	0	11	1
A	children()	0	30	3
A	delete()	0	7	1
A	child()	0	3	1
A	setKeysForSaveQuery()	0	8	1
A	deleteRelationsOf()	0	12	2
A	deleteAllParentRelationsOf()	0	9	2
A	deleteAllChildRelationsOf()	0	9	2

<?php

namespace Thinktomorrow\Chief\Relations;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class Relation extends Model
{
    public $timestamps = false;
    public $guarded = [];

    /**
     * Set the keys for a save update query.
     * We override the default save setup since we do not have a primary key in relation table.
     * There should however always be the parent and child references so we can use
     * those to target the record in database.
     *
     * @param Builder $query
     * @return Builder
     */
    protected function setKeysForSaveQuery(Builder $query)
    {
        $query->where('parent_type', $this->getMorphClass())
                ->where('parent_id', $this->getKey())
                ->where('child_type', $this->child_type)
                ->where('child_id', $this->child_id);

        return $query;
    }

    public function parent()
    {
        return $this->morphTo('parent', 'parent_type', 'parent_id');
    }

    public function child()
    {
        return $this->morphTo('child', 'child_type', 'child_id');
    }

    public static function parents($child_type, $child_id)
    {
        $relations = static::where('child_type', $child_type)
            ->where('child_id', $child_id)
            ->orderBy('sort', 'ASC')
            ->get();

        return $relations->map(function (Relation $relation) {
            $parent = $relation->parent;

The property parent does not exist on Thinktomorrow\Chief\Relations\Relation. Did you mean parent_id?

            $parent->relation = $relation;
            return $parent;
        });
    }

    public static function children($parent_type, $parent_id)
    {
        $relations = static::where('parent_type', $parent_type)
                            ->where('parent_id', $parent_id)
                            ->orderBy('sort', 'ASC')
                            ->get();

        return $relations->map(function (Relation $relation) use ($parent_type, $parent_id) {

            // It could be that the child itself is soft-deleted, if this is the case, we will ignore it and move on.
            if (!$child = $relation->child) {

The property child does not exist on Thinktomorrow\Chief\Relations\Relation. Did you mean child_id?

                if (!$relation->child()->withTrashed()->first()) {
//                if ((!method_exists($childInstance, 'trashed')) || ! $childInstance->onlyTrashed()->find($relation->child_id)) {
                    // If we cannot retrieve it then he collection type is possibly off, this is a database inconsistency and should be addressed
                    throw new \DomainException('Corrupt relation reference. Related child ['.$relation->child_type.'@'.$relation->child_id.'] could not be retrieved for parent [' . $parent_type.'@'.$parent_id.']. Make sure the morph key can resolve to a valid class.');
                }

                return null;
            }

            $child->relation = $relation;

            return $child;
        })

        // In case of soft-deleted entries, this will be null and should be ignored. We make sure that keys are reset in case of removed child
        ->reject(function ($child) {
            return is_null($child);
        })
        ->values();
    }

    public function delete()
    {
        return static::where('parent_type', $this->parent_type)
                ->where('parent_id', $this->parent_id)
                ->where('child_type', $this->child_type)
                ->where('child_id', $this->child_id)
                ->delete();
    }

    public static function deleteRelationsOf($type, $id)
    {
        $relations = static::where(function ($query) use ($type, $id) {
            return $query->where('parent_type', $type)
                         ->where('parent_id', $id);
        })->orWhere(function ($query) use ($type, $id) {
            return $query->where('child_type', $type)
                ->where('child_id', $id);
        })->get();

        foreach ($relations as $relation) {
            $relation->delete();
        }
    }

    public static function deleteAllChildRelationsOf($type, $id)
    {
        $relations = static::where(function ($query) use ($type, $id) {
            return $query->where('parent_type', $type)
                ->where('parent_id', $id);
        })->get();

        foreach ($relations as $relation) {
            $relation->delete();
        }
    }

    public static function deleteAllParentRelationsOf($type, $id)
    {
        $relations = static::where(function ($query) use ($type, $id) {
            return $query->where('child_type', $type)
                ->where('child_id', $id);
        })->get();

        foreach ($relations as $relation) {
            $relation->delete();
        }
    }
}