OrderByClause::loadBelongsTo() - Code Metrics - Inspection of "hehey" - LaravelRUS/SleepingOwlAdmin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#688)

unknown

created 2017-08-07 13:46 UTC

OrderByClause::loadBelongsTo() A

↳ Parent: OrderByClause

Complexity

Conditions	1
Paths	1

Size

Total Lines	22
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	22
ccs	0
cts	12
cp	0
rs	9.2
c	0
b	0
f	0
cc	1
eloc	17
nc	1
nop	6
crap	2

<?php

namespace SleepingOwl\Admin\Display\Column;

use Illuminate\Support\Str;
use Mockery\Matcher\Closure;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
use SleepingOwl\Admin\Contracts\Display\OrderByClauseInterface;

class OrderByClause implements OrderByClauseInterface
{
    /**
     * @var string|Closure
     */
    protected $name;

    /**
     * OrderByClause constructor.
     *
     * @param string|Closure $name
     */
    public function __construct($name)
    {
        $this->setName($name);
    }

    /**
     * @param Builder $query
     * @param string $direction
     */
    public function modifyQuery(Builder $query, $direction = 'asc')
    {
        $this->name instanceof \Closure
            ? $this->callCallable($query, $direction)
            : $this->callDefaultClause($query, $direction);
    }

    /**
     * @param string|Closure $name
     *
     * @return $this
     */
    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    /**
     * @param Builder $query
     * @param string $direction
     */
    protected function callCallable(Builder $query, $direction)
    {
        call_user_func_array($this->name, [$query, $direction]);
    }

    /**
     * @param $name
     * @return bool
     */
    protected function isRelationName($name)
    {
        return Str::contains($name, '.');
    }

    /**
     * Make EagerLoad.
     */
    protected function eagerLoad()
    {
    }

    /**
     * Load Relations by this->name.
     * @param Builder $query
     * @param $direction
     */
    protected function loadRelationOrder(Builder $query, $direction)
    {
        $relations = collect(explode('.', $this->name));

        //Without Eager Load
        //With Eager Load
        if ($relations->count() == 2) {
            $model = $query->getModel();
            $relation = $relations->first();

            if (method_exists($model, $relation)) {

                /** @var Relation $relationClass */
                $relationClass = $model->{$relation}();
                $relationModel = $relationClass->getRelated();

                call_user_func([$this, implode('', ['load', class_basename(get_class($relationClass))])],
                    $relations, $relationClass, $relationModel, $model, $query, $direction);
            }
        }
    }

    /**
     * Load HasOneOrMany keys.
     * @param Collection $relations
     * @param HasOneOrMany $relationClass
     * @param Model $relationModel
     * @param Model $model
     * @param Builder $query
     * @param $direction
     */
    protected function loadHasOne(
        Collection $relations,
        HasOneOrMany $relationClass,
        Model $relationModel,
        Model $model,
        Builder $query,
        $direction
    ) {
        $this->loadHasOneOrMany($relations, $relationClass, $relationModel, $model, $query, $direction);
    }

    /**
     * Load HasMany keys.
     * @param Collection $relations
     * @param HasOneOrMany $relationClass
     * @param Model $relationModel
     * @param Model $model
     * @param Builder $query
     * @param $direction
     */
    protected function loadHasMany(
        Collection $relations,
        HasOneOrMany $relationClass,
        Model $relationModel,
        Model $model,
        Builder $query,
        $direction
    ) {
        $this->loadHasOneOrMany($relations, $relationClass, $relationModel, $model, $query, $direction);
    }

    /**
     * Load HasOneOrMany keys.
     * @param Collection $relations
     * @param HasOneOrMany $relationClass
     * @param Model $relationModel
     * @param Model $model
     * @param Builder $query
     * @param $direction
     */
    protected function loadHasOneOrMany(
        Collection $relations,
        HasOneOrMany $relationClass,
        Model $relationModel,
        Model $model,
        Builder $query,
        $direction
    ) {
        $ownerTable = $model->getTable();
        $foreignTable = $relationModel->getTable();

        $ownerColumn = $relationClass->getQualifiedForeignKeyName();
        $foreignColumn = $relationClass->getQualifiedParentKeyName();
        $sortedColumn = implode('.', [$foreignTable, $relations->last()]);

        $query->select([$ownerTable.'.*', $foreignTable.'.'.$relations->last()])

            ->join($foreignTable, $foreignColumn, '=', $ownerColumn, 'left')
            ->orderBy($sortedColumn, $direction);
    }

