SleepingOwl\Admin\Repository\TreeRepository

Complexity

Total Complexity

42

Size/Duplication

Total Lines	400
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	setClass()	0	8	1
A	getTree()	0	16	4
A	getType()	0	4	1
A	setType()	0	6	1
A	isType()	0	4	1
A	getParentField()	0	4	1
A	setParentField()	0	6	1
A	getOrderField()	0	4	1
A	setOrderField()	0	6	1
A	getRootParentId()	0	4	1
A	setRootParentId()	0	6	1
A	reorder()	0	11	3
A	move()	0	10	1
A	getLeftColumn()	0	9	1
A	getRightColumn()	0	9	1
A	getParentColumn()	0	9	1
B	detectType()	0	20	9
A	callMethods()	0	10	3
A	recursiveReorder()	0	12	2
A	recursiveReorderSimple()	0	15	3
A	getChildren()	0	15	3
A	createSimpleTree()	0	13	1

<?php

namespace SleepingOwl\Admin\Repository;

use Exception;
use Illuminate\Support\Collection;
use SleepingOwl\Admin\Contracts\TreeRepositoryInterface;

class TreeRepository extends BaseRepository implements TreeRepositoryInterface
{
    /**
     * Extrepat/Baum tree type
     * https://github.com/etrepat/baum.
     */
    const TreeTypeBaum = 0;

    /**
     * Lasychaser/Laravel-nestedset tree type
     * https://github.com/lazychaser/laravel-nestedset.
     */
    const TreeTypeKalnoy = 1;

    /**
     * Simple tree type (with `parent_id` and `order` fields).
     */
    const TreeTypeSimple = 2;

    /**
     * Tree type.
     * @var int
     */
    protected $type;

    /**
     * Parent field name.
     * @var string
     */
    protected $parentField = 'parent_id';

    /**
     * Order field name.
     * @var string
     */
    protected $orderField = 'order';

    /**
     * Root parent id value.
     * @var null
     */
    protected $rootParentId = null;

    /**
     * @param string $class
     *
     * @return $this
     */
    public function setClass($class)
    {
        parent::setClass($class);

        $this->detectType();

        return $this;
    }

    /**
     * Get tree structure.
     *
     * @param \Illuminate\Database\Eloquent\Collection $collection
     *
     * @return mixed
     */
    public function getTree(\Illuminate\Database\Eloquent\Collection $collection)
    {
        switch ($this->getType()) {
            case static::TreeTypeBaum:
                return $collection->toHierarchy();
                break;

break is not strictly necessary here and could be removed.

            case static::TreeTypeKalnoy:
                return $collection->toTree();
                break;

break is not strictly necessary here and could be removed.

            case static::TreeTypeSimple:
                return $this->createSimpleTree();
                break;

break is not strictly necessary here and could be removed.

        }
    }

    /**
     * Get or set tree type.
     *
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @param int $type
     *
     * @return $this
     */
    public function setType($type)
    {
        $this->type = $type;

        return $this;
    }

    /**
     * @param int $type
     *
     * @return bool
     */
    public function isType($type)
    {
        return $this->type == $type;
    }

    /**
     * Get parent field name.
     *
     * @return string
     */
    public function getParentField()
    {
        return $this->parentField;
    }

    /**
     * @param string $parentField
     *
     * @return $this
     */
    public function setParentField($parentField)
    {
        $this->parentField = $parentField;

        return $this;
    }

    /**
     * Get order field name.
     *
     * @return string
     */
    public function getOrderField()
    {
        return $this->orderField;
    }

    /**
     * @param string $orderField
     *
     * @return $this
     */
    public function setOrderField($orderField)
    {
        $this->orderField = $orderField;

        return $this;
    }

    /**
     * Get or set parent field name.
     *
     * @return string
     */
    public function getRootParentId()
    {
        return $this->rootParentId;
    }

    /**
     * @param string $rootParentId
     *
     * @return $this
     */
    public function setRootParentId($rootParentId)
    {
        $this->rootParentId = $rootParentId;

It seems like $rootParentId of type string is incompatible with the declared type null of property $rootParentId.

        return $this;
    }

    /**
     * Reorder tree by $data value.
     *
     * @param $data
     */
    public function reorder(array $data)
    {
        if ($this->isType(static::TreeTypeSimple)) {
            $this->recursiveReorderSimple($data, $this->getRootParentId());
        } else {
            $left = 1;
            foreach ($data as $root) {
                $left = $this->recursiveReorder($root, null, $left);
            }
        }
    }

