CustomOrderTrait::setOrder() - Code Metrics - blasttech/eloquent-related-plus - Measure and Improve Code Quality continuously with Scrutinizer

CustomOrderTrait::setOrder() A
last analyzed 2021-04-13 00:05 UTC

↳ Parent: CustomOrderTrait

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	2
eloc	3
c	2
b	0
f	0
nc	2
nop	3
dl	0
loc	7
rs	10

<?php

namespace Blasttech\EloquentRelatedPlus;

use Illuminate\Database\Eloquent\Builder;
use InvalidArgumentException;

/**
 * Trait CustomOrderTrait
 *
 * @property array attributes
 * @property array orderFields
 * @property array orderDefaults
 * @property array orderRelations
 * @property array orderWith
 * @property array searchFields
 * @property string connection
 */
trait CustomOrderTrait
{
    /**
     * Check $orderFields and $orderDefaults are set
     *
     * @param string $orderField
     * @param string $direction
     * @return bool
     */
    protected function hasOrderFieldsAndDefaults($orderField, $direction)
    {
        return $this->hasOrderFields() && $this->hasOrderDefaults($orderField, $direction);
    }

    /**
     * Check $this->orderFields set correctly
     *
     * @return bool
     */
    protected function hasOrderFields()
    {
        return $this->hasProperty('orderFields');
    }

    /**
     * Check if array property exists
     *
     * @param string $attributeName
     * @param bool $canBeEmpty
     * @return bool
     */
    protected function hasProperty($attributeName, $canBeEmpty = true)
    {
        if (!$this->isValidProperty($attributeName, $canBeEmpty)) {
            throw new InvalidArgumentException(
                get_class($this) . ' ' . $attributeName . ' property not set correctly.'
            );
        }

        return true;
    }

    /**
     * Check if property exists and is array
     *
     * @param $attributeName
     * @param bool $canBeEmpty
     * @return bool
     */
    protected function isValidProperty($attributeName, $canBeEmpty = true)
    {
        return isset($this->$attributeName) && is_array($this->$attributeName)
            && ($canBeEmpty || !empty($this->$attributeName));
    }

    /**
     * Check order defaults set correctly
     *
     * @param string $orderField
     * @param string $direction
     * @return bool
     */
    protected function hasOrderDefaults($orderField, $direction)
    {
        if ($orderField === '' || $direction === '') {
            return $this->hasProperty('orderDefaults');
        }

        return true;
    }

    /**
     * Check $this->searchFields set correctly
     *
     * @return bool
     */
    protected function hasSearchFields()
    {
        return $this->hasProperty('searchFields', false);
    }

    /**
     * Override column if provided column not valid. If $column not in orderFields list, use default.
     *
     * @param string $column
     * @return string
     */
    protected function setOrderColumn($column)
    {
        if ($column == '' || !isset($this->orderFields[$column])) {
            $column = $this->orderDefaults['field'];
        }

        return $column;
    }

    /**
     * Override direction if provided direction not valid. If $direction not asc or desc, use default.
     *
     * @param string $direction
     * @return string
     */
    protected function setOrderDirection($direction)
    {
        if ($direction == '' || !in_array(strtoupper($direction), ['ASC', 'DESC'])) {
            $direction = $this->orderDefaults['dir'];
        }

        return $direction;
    }

    /**
     * Set order based on orderFields
     *
     * @param Builder $query
     * @param string $column
     * @param string $direction
     * @return Builder
     */
    protected function setOrder($query, $column, $direction)
    {
        if (is_array($this->orderFields[$column])) {
            return $this->setOrders($query, $column, $direction);
        }

        return $query->orderByCheckModel($this->orderFields[$column], $direction);
    }

    /**
     * Set order based on multiple orderFields
     *
     * @param Builder $query
     * @param string $column
     * @param string $direction
     * @return Builder
     */
    protected function setOrders($query, $column, $direction)
    {
        foreach ($this->orderFields[$column] as $dbField) {
            $query->orderByCheckModel($dbField, $direction);
        }

        return $query;
    }

    /**
     * Join a related table if not already joined
     *
     * @param Builder $query
     * @param string $table
     * @return Builder
     */
    protected function joinRelatedTable($query, $table)
    {
        if (isset($this->orderRelations[$table]) &&
            !$this->hasJoin($query, $table, $this->orderRelations[$table])) {
            $columnRelations = $this->orderRelations[$table];

            $query->modelJoin($columnRelations, '=', 'left', false, false);
        }

        return $query;
    }