    /**
     * Load keys for BelongsTo.
     * @param Collection $relations
     * @param BelongsTo $relationClass
     * @param Model $relationModel
     * @param Model $model
     * @param Builder $query
     * @param $direction
     * @return array
     */
    protected function loadBelongsTo(
        Collection $relations,
        BelongsTo $relationClass,
        Model $relationModel,
        Model $model,
        Builder $query,
        $direction
    ) {
        $foreignKey = $relationClass->getOwnerKey();
        $ownerKey = $relationClass->getForeignKey();

        $ownerTable = $model->getTable();
        $foreignTable = $relationModel->getTable();

        $ownerColumn = implode('.', [$ownerTable, $ownerKey]);
        $foreignColumn = implode('.', [$foreignTable, $foreignKey]);
        $sortedColumn = implode('.', [$foreignTable, $relations->last()]);

        $query->select([$ownerTable.'.*', $foreignTable.'.'.$relations->last()])

            ->join($foreignTable, $foreignColumn, '=', $ownerColumn, 'left')
            ->orderBy($sortedColumn, $direction);
    }

    /**
     * @param Builder $query
     * @param string $direction
     */
    protected function callDefaultClause(Builder $query, $direction)
    {
        if ($this->isRelationName($this->name)) {
            $this->loadRelationOrder($query, $direction);
        } else {
            $query->orderBy($this->name, $direction);

        }
    }
}


