HasRoutine::setRoutineAttribute() - Code Metrics - SierraTecnologia/Telefonica - Measure and Improve Code Quality continuously with Scrutinizer

HasRoutine::setRoutineAttribute() A
last analyzed 2021-05-27 23:00 UTC

↳ Parent: HasRoutine

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

/**
 * @todo Mt bom, analisar
 */
namespace Telefonica\Traits;

use InvalidArgumentException;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Casa\Models\Economic\Routine;

trait HasRoutine
{
    protected $queuedRoutine = [];

    public static function getRoutineClassName(): string
    {
        return Routine::class;
    }

    public static function bootHasRoutine()

    {
        static::created(
            function (Model $routineableModel) {
                if (count($routineableModel->queuedRoutine) > 0) {
                    $routineableModel->attachRoutine($routineableModel->queuedRoutine);

                    $routineableModel->queuedRoutine = [];
                }
            }
        );

        static::deleted(
            function (Model $deletedModel) {
                $routines = $deletedModel->routines()->get();

                $deletedModel->detachRoutine($routines);
            }
        );
    }

    public function routines(): MorphToMany
    {
        return $this
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->morphToMany(self::getRoutineClassName(), 'routineable')
            ->ordered();
    }

    /**
     * @param string $locale
     */
    public function routinesTranslated($locale = null): MorphToMany

    {
        $locale = ! is_null($locale) ? $locale : app()->getLocale();

        return $this
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->morphToMany(self::getRoutineClassName(), 'routineable')
            ->select('*')
            ->selectRaw("JSON_UNQUOTE(JSON_EXTRACT(name, '$.\"{$locale}\"')) as name_translated")
            ->selectRaw("JSON_UNQUOTE(JSON_EXTRACT(slug, '$.\"{$locale}\"')) as slug_translated")
            ->ordered();
    }

    /**
     * @param string|array|\ArrayAccess|\\App\Models\Routine $routines
     */
    public function setRoutineAttribute($routines)
    {
        if (! $this->exists) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $this->queuedRoutine = $routines;

            return;
        }

        $this->attachRoutine($routines);
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder   $query
     * @param array|\ArrayAccess|\\App\Models\Routine $routines
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWithAllRoutine(Builder $query, $routines, string $type = null): Builder