    /**
     * Check if this model has already been joined to a table or relation
     *
     * @param Builder $builder
     * @param string $table
     * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
     * @return bool
     */
    protected function hasJoin(Builder $builder, $table, $relation)
    {
        if (!$this->isJoinedToTable($builder, $table)) {
            return $this->isEagerLoaded($builder, $relation);
        }

        return true;
    }

    /**
     * Check if model is currently joined to $table
     *
     * @param Builder $builder
     * @param string $table
     * @return bool
     */
    protected function isJoinedToTable(Builder $builder, $table)
    {
        $joins = $builder->getQuery()->joins;
        if (!empty($joins)) {
            foreach ($joins as $joinClause) {
                if ($joinClause->table == $table) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Check if relation exists in eager loads
     *
     * @param Builder $builder
     * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
     * @return bool
     */
    protected function isEagerLoaded(Builder $builder, $relation)
    {
        $eagerLoads = $builder->getEagerLoads();

        return !is_null($eagerLoads) && in_array($relation, $eagerLoads);
    }

    /**
     * Execute a scope in the order_width settings
     *
     * @param Builder $query
     * @param string $order
     * @return Builder
     */
    protected function addOrderWith(Builder $query, $order)
    {
        $with = 'with' . $this->orderWith[$order];

        return $query->$with();
    }

    /**
     * Add join from orderFields
     *
     * @param Builder $query
     * @param string $order
     * @return Builder
     */
    protected function addOrderJoin(Builder $query, $order)
    {
        $orderOption = (explode('.', $this->orderFields[$order]))[0];

        if (isset($this->orderRelations[$orderOption])) {
            $query->modelJoin(
                $this->orderRelations[$orderOption],
                '=',
                'left',
                false,
                false
            );
        }

        return $query;
    }
}


1			<?php
2
3			namespace Blasttech\EloquentRelatedPlus;
4
5			use Illuminate\Database\Eloquent\Builder;
6			use InvalidArgumentException;
7
8			/**
9			* Trait CustomOrderTrait
10			*
11			* @property array attributes
12			* @property array orderFields
13			* @property array orderDefaults
14			* @property array orderRelations
15			* @property array orderWith
16			* @property array searchFields
17			* @property string connection
18			*/
19			trait CustomOrderTrait
20			{
21			/**
22			* Check $orderFields and $orderDefaults are set
23			*
24			* @param string $orderField
25			* @param string $direction
26			* @return bool
27			*/
28			protected function hasOrderFieldsAndDefaults($orderField, $direction)
29			{
30			return $this->hasOrderFields() && $this->hasOrderDefaults($orderField, $direction);
31			}
32
33			/**
34			* Check $this->orderFields set correctly
35			*
36			* @return bool
37			*/
38			protected function hasOrderFields()
39			{
40			return $this->hasProperty('orderFields');
41			}
42
43			/**
44			* Check if array property exists
45			*
46			* @param string $attributeName
47			* @param bool $canBeEmpty
48			* @return bool
49			*/
50			protected function hasProperty($attributeName, $canBeEmpty = true)
51			{
52			if (!$this->isValidProperty($attributeName, $canBeEmpty)) {
53			throw new InvalidArgumentException(
54			get_class($this) . ' ' . $attributeName . ' property not set correctly.'
55			);
56			}
57
58			return true;
59			}
60
61			/**
62			* Check if property exists and is array
63			*
64			* @param $attributeName
65			* @param bool $canBeEmpty
66			* @return bool
67			*/
68			protected function isValidProperty($attributeName, $canBeEmpty = true)
69			{
70			return isset($this->$attributeName) && is_array($this->$attributeName)
71			&& ($canBeEmpty \|\| !empty($this->$attributeName));
72			}
73
74			/**
75			* Check order defaults set correctly
76			*
77			* @param string $orderField
78			* @param string $direction
79			* @return bool
80			*/
81			protected function hasOrderDefaults($orderField, $direction)
82			{
83			if ($orderField === '' \|\| $direction === '') {
84			return $this->hasProperty('orderDefaults');
85			}
86
87			return true;
88			}
89
90			/**
91			* Check $this->searchFields set correctly
92			*
93			* @return bool
94			*/
95			protected function hasSearchFields()
96			{
97			return $this->hasProperty('searchFields', false);
98			}
99
100			/**
101			* Override column if provided column not valid. If $column not in orderFields list, use default.
102			*
103			* @param string $column
104			* @return string
105			*/
106			protected function setOrderColumn($column)
107			{
108			if ($column == '' \|\| !isset($this->orderFields[$column])) {
109			$column = $this->orderDefaults['field'];
110			}
111
112			return $column;
113			}
114
115			/**
116			* Override direction if provided direction not valid. If $direction not asc or desc, use default.
117			*
118			* @param string $direction
119			* @return string
120			*/
121			protected function setOrderDirection($direction)
122			{
123			if ($direction == '' \|\| !in_array(strtoupper($direction), ['ASC', 'DESC'])) {
124			$direction = $this->orderDefaults['dir'];
125			}
126
127			return $direction;
128			}
129
130			/**
131			* Set order based on orderFields
132			*
133			* @param Builder $query
134			* @param string $column
135			* @param string $direction
136			* @return Builder
137			*/
138			protected function setOrder($query, $column, $direction)
139			{
140			if (is_array($this->orderFields[$column])) {
141			return $this->setOrders($query, $column, $direction);
142			}
143
144			return $query->orderByCheckModel($this->orderFields[$column], $direction);
145			}
146
147			/**
148			* Set order based on multiple orderFields
149			*
150			* @param Builder $query
151			* @param string $column
152			* @param string $direction
153			* @return Builder
154			*/
155			protected function setOrders($query, $column, $direction)
156			{
157			foreach ($this->orderFields[$column] as $dbField) {
158			$query->orderByCheckModel($dbField, $direction);
159			}
160
161			return $query;
162			}
163
164			/**
165			* Join a related table if not already joined
166			*
167			* @param Builder $query
168			* @param string $table
169			* @return Builder
170			*/
171			protected function joinRelatedTable($query, $table)
172			{
173			if (isset($this->orderRelations[$table]) &&
174			!$this->hasJoin($query, $table, $this->orderRelations[$table])) {
175			$columnRelations = $this->orderRelations[$table];
176
177			$query->modelJoin($columnRelations, '=', 'left', false, false);
178			}
179
180			return $query;
181			}
182
183			/**
184			* Check if this model has already been joined to a table or relation
185			*
186			* @param Builder $builder
187			* @param string $table
188			* @param \Illuminate\Database\Eloquent\Relations\Relation $relation
189			* @return bool
190			*/
191			protected function hasJoin(Builder $builder, $table, $relation)
192			{
193			if (!$this->isJoinedToTable($builder, $table)) {
194			return $this->isEagerLoaded($builder, $relation);
195			}
196
197			return true;
198			}
199
200			/**
201			* Check if model is currently joined to $table
202			*
203			* @param Builder $builder
204			* @param string $table
205			* @return bool
206			*/
207			protected function isJoinedToTable(Builder $builder, $table)
208			{
209			$joins = $builder->getQuery()->joins;
210			if (!empty($joins)) {
211			foreach ($joins as $joinClause) {
212			if ($joinClause->table == $table) {
213			return true;
214			}
215			}
216			}
217
218			return false;
219			}
220
221			/**
222			* Check if relation exists in eager loads
223			*
224			* @param Builder $builder
225			* @param \Illuminate\Database\Eloquent\Relations\Relation $relation
226			* @return bool
227			*/
228			protected function isEagerLoaded(Builder $builder, $relation)
229			{
230			$eagerLoads = $builder->getEagerLoads();
231
232			return !is_null($eagerLoads) && in_array($relation, $eagerLoads);
233			}
234
235			/**
236			* Execute a scope in the order_width settings
237			*
238			* @param Builder $query
239			* @param string $order
240			* @return Builder
241			*/
242			protected function addOrderWith(Builder $query, $order)
243			{
244			$with = 'with' . $this->orderWith[$order];
245
246			return $query->$with();
247			}
248
249			/**
250			* Add join from orderFields
251			*
252			* @param Builder $query
253			* @param string $order
254			* @return Builder
255			*/
256			protected function addOrderJoin(Builder $query, $order)
257			{
258			$orderOption = (explode('.', $this->orderFields[$order]))[0];
259
260			if (isset($this->orderRelations[$orderOption])) {
261			$query->modelJoin(
262			$this->orderRelations[$orderOption],
263			'=',
264			'left',
265			false,
266			false
267			);
268			}
269
270			return $query;
271			}
272			}
273

blasttech / eloquent-related-plus

CustomOrderTrait::setOrder() A last analyzed 2021-04-13 00:05 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CustomOrderTrait::setOrder() A
last analyzed 2021-04-13 00:05 UTC