1		<?php
2
3		namespace SleepingOwl\Admin\Display\Column;
4
5		use Illuminate\Support\Str;
6		use Mockery\Matcher\Closure;
7		use Illuminate\Support\Collection;
8		use Illuminate\Database\Eloquent\Model;
9		use Illuminate\Database\Eloquent\Builder;
10		use Illuminate\Database\Eloquent\Relations\Relation;
11		use Illuminate\Database\Eloquent\Relations\BelongsTo;
12		use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
13		use SleepingOwl\Admin\Contracts\Display\OrderByClauseInterface;
14
15		class OrderByClause implements OrderByClauseInterface
16		{
17		/**
18		* @var string\|Closure
19		*/
20		protected $name;
21
22		/**
23		* OrderByClause constructor.
24		*
25		* @param string\|Closure $name
26		*/
27	17	public function __construct($name)
28		{
29	17	$this->setName($name);
30	17	}
31
32		/**
33		* @param Builder $query
34		* @param string $direction
35		*/
36		public function modifyQuery(Builder $query, $direction = 'asc')
37		{
38		$this->name instanceof \Closure
39		? $this->callCallable($query, $direction)
40		: $this->callDefaultClause($query, $direction);
41		}
42
43		/**
44		* @param string\|Closure $name
45		*
46		* @return $this
47		*/
48	17	public function setName($name)
49		{
50	17	$this->name = $name;
51
52	17	return $this;
53		}
54
55		/**
56		* @param Builder $query
57		* @param string $direction
58		*/
59		protected function callCallable(Builder $query, $direction)
60		{
61		call_user_func_array($this->name, [$query, $direction]);
62		}
63
64		/**
65		* @param $name
66		* @return bool
67		*/
68		protected function isRelationName($name)
69		{
70		return Str::contains($name, '.');
71		}
72
73		/**
74		* Make EagerLoad.
75		*/
76		protected function eagerLoad()
77		{
78		}
79
80		/**
81		* Load Relations by this->name.
82		* @param Builder $query
83		* @param $direction
84		*/
85		protected function loadRelationOrder(Builder $query, $direction)
86		{
87		$relations = collect(explode('.', $this->name));
88
89		//Without Eager Load
90		//With Eager Load
91		if ($relations->count() == 2) {
92		$model = $query->getModel();
93		$relation = $relations->first();
94
95		if (method_exists($model, $relation)) {
96
97		/** @var Relation $relationClass */
98		$relationClass = $model->{$relation}();
99		$relationModel = $relationClass->getRelated();
100
101		call_user_func([$this, implode('', ['load', class_basename(get_class($relationClass))])],
102		$relations, $relationClass, $relationModel, $model, $query, $direction);
103		}
104		}
105		}
106
107		/**
108		* Load HasOneOrMany keys.
109		* @param Collection $relations
110		* @param HasOneOrMany $relationClass
111		* @param Model $relationModel
112		* @param Model $model
113		* @param Builder $query
114		* @param $direction
115		*/
116		protected function loadHasOne(
117		Collection $relations,
118		HasOneOrMany $relationClass,
119		Model $relationModel,
120		Model $model,
121		Builder $query,
122		$direction
123		) {
124		$this->loadHasOneOrMany($relations, $relationClass, $relationModel, $model, $query, $direction);
125		}
126
127		/**
128		* Load HasMany keys.
129		* @param Collection $relations
130		* @param HasOneOrMany $relationClass
131		* @param Model $relationModel
132		* @param Model $model
133		* @param Builder $query
134		* @param $direction
135		*/
136		protected function loadHasMany(
137		Collection $relations,
138		HasOneOrMany $relationClass,
139		Model $relationModel,
140		Model $model,
141		Builder $query,
142		$direction
143		) {
144		$this->loadHasOneOrMany($relations, $relationClass, $relationModel, $model, $query, $direction);
145		}
146
147		/**
148		* Load HasOneOrMany keys.
149		* @param Collection $relations
150		* @param HasOneOrMany $relationClass
151		* @param Model $relationModel
152		* @param Model $model
153		* @param Builder $query
154		* @param $direction
155		*/
156		protected function loadHasOneOrMany(
157		Collection $relations,
158		HasOneOrMany $relationClass,
159		Model $relationModel,
160		Model $model,
161		Builder $query,
162		$direction
163		) {
164		$ownerTable = $model->getTable();
165		$foreignTable = $relationModel->getTable();
166
167		$ownerColumn = $relationClass->getQualifiedForeignKeyName();
168		$foreignColumn = $relationClass->getQualifiedParentKeyName();
169		$sortedColumn = implode('.', [$foreignTable, $relations->last()]);
170
171		$query->select([$ownerTable.'.*', $foreignTable.'.'.$relations->last()])
		0 ignored issues – show Bug introduced 2017-04-04 16:33 UTC by Report Bug Copy Issue Report The method `select()` does not exist on `Illuminate\Database\Eloquent\Builder`. Did you maybe mean `createSelectWithConstraint()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
172		->join($foreignTable, $foreignColumn, '=', $ownerColumn, 'left')
173		->orderBy($sortedColumn, $direction);
174		}
175
176		/**
177		* Load keys for BelongsTo.
178		* @param Collection $relations
179		* @param BelongsTo $relationClass
180		* @param Model $relationModel
181		* @param Model $model
182		* @param Builder $query
183		* @param $direction
184		* @return array
185		*/
186		protected function loadBelongsTo(
187		Collection $relations,
188		BelongsTo $relationClass,
189		Model $relationModel,
190		Model $model,
191		Builder $query,
192		$direction
193		) {
194		$foreignKey = $relationClass->getOwnerKey();
195		$ownerKey = $relationClass->getForeignKey();
196
197		$ownerTable = $model->getTable();
198		$foreignTable = $relationModel->getTable();
199
200		$ownerColumn = implode('.', [$ownerTable, $ownerKey]);
201		$foreignColumn = implode('.', [$foreignTable, $foreignKey]);
202		$sortedColumn = implode('.', [$foreignTable, $relations->last()]);
203
204		$query->select([$ownerTable.'.*', $foreignTable.'.'.$relations->last()])
		0 ignored issues – show Bug introduced 2017-08-07 14:04 UTC by Report Bug Copy Issue Report The method `select()` does not exist on `Illuminate\Database\Eloquent\Builder`. Did you maybe mean `createSelectWithConstraint()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
205		->join($foreignTable, $foreignColumn, '=', $ownerColumn, 'left')
206		->orderBy($sortedColumn, $direction);
207		}
208
209		/**
210		* @param Builder $query
211		* @param string $direction
212		*/
213		protected function callDefaultClause(Builder $query, $direction)
214		{
215		if ($this->isRelationName($this->name)) {
216		$this->loadRelationOrder($query, $direction);
217		} else {
218		$query->orderBy($this->name, $direction);
		0 ignored issues – show Bug introduced 2017-02-11 08:58 UTC by Report Bug Copy Issue Report The method `orderBy()` does not exist on `Illuminate\Database\Eloquent\Builder`. Did you maybe mean `enforceOrderBy()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
219		}
220		}
221		}
222

LaravelRUS / SleepingOwlAdmin

GitHub Access Token became invalid

Pull Request — master (#688)

OrderByClause::loadBelongsTo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like