UserIdentities::bootUserIdentities() - Code Metrics - akalongman/laravel-lodash - Measure and Improve Code Quality continuously with Scrutinizer

UserIdentities::bootUserIdentities() B
last analyzed 2021-03-16 10:54 UTC

↳ Parent: UserIdentities

Complexity

Conditions	9
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	90

Importance

Changes

Metric	Value
cc	9
nc	2
nop	0
dl	0
loc	53
ccs	0
cts	30
cp	0
crap	90
rs	7.4698
c	0
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace Longman\LaravelLodash\Eloquent;

use App\Models\User;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\SoftDeletes;
use InvalidArgumentException;

use function auth;
use function class_exists;
use function class_uses_recursive;
use function get_class;
use function in_array;
use function is_null;

/**
 * @mixin \Illuminate\Database\Eloquent\Model
 * @property \Illuminate\Contracts\Auth\Authenticatable $creator
 * @property \Illuminate\Contracts\Auth\Authenticatable $editor
 * @property \Illuminate\Contracts\Auth\Authenticatable $destroyer
 */
trait UserIdentities
{
    protected $userIdentities = true;
    protected $columnCreatedBy = 'created_by';
    protected $columnUpdatedBy = 'updated_by';
    protected $columnDeletedBy = 'deleted_by';