    {
        $routines = static::convertToRoutine($routines, $type);

        collect($routines)->each(
            function ($routine) use ($query) {
                $query->whereHas(
                    'routines', function (Builder $query) use ($routine) {
                        $query->where('routines.id', $routine ? $routine->id : 0);
                    }
                );
            }
        );

        return $query;
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder   $query
     * @param array|\ArrayAccess|\\App\Models\Routine $routines
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWithAnyRoutine(Builder $query, $routines, string $type = null): Builder

    {
        $routines = static::convertToRoutine($routines, $type);

        return $query->whereHas(
            'routines', function (Builder $query) use ($routines) {
                $routineIds = collect($routines)->pluck('id');

                $query->whereIn('routines.id', $routineIds);
            }
        );
    }

    public function scopeWithAllRoutineOfAnyType(Builder $query, $routines): Builder

    {
        $routines = static::convertToRoutineOfAnyType($routines);

        collect($routines)->each(
            function ($routine) use ($query) {
                $query->whereHas(
                    'routines', function (Builder $query) use ($routine) {
                        $query->where('routines.id', $routine ? $routine->id : 0);
                    }
                );
            }
        );

        return $query;
    }

    public function scopeWithAnyRoutineOfAnyType(Builder $query, $routines): Builder

    {
        $routines = static::convertToRoutineOfAnyType($routines);

        return $query->whereHas(
            'routines', function (Builder $query) use ($routines) {
                $routineIds = collect($routines)->pluck('id');

                $query->whereIn('routines.id', $routineIds);
            }
        );
    }

    public function routinesWithType(string $type = null): Collection
    {
        return $this->routines->filter(
class MyClass { }

$x = new MyClass();
$x->foo = true;
            function (Routine $routine) use ($type) {
                return $routine->type === $type;
            }
        );
    }

    /**
     * @param array|\ArrayAccess|\\App\Models\Routine $routines
     *
     * @return $this
     */
    public function attachRoutine($routines)

    {
        $className = static::getRoutineClassName();

        $routines = collect($className::findOrCreate($routines));

        $this->routines()->syncWithoutDetaching($routines->pluck('id')->toArray());

        return $this;
    }

    /**
     * @param string|\\App\Models\Routine $routine
     *
     * @return $this
     */
    public function detachRoutine($routine)
    {
        return $this->detachRoutine([$routine]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @param array|\ArrayAccess $routines
     *
     * @return $this
     */
    public function syncRoutine($routines)

    {
        $className = static::getRoutineClassName();

        $routines = collect($className::findOrCreate($routines));

        $this->routines()->sync($routines->pluck('id')->toArray());

        return $this;
    }

    /**
     * @param array|\ArrayAccess $routines
     * @param string|null        $type
     *
     * @return $this
     */
    public function syncRoutineWithType($routines, string $type = null)

    {
        $className = static::getRoutineClassName();

        $routines = collect($className::findOrCreate($routines, $type));

        $this->syncRoutineIds($routines->pluck('id')->toArray(), $type);

        return $this;
    }

    protected static function convertToRoutine($values, $type = null, $locale = null)

    {
        return collect($values)->map(
            function ($value) use ($type, $locale) {
                if ($value instanceof Routine) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
                    if (isset($type) && $value->type != $type) {
                        throw new InvalidArgumentException("Type was set to {$type} but routine is of type {$value->type}");
                    }

                    return $value;
                }

                $className = static::getRoutineClassName();

                return $className::findFromString($value, $type, $locale);
            }
        );
    }

    protected static function convertToRoutineOfAnyType($values, $locale = null)

    {
        return collect($values)->map(
            function ($value) use ($locale) {
                if ($value instanceof Routine) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
                    return $value;
                }

                $className = static::getRoutineClassName();

                return $className::findFromStringOfAnyType($value, $locale);
            }
        );
    }

    /**
     * Use in place of eloquent's sync() method so that the routine type may be optionally specified.
     *
     * @param $ids
     * @param string|null $type
     * @param bool        $detaching
     */
    protected function syncRoutineIds($ids, string $type = null, $detaching = true)

    {
        $isUpdated = false;

        // Get a list of routine_ids for all current routines
        $current = $this->routines()
            ->newPivotStatement()
            ->where('routineable_id', $this->getKey())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->where('routineable_type', $this->getMorphClass())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->when(
                $type !== null, function ($query) use ($type) {
                    $routineModel = $this->routines()->getRelated();

                    return $query->join(
                        $routineModel->getTable(),
                        'routineables.routine_id',
                        '=',
                        $routineModel->getTable().'.'.$routineModel->getKeyName()
                    )
                        ->where('routines.type', $type);
                }
            )
            ->pluck('routine_id')
            ->all();

        // Compare to the list of ids given to find the routines to remove
        $detach = array_diff($current, $ids);
        if ($detaching && count($detach) > 0) {
            $this->routines()->detach($detach);
            $isUpdated = true;
        }

        // Attach any new ids
        $attach = array_diff($ids, $current);
        if (count($attach) > 0) {
            collect($attach)->each(
                function ($id) {
                    $this->routines()->attach($id, []);
                }
            );
            $isUpdated = true;
        }

        // Once we have finished attaching or detaching the records, we will see if we
        // have done any attaching or detaching, and if we have we will touch these
        // relationships if they are configured to touch on any database updates.
        if ($isUpdated) {
            $this->routines()->touchIfTouching();
        }
    }
}


HasRoutine::setRoutineAttribute() A
last analyzed 2021-05-27 23:00 UTC

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1		<?php
2
3		/**
4		* @todo Mt bom, analisar
5		*/
6		namespace Telefonica\Traits;
7
8		use InvalidArgumentException;
9		use Illuminate\Database\Eloquent\Model;
10		use Illuminate\Database\Eloquent\Builder;
11		use Illuminate\Database\Eloquent\Collection;
12		use Illuminate\Database\Eloquent\Relations\MorphToMany;
13		use Casa\Models\Economic\Routine;
14
15		trait HasRoutine
16		{
17		protected $queuedRoutine = [];
18
19		public static function getRoutineClassName(): string
20		{
21		return Routine::class;
22		}
23
24	View Code Duplication	public static function bootHasRoutine()
		0 ignored issues – show Duplication introduced 2020-07-20 09:15 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
25		{
26		static::created(
27		function (Model $routineableModel) {
28		if (count($routineableModel->queuedRoutine) > 0) {
29		$routineableModel->attachRoutine($routineableModel->queuedRoutine);
30
31		$routineableModel->queuedRoutine = [];
32		}
33		}
34		);
35
36		static::deleted(
37		function (Model $deletedModel) {
38		$routines = $deletedModel->routines()->get();
39

SierraTecnologia / Telefonica

HasRoutine::setRoutineAttribute() A last analyzed 2021-05-27 23:00 UTC

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like

HasRoutine::setRoutineAttribute() A
last analyzed 2021-05-27 23:00 UTC