    /**
     * Move tree node in nested-set tree type.
     *
     * @param $id
     * @param $parentId
     * @param $left
     * @param $right
     */
    protected function move($id, $parentId, $left, $right)
    {
        $instance = $this->find($id);
        $attributes = $instance->getAttributes();

The method getAttributes does only exist in Illuminate\Database\Eloquent\Model, but not in Illuminate\Database\Eloquent\Builder and Illuminate\Database\Eloquent\Collection.

        $attributes[$this->getLeftColumn($instance)] = $left;
        $attributes[$this->getRightColumn($instance)] = $right;
        $attributes[$this->getParentColumn($instance)] = $parentId;
        $instance->setRawAttributes($attributes);

The method setRawAttributes does only exist in Illuminate\Database\Eloquent\Model, but not in Illuminate\Database\Eloquent\Builder and Illuminate\Database\Eloquent\Collection.

        $instance->save();

The method save does only exist in Illuminate\Database\Eloquent\Model, but not in Illuminate\Database\Eloquent\Builder and Illuminate\Database\Eloquent\Collection.

    }

    /**
     * Get left column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getLeftColumn($instance)
    {
        $methods = [
            'getLeftColumnName',
            'getLftName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Get right column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getRightColumn($instance)
    {
        $methods = [
            'getRightColumnName',
            'getRgtName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Get parent column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getParentColumn($instance)
    {
        $methods = [
            'getParentColumnName',
            'getParentIdName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Detect tree type.
     * @return $this
     */
    protected function detectType()
    {
        $model = $this->getModel();

        // Check for package baum/baum
        if ($model instanceof \Baum\Node) {

The class Baum\Node does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return $this->setType(static::TreeTypeBaum);
        }

        // Check for package kalnoy/nestedset
        if (class_exists('Kalnoy\Nestedset\Node') and $model instanceof \Kalnoy\Nestedset\Node) {

The class Kalnoy\Nestedset\Node does not exist. Did you forget a USE statement, or did you not list all dependencies?

Using logical operators such as and instead of && is generally not recommended.

            return $this->setType(static::TreeTypeKalnoy);
        } elseif (function_exists('trait_uses_recursive') and $traits = trait_uses_recursive($model) and in_array('Kalnoy\Nestedset\NodeTrait', $traits)) {

Using logical operators such as and instead of && is generally not recommended.

            return $this->setType(static::TreeTypeKalnoy);
        } elseif ($traits = class_uses($model) and in_array('Kalnoy\Nestedset\NodeTrait', $traits)) {

Using logical operators such as and instead of && is generally not recommended.

            return $this->setType(static::TreeTypeKalnoy);
        }

        return $this->setType(static::TreeTypeSimple);
    }

    /**
     * Call several methods and get first result.
     *
     * @param $instance
     * @param $methods
     *
     * @return mixed
     * @throws Exception
     */
    protected function callMethods($instance, $methods)
    {
        foreach ($methods as $method) {
            if (method_exists($instance, $method)) {
                return $instance->$method();
            }
        }

        throw new Exception('Tree type not supported');
    }

    /**
     * Recursive reorder nested-set tree type.
     *
     * @param $root
     * @param $parentId
     * @param $left
     *
     * @return mixed
     */
    protected function recursiveReorder($root, $parentId, $left)
    {
        $right = $left + 1;
        $children = array_get($root, 'children', []);
        foreach ($children as $child) {
            $right = $this->recursiveReorder($child, $root['id'], $right);
        }
        $this->move($root['id'], $parentId, $left, $right);
        $left = $right + 1;

        return $left;
    }

    /**
     * Recursive reoder simple tree type.
     *
     * @param $data
     * @param $parentId
     */
    protected function recursiveReorderSimple(array $data, $parentId)
    {
        foreach ($data as $order => $item) {
            $id = $item['id'];

            $instance = $this->find($id);
            $instance->{$this->getParentField()} = $parentId;
            $instance->{$this->getOrderField()} = $order;
            $instance->save();

The method save does only exist in Illuminate\Database\Eloquent\Model, but not in Illuminate\Database\Eloquent\Builder and Illuminate\Database\Eloquent\Collection.

            if (isset($item['children'])) {
                $this->recursiveReorderSimple($item['children'], $id);
            }
        }
    }

    /**
     * Get children for simple tree type structure.
     *
     * @param $collection
     * @param $id
     *
     * @return Collection
     */
    protected function getChildren($collection, $id)
    {
        $parentField = $this->getParentField();
        $result = [];
        foreach ($collection as $instance) {
            if ((int) $instance->$parentField != $id) {
                continue;
            }

            $instance->setRelation('children', $this->getChildren($collection, $instance->getKey()));
            $result[] = $instance;
        }

        return new Collection($result);
    }

    /**
     * Create simple tree type structure.
     * @return static
     */
    protected function createSimpleTree()
    {
        $collection = $this

The method orderBy() does not exist on Illuminate\Database\Eloquent\Builder. Did you maybe mean enforceOrderBy()?

            ->getQuery()
            ->orderBy($this->getParentField(), 'asc')
            ->orderBy($this->getOrderField(), 'asc')
            ->get();

        return $this->getChildren(
            $collection,
            $this->getRootParentId()
        );
    }
}