    /**
     * Define an inverse one-to-one or many relationship.
     *
     * @param string $related
     * @param string $foreignKey
     * @param string $ownerKey
     * @param string $relation
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    abstract public function belongsTo($related, $foreignKey = null, $ownerKey = null, $relation = null);

    public static function usingSoftDeletes(): bool
    {
        static $usingSoftDeletes;

        if (is_null($usingSoftDeletes)) {
            return $usingSoftDeletes = in_array(SoftDeletes::class, class_uses_recursive(static::class));
        }

        return $usingSoftDeletes;
    }

    public function creator(): BelongsTo
    {
        return $this->belongsTo($this->getUserClass(), $this->columnCreatedBy);
    }

    public function editor(): BelongsTo
    {
        return $this->belongsTo($this->getUserClass(), $this->columnUpdatedBy);
    }

    public function destroyer(): BelongsTo
    {
        return $this->belongsTo($this->getUserClass(), $this->columnDeletedBy);
    }

    public function usesUserIdentities(): bool
    {
        return $this->userIdentities;
    }

    public function stopUserIdentities(): self
    {
        $this->userIdentities = false;

        return $this;
    }

    public function startUserIdentities(): self
    {
        $this->userIdentities = true;

        return $this;
    }

    protected static function bootUserIdentities(): void
    {
        // Creating
        static::creating(static function (Model $model) {
            if (! $model->usesUserIdentities()) {
                return;
            }

            if (is_null($model->{$model->columnCreatedBy})) {
                $model->{$model->columnCreatedBy} = auth()->id();
            }

            if (! is_null($model->{$model->columnUpdatedBy})) {
                return;
            }

            $model->{$model->columnUpdatedBy} = auth()->id();
        });

        // Updating
        static::updating(static function (Model $model) {
            if (! $model->usesUserIdentities()) {
                return;
            }

            $model->{$model->columnUpdatedBy} = auth()->id();
        });

        // Deleting/Restoring
        if (! static::usingSoftDeletes()) {
            return;
        }

        static::deleting(static function (Model $model) {
            if (! $model->usesUserIdentities()) {
                return;
            }

            if (is_null($model->{$model->columnDeletedBy})) {
                $model->{$model->columnDeletedBy} = auth()->id();
            }

            $model->save();
        });

        static::restoring(static function (Model $model) {
            if (! $model->usesUserIdentities()) {
                return;
            }

            $model->{$model->columnDeletedBy} = null;
        });
    }

    protected function getUserClass(): string
    {
        $provider = auth()->guard()->getProvider();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        if ($provider) {
            return $provider->getModel();
        }

        $user = auth()->guard()->user();
        if ($user) {
            return get_class($user);
        }

        if (class_exists(User::class)) {
            return User::class;
        }

        throw new InvalidArgumentException('User class can not detected');
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Longman\LaravelLodash\Eloquent;
6
7			use App\Models\User;
8			use Illuminate\Database\Eloquent\Model;
9			use Illuminate\Database\Eloquent\Relations\BelongsTo;
10			use Illuminate\Database\Eloquent\SoftDeletes;
11			use InvalidArgumentException;
12
13			use function auth;
14			use function class_exists;
15			use function class_uses_recursive;
16			use function get_class;
17			use function in_array;
18			use function is_null;
19
20			/**
21			* @mixin \Illuminate\Database\Eloquent\Model
22			* @property \Illuminate\Contracts\Auth\Authenticatable $creator
23			* @property \Illuminate\Contracts\Auth\Authenticatable $editor
24			* @property \Illuminate\Contracts\Auth\Authenticatable $destroyer
25			*/
26			trait UserIdentities
27			{
28			protected $userIdentities = true;
29			protected $columnCreatedBy = 'created_by';
30			protected $columnUpdatedBy = 'updated_by';
31			protected $columnDeletedBy = 'deleted_by';
32
33			/**
34			* Define an inverse one-to-one or many relationship.
35			*
36			* @param string $related
37			* @param string $foreignKey
38			* @param string $ownerKey
39			* @param string $relation
40			* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
41			*/
42			abstract public function belongsTo($related, $foreignKey = null, $ownerKey = null, $relation = null);
43
44			public static function usingSoftDeletes(): bool
45			{
46			static $usingSoftDeletes;
47
48			if (is_null($usingSoftDeletes)) {
49			return $usingSoftDeletes = in_array(SoftDeletes::class, class_uses_recursive(static::class));
50			}
51
52			return $usingSoftDeletes;
53			}
54
55			public function creator(): BelongsTo
56			{
57			return $this->belongsTo($this->getUserClass(), $this->columnCreatedBy);
58			}
59
60			public function editor(): BelongsTo
61			{
62			return $this->belongsTo($this->getUserClass(), $this->columnUpdatedBy);
63			}
64
65			public function destroyer(): BelongsTo
66			{
67			return $this->belongsTo($this->getUserClass(), $this->columnDeletedBy);
68			}
69
70			public function usesUserIdentities(): bool
71			{
72			return $this->userIdentities;
73			}
74
75			public function stopUserIdentities(): self
76			{
77			$this->userIdentities = false;
78
79			return $this;
80			}
81
82			public function startUserIdentities(): self
83			{
84			$this->userIdentities = true;
85
86			return $this;
87			}
88
89			protected static function bootUserIdentities(): void
90			{
91			// Creating
92			static::creating(static function (Model $model) {
93			if (! $model->usesUserIdentities()) {
94			return;
95			}
96
97			if (is_null($model->{$model->columnCreatedBy})) {
98			$model->{$model->columnCreatedBy} = auth()->id();
99			}
100
101			if (! is_null($model->{$model->columnUpdatedBy})) {
102			return;
103			}
104
105			$model->{$model->columnUpdatedBy} = auth()->id();
106			});
107
108			// Updating
109			static::updating(static function (Model $model) {
110			if (! $model->usesUserIdentities()) {
111			return;
112			}
113
114			$model->{$model->columnUpdatedBy} = auth()->id();
115			});
116
117			// Deleting/Restoring
118			if (! static::usingSoftDeletes()) {
119			return;
120			}
121
122			static::deleting(static function (Model $model) {
123			if (! $model->usesUserIdentities()) {
124			return;
125			}
126
127			if (is_null($model->{$model->columnDeletedBy})) {
128			$model->{$model->columnDeletedBy} = auth()->id();
129			}
130
131			$model->save();
132			});
133
134			static::restoring(static function (Model $model) {
135			if (! $model->usesUserIdentities()) {
136			return;
137			}
138
139			$model->{$model->columnDeletedBy} = null;
140			});
141			}
142
143			protected function getUserClass(): string
144			{
145			$provider = auth()->guard()->getProvider();
			0 ignored issues – show Bug introduced 2021-01-05 01:30 UTC by Report Bug Copy Issue Report The method `guard` does only exist in `Illuminate\Contracts\Auth\Factory`, but not in `Illuminate\Contracts\Auth\Guard`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
146			if ($provider) {
147			return $provider->getModel();
148			}
149
150			$user = auth()->guard()->user();
151			if ($user) {
152			return get_class($user);
153			}
154
155			if (class_exists(User::class)) {
156			return User::class;
157			}
158
159			throw new InvalidArgumentException('User class can not detected');
160			}
161			}
162

akalongman / laravel-lodash

UserIdentities::bootUserIdentities() B last analyzed 2021-03-16 10:54 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like

UserIdentities::bootUserIdentities() B
last analyzed 2021-03-16 10:54 UTC