HasDuplicates::duplicateRelationWithUnique() - Code Metrics - Neurony/laravel-duplicate - Measure and Improve Code Quality continuously with Scrutinizer

HasDuplicates::duplicateRelationWithUnique() B
last analyzed 2020-06-09 08:13 UTC

↳ Parent: HasDuplicates

Complexity

Conditions	7
Paths	3

Size

Total Lines

Duplication

Lines	10
Ratio	43.48 %

Importance

Changes

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

<?php

namespace Neurony\Duplicate\Traits;

use Closure;
use Exception;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Neurony\Duplicate\Helpers\RelationHelper;
use Neurony\Duplicate\Options\DuplicateOptions;

trait HasDuplicates
{
    /**
     * The container for all the options necessary for this trait.
     * Options can be viewed in the Neurony\Duplicate\Options\DuplicateOptions file.
     *
     * @var DuplicateOptions
     */
    protected $duplicateOptions;

    /**
     * Set the options for the HasDuplicates trait.
     *
     * @return DuplicateOptions
     */
    abstract public function getDuplicateOptions(): DuplicateOptions;

    /**
     * Register a duplicating model event with the dispatcher.
     *
     * @param Closure|string  $callback
     * @return void
     */
    public static function duplicating($callback): void
    {
        static::registerModelEvent('duplicating', $callback);
    }

    /**
     * Register a duplicated model event with the dispatcher.
     *
     * @param Closure|string  $callback
     * @return void
     */
    public static function duplicated($callback): void
    {
        static::registerModelEvent('duplicated', $callback);
    }

