umbrellio / laravel-ltree

src/Relations/BelongsToTree.php

<?php

declare(strict_types=1);

namespace Umbrellio\LTree\Relations;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\JoinClause;
use Umbrellio\LTree\Interfaces\LTreeModelInterface;

class BelongsToTree extends Relation
{
    protected $throughRelationName;
    private $foreignKey;
    private $ownerKey;

    public function __construct(
        Builder $query,
        Model $child,
        string $throughRelationName,
        string $foreignKey,
        string $ownerKey
    ) {
        $this->throughRelationName = $throughRelationName;
        $this->foreignKey = $foreignKey;
        $this->ownerKey = $ownerKey;

        parent::__construct($query, $child);
    }

    public function addConstraints(): void
    {
        if (static::$constraints) {
            $relation = $this->parent->{$this->throughRelationName};

            if ($relation) {
                $this->query = $relation
                    ->newQuery()
                    ->ancestorsOf($relation)
                    ->orderBy($this->getLTreeRelated()->getLtreePathColumn());
            }
        }
    }

    public function addEagerConstraints(array $models): void
    {
        $key = $this->related->getTable() . '.' . $this->ownerKey;

The method getTable() does not exist on Illuminate\Database\Eloquent\Model. It seems like you code against a sub-type of Illuminate\Database\Eloquent\Model such as Illuminate\Database\Eloquent\Relations\Pivot.

        $whereIn = $this->whereInMethod($this->related, $this->ownerKey);

        $this->query->{$whereIn}($key, $this->getEagerModelKeys($models));

        $table = $this
            ->getModel()

The method getModel() does not exist on Umbrellio\LTree\Relations\BelongsToTree. Since you implemented __call, consider adding a @method annotation.

            ->getTable();
        $alias = sprintf('%s_depends', $table);

        $related = $this->getLTreeRelated();

        $this->query->join(

The method join() does not exist on Illuminate\Database\Eloquent\Builder.

            sprintf('%s as %s', $table, $alias),
            function (JoinClause $query) use ($alias, $table, $related) {
                $query->whereRaw(sprintf('%1$s.%2$s @> %3$s.%2$s', $alias, $related->getLtreePathColumn(), $table));
            }
        );

        $this->query->orderBy($related->getLtreePathColumn());

The method orderBy() does not exist on Illuminate\Database\Eloquent\Builder.

        $this->query->selectRaw(sprintf('%s.*, %s.%s as relation_id', $alias, $table, $this->ownerKey));

The method selectRaw() does not exist on Illuminate\Database\Eloquent\Builder.

    }

    public function match(array $models, Collection $results, $relation)
    {
        $dictionary = [];

        foreach ($results as $result) {
            $dictionary[$result->relation_id][] = $result;
        }

        foreach ($models as $model) {
            foreach ($dictionary as $related => $value) {
                if ($model->getAttribute($this->foreignKey) === $related) {
                    $model->setRelation($relation, $this->related->newCollection($value));

The method newCollection() does not exist on Illuminate\Database\Eloquent\Model. It seems like you code against a sub-type of Illuminate\Database\Eloquent\Model such as Umbrellio\LTree\tests\_data\Models\CategoryStub or Umbrellio\LTree\tests\_data\Models\ProductStub or Illuminate\Notifications\DatabaseNotification.

                }
            }
        }

        return $models;
    }

    public function getResults()
    {
        return $this->getParentKey() !== null
            ? $this->query->get()
            : $this->related->newCollection();
    }


    /**
     * Initialize the relation on a set of models.
     *
     * @param string $relation
     * @return array
     */
    public function initRelation(array $models, $relation)
    {
        foreach ($models as $model) {
            $model->setRelation($relation, $this->related->newCollection());
        }

        return $models;
    }

    protected function getEagerModelKeys(array $models)
    {
        $keys = [];

        foreach ($models as $model) {
            if (($value = $model->{$this->foreignKey}) !== null) {
                $keys[] = $value;
            }
        }

        sort($keys);

        return array_values(array_unique($keys));
    }

    private function getLTreeRelated(): LTreeModelInterface
    {
        return $this
            ->parent
            ->{$this->throughRelationName}()
            ->related;
    }

    private function getParentKey()
    {
        return $this->parent->{$this->foreignKey};
    }
}