    /**
     * Duplicate a model instance and it's relations.
     *
     * @return Model|bool
     * @throws Exception
     */
    public function saveAsDuplicate()
    {
        try {
            if ($this->fireModelEvent('duplicating') === false) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                return false;
            }

            $this->initDuplicateOptions();

            $model = DB::transaction(function () {
                $model = $this->duplicateModel();

                if ($this->duplicateOptions->shouldDuplicateDeeply !== true) {
                    return $model;
                }

                foreach ($this->getRelationsForDuplication() as $relation => $attributes) {
                    if (RelationHelper::isChild($attributes['type'])) {
                        $this->duplicateDirectRelation($model, $relation);
                    }

                    if (RelationHelper::isPivoted($attributes['type'])) {
                        $this->duplicatePivotedRelation($model, $relation);
                    }
                }

                return $model;
            });

            $this->fireModelEvent('duplicated', false);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            return $model;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Get a replicated instance of the original model's instance.
     *
     * @return Model
     * @throws Exception
     */
    protected function duplicateModel(): Model
    {
        $model = $this->duplicateModelWithExcluding();
        $model = $this->duplicateModelWithUnique($model);

        $model->save();

        return $model;
    }

    /**
     * Duplicate a direct relation.
     * Subsequently save new relation records for the initial model instance.
     *
     * @param Model $model
     * @param string $relation
     * @return Model
     * @throws Exception
     */
    protected function duplicateDirectRelation(Model $model, string $relation): Model
    {
        $this->{$relation}()->get()->each(function ($rel) use ($model, $relation) {
            $rel = $this->duplicateRelationWithExcluding($rel, $relation);
            $rel = $this->duplicateRelationWithUnique($rel, $relation);

            $model->{$relation}()->save($rel);
        });

        return $model;
    }

    /**
     * Duplicate a pivoted relation.
     * Subsequently attach new pivot records corresponding to the relation for the initial model instance.
     *
     * @param Model $model
     * @param string $relation
     * @return Model
     * @throws Exception
     */
    protected function duplicatePivotedRelation(Model $model, string $relation): Model
    {
        $this->{$relation}()->get()->each(function ($rel) use ($model, $relation) {
            $attributes = $this->establishDuplicatablePivotAttributes($rel);

            $model->{$relation}()->attach($rel, $attributes);
        });

        return $model;
    }

    /**
     * Get the relations that should be duplicated alongside the original model.
     *
     * @return array
     * @throws \ReflectionException
     */
    protected function getRelationsForDuplication(): array
    {
        $relations = [];
        $excluded = $this->duplicateOptions->excludedRelations ?: [];

        foreach (RelationHelper::getModelRelations($this) as $relation => $attributes) {
            if (! in_array($relation, $excluded)) {
                $relations[$relation] = $attributes;
            }
        }

        return $relations;
    }

    /**
     * Replicate a model instance, excluding attributes provided in the model's getDuplicateOptions() method.
     *
     * @return Model
     */
    private function duplicateModelWithExcluding(): Model
    {
        $except = [];
        $excluded = $this->duplicateOptions->excludedColumns;

        if ($this->usesTimestamps()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $except = array_merge($except, [
                $this->getCreatedAtColumn(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                $this->getUpdatedAtColumn(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ]);
        }

        if ($excluded && is_array($excluded) && ! empty($excluded)) {
            $except = array_merge($except, $excluded);
        }

        return $this->replicate($except);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Update a model instance.
     * With unique values for the attributes provided in the model's getDuplicateOptions() method.
     *
     * @param Model $model
     * @return Model
     */
    private function duplicateModelWithUnique(Model $model): Model
    {
        $unique = $this->duplicateOptions->uniqueColumns;

        if (! $unique || ! is_array($unique) || empty($unique)) {
            return $model;
        }

        foreach ($unique as $column) {

            $i = 1;
            $original = $value = $model->{$column};

            while (static::withoutGlobalScopes()->where($column, $value)->first()) {
                $value = $original.' ('.$i++.')';

                $model->{$column} = $value;
            }
        }

        return $model;
    }

    /**
     * Replicate a model relation instance, excluding attributes provided in the model's getDuplicateOptions() method.
     *
     * @param Model $model
     * @param string $relation
     * @return Model
     */
    private function duplicateRelationWithExcluding(Model $model, string $relation): Model
    {
        $attributes = null;
        $excluded = $this->duplicateOptions->excludedRelationColumns;

        if ($excluded && is_array($excluded) && ! empty($excluded)) {
            if (array_key_exists($relation, $excluded)) {
                $attributes = $excluded[$relation];
            }
        }

        return $model->replicate($attributes);
    }

    /**
     * Update a relation for the model instance.
     * With unique values for the attributes attributes provided in the model's getDuplicateOptions() method.
     *
     * @param Model $model
     * @param string $relation
     * @return Model
     */
    private function duplicateRelationWithUnique(Model $model, string $relation): Model
    {
        $unique = $this->duplicateOptions->uniqueRelationColumns;

        if (! $unique || ! is_array($unique) || empty($unique)) {
            return $model;
        }

        if (array_key_exists($relation, $unique)) {
            foreach ($unique[$relation] as $column) {

                $i = 1;
                $original = $value = $model->{$column};

                while ($model->where($column, $value)->first()) {
                    $value = $original.' ('.$i++.')';

                    $model->{$column} = $value;
                }
            }
        }

        return $model;
    }

    /**
     * Get additional pivot attributes that should be saved when duplicating a pivoted relation.
     * Usually, these are attributes coming from the withPivot() method defined on the relation.
     *
     * @param Model $model
     * @return array
     */
    protected function establishDuplicatablePivotAttributes(Model $model): array
    {
        $pivot = $model->pivot;

        return Arr::except($pivot->getAttributes(), [
            $pivot->getKeyName(),
            $pivot->getForeignKey(),
            $pivot->getOtherKey(),
            $pivot->getCreatedAtColumn(),
            $pivot->getUpdatedAtColumn(),
        ]);
    }

    /**
     * Instantiate the duplicate options.
     *
     * @return void
     */
    protected function initDuplicateOptions(): void
    {
        if ($this->duplicateOptions === null) {
            $this->duplicateOptions = $this->getDuplicateOptions();
        }
    }
}


1		<?php
2
3		namespace Neurony\Duplicate\Traits;
4
5		use Closure;
6		use Exception;
7		use Illuminate\Database\Eloquent\Model;
8		use Illuminate\Support\Arr;
9		use Illuminate\Support\Facades\DB;
10		use Neurony\Duplicate\Helpers\RelationHelper;
11		use Neurony\Duplicate\Options\DuplicateOptions;
12
13		trait HasDuplicates
14		{
15		/**
16		* The container for all the options necessary for this trait.
17		* Options can be viewed in the Neurony\Duplicate\Options\DuplicateOptions file.
18		*
19		* @var DuplicateOptions
20		*/
21		protected $duplicateOptions;
22
23		/**
24		* Set the options for the HasDuplicates trait.
25		*
26		* @return DuplicateOptions
27		*/
28		abstract public function getDuplicateOptions(): DuplicateOptions;
29
30		/**
31		* Register a duplicating model event with the dispatcher.
32		*
33		* @param Closure\|string $callback
34		* @return void
35		*/
36		public static function duplicating($callback): void
37		{
38		static::registerModelEvent('duplicating', $callback);
39		}
40
41		/**
42		* Register a duplicated model event with the dispatcher.
43		*
44		* @param Closure\|string $callback
45		* @return void
46		*/
47		public static function duplicated($callback): void
48		{
49		static::registerModelEvent('duplicated', $callback);
50		}
51
52		/**
53		* Duplicate a model instance and it's relations.
54		*
55		* @return Model\|bool
56		* @throws Exception
57		*/
58		public function saveAsDuplicate()
59		{
60		try {
61		if ($this->fireModelEvent('duplicating') === false) {
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `fireModelEvent()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
62		return false;
63		}
64
65		$this->initDuplicateOptions();
66
67		$model = DB::transaction(function () {
68		$model = $this->duplicateModel();
69
70		if ($this->duplicateOptions->shouldDuplicateDeeply !== true) {
71		return $model;
72		}
73
74		foreach ($this->getRelationsForDuplication() as $relation => $attributes) {
75		if (RelationHelper::isChild($attributes['type'])) {
76		$this->duplicateDirectRelation($model, $relation);
77		}
78
79		if (RelationHelper::isPivoted($attributes['type'])) {
80		$this->duplicatePivotedRelation($model, $relation);
81		}
82		}
83
84		return $model;
85		});
86
87		$this->fireModelEvent('duplicated', false);
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `fireModelEvent()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
88
89		return $model;
90		} catch (Exception $e) {
91		throw $e;
92		}
93		}
94
95		/**
96		* Get a replicated instance of the original model's instance.
97		*
98		* @return Model
99		* @throws Exception
100		*/
101		protected function duplicateModel(): Model
102		{
103		$model = $this->duplicateModelWithExcluding();
104		$model = $this->duplicateModelWithUnique($model);
105
106		$model->save();
107
108		return $model;
109		}
110
111		/**
112		* Duplicate a direct relation.
113		* Subsequently save new relation records for the initial model instance.
114		*
115		* @param Model $model
116		* @param string $relation
117		* @return Model
118		* @throws Exception
119		*/
120		protected function duplicateDirectRelation(Model $model, string $relation): Model
121		{
122		$this->{$relation}()->get()->each(function ($rel) use ($model, $relation) {
123		$rel = $this->duplicateRelationWithExcluding($rel, $relation);
124		$rel = $this->duplicateRelationWithUnique($rel, $relation);
125
126		$model->{$relation}()->save($rel);
127		});
128
129		return $model;
130		}
131
132		/**
133		* Duplicate a pivoted relation.
134		* Subsequently attach new pivot records corresponding to the relation for the initial model instance.
135		*
136		* @param Model $model
137		* @param string $relation
138		* @return Model
139		* @throws Exception
140		*/
141		protected function duplicatePivotedRelation(Model $model, string $relation): Model
142		{
143		$this->{$relation}()->get()->each(function ($rel) use ($model, $relation) {
144		$attributes = $this->establishDuplicatablePivotAttributes($rel);
145
146		$model->{$relation}()->attach($rel, $attributes);
147		});
148
149		return $model;
150		}
151
152		/**
153		* Get the relations that should be duplicated alongside the original model.
154		*
155		* @return array
156		* @throws \ReflectionException
157		*/
158		protected function getRelationsForDuplication(): array
159		{
160		$relations = [];
161		$excluded = $this->duplicateOptions->excludedRelations ?: [];
162
163		foreach (RelationHelper::getModelRelations($this) as $relation => $attributes) {
164		if (! in_array($relation, $excluded)) {
165		$relations[$relation] = $attributes;
166		}
167		}
168
169		return $relations;
170		}
171
172		/**
173		* Replicate a model instance, excluding attributes provided in the model's getDuplicateOptions() method.
174		*
175		* @return Model
176		*/
177		private function duplicateModelWithExcluding(): Model
178		{
179		$except = [];
180		$excluded = $this->duplicateOptions->excludedColumns;
181
182		if ($this->usesTimestamps()) {
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `usesTimestamps()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
183		$except = array_merge($except, [
184		$this->getCreatedAtColumn(),
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `getCreatedAtColumn()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
185		$this->getUpdatedAtColumn(),
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `getUpdatedAtColumn()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
186		]);
187		}
188
189		if ($excluded && is_array($excluded) && ! empty($excluded)) {
190		$except = array_merge($except, $excluded);
191		}
192
193		return $this->replicate($except);
		0 ignored issues – show Bug introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report It seems like `replicate()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
194		}
195
196		/**
197		* Update a model instance.
198		* With unique values for the attributes provided in the model's getDuplicateOptions() method.
199		*
200		* @param Model $model
201		* @return Model
202		*/
203		private function duplicateModelWithUnique(Model $model): Model
204		{
205		$unique = $this->duplicateOptions->uniqueColumns;
206
207		if (! $unique \|\| ! is_array($unique) \|\| empty($unique)) {
208		return $model;
209		}
210
211	View Code Duplication	foreach ($unique as $column) {
		0 ignored issues – show Duplication introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
212		$i = 1;
213		$original = $value = $model->{$column};
214
215		while (static::withoutGlobalScopes()->where($column, $value)->first()) {
216		$value = $original.' ('.$i++.')';
217
218		$model->{$column} = $value;
219		}
220		}
221
222		return $model;
223		}
224
225		/**
226		* Replicate a model relation instance, excluding attributes provided in the model's getDuplicateOptions() method.
227		*
228		* @param Model $model
229		* @param string $relation
230		* @return Model
231		*/
232		private function duplicateRelationWithExcluding(Model $model, string $relation): Model
233		{
234		$attributes = null;
235		$excluded = $this->duplicateOptions->excludedRelationColumns;
236
237		if ($excluded && is_array($excluded) && ! empty($excluded)) {
238		if (array_key_exists($relation, $excluded)) {
239		$attributes = $excluded[$relation];
240		}
241		}
242
243		return $model->replicate($attributes);
244		}
245
246		/**
247		* Update a relation for the model instance.
248		* With unique values for the attributes attributes provided in the model's getDuplicateOptions() method.
249		*
250		* @param Model $model
251		* @param string $relation
252		* @return Model
253		*/
254		private function duplicateRelationWithUnique(Model $model, string $relation): Model
255		{
256		$unique = $this->duplicateOptions->uniqueRelationColumns;
257
258		if (! $unique \|\| ! is_array($unique) \|\| empty($unique)) {
259		return $model;
260		}
261
262		if (array_key_exists($relation, $unique)) {
263	View Code Duplication	foreach ($unique[$relation] as $column) {
		0 ignored issues – show Duplication introduced 2019-03-22 16:33 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
264		$i = 1;
265		$original = $value = $model->{$column};
266
267		while ($model->where($column, $value)->first()) {
268		$value = $original.' ('.$i++.')';
269
270		$model->{$column} = $value;
271		}
272		}
273		}
274
275		return $model;
276		}
277
278		/**
279		* Get additional pivot attributes that should be saved when duplicating a pivoted relation.
280		* Usually, these are attributes coming from the withPivot() method defined on the relation.
281		*
282		* @param Model $model
283		* @return array
284		*/
285		protected function establishDuplicatablePivotAttributes(Model $model): array
286		{
287		$pivot = $model->pivot;
288
289		return Arr::except($pivot->getAttributes(), [
290		$pivot->getKeyName(),
291		$pivot->getForeignKey(),
292		$pivot->getOtherKey(),
293		$pivot->getCreatedAtColumn(),
294		$pivot->getUpdatedAtColumn(),
295		]);
296		}
297
298		/**
299		* Instantiate the duplicate options.
300		*
301		* @return void
302		*/
303		protected function initDuplicateOptions(): void
304		{
305		if ($this->duplicateOptions === null) {
306		$this->duplicateOptions = $this->getDuplicateOptions();
307		}
308		}
309		}
310

Neurony / laravel-duplicate

GitHub Access Token became invalid

HasDuplicates::duplicateRelationWithUnique() B last analyzed 2020-06-09 08:13 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HasDuplicates::duplicateRelationWithUnique() B
last analyzed 2020-06-09 08:13 UTC