UserService - Code Metrics - Inspection of "changes" - SherifElfadaly/Laravel-Api-Skeleton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bfbb50...8023d3 )

by Sherif

created 2020-04-19 23:53 UTC

UserService A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	372
Duplicated Lines	2.96 %

Coupling/Cohesion

Components	3
Dependencies	6

Importance

Changes

Metric	Value
wmc	42
lcom	3
cbo	6
dl	11
loc	372
rs	9.0399
c	0
b	0
f	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	account()	0	13	2
A	can()	0	22	3
A	hasRoles()	0	4	3
A	assignRoles()	11	11	1
A	login()	0	12	5
A	loginSocial()	0	15	4
A	register()	0	15	3
A	block()	0	8	2
A	unblock()	0	4	1
A	sendReset()	0	9	2
A	resetPassword()	0	29	5
A	changePassword()	0	9	2
A	confirmEmail()	0	8	2
A	sendConfirmationEmail()	0	10	2
A	saveProfile()	0	14	2
A	logout()	0	4	1
A	refreshToken()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like UserService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use UserService, and based on these observations, apply Extract Interface, too.

<?php

namespace App\Modules\Users\Services;

use App\Modules\Core\BaseClasses\BaseService;
use Illuminate\Support\Arr;
use App\Modules\Users\Repositories\UserRepository;
use App\Modules\Permissions\Services\PermissionService;
use App\Modules\OauthClients\Services\OauthClientService;
use App\Modules\Notifications\Services\NotificationService;
use App\Modules\Users\Proxy\LoginProxy;

class UserService extends BaseService
{
    /**
     * @var PermissionService
     */
    protected $permissionService;

    /**
     * @var LoginProxy
     */
    protected $loginProxy;

    /**
     * @var NotificationService
     */
    protected $notificationService;

    /**
     * @var OauthClientService
     */
    protected $oauthClientService;

    /**
     * Init new object.
     *
     * @param   UserRepository       $repo
     * @param   PermissionService    $permissionService
     * @param   LoginProxy           $loginProxy
     * @param   NotificationService  $notificationService
     * @param   OauthClientService   $oauthClientService
     * @return  void

     */
    public function __construct(
        UserRepository $repo,
        PermissionService $permissionService,
        LoginProxy $loginProxy,
        NotificationService $notificationService,
        OauthClientService $oauthClientService
    ) {
        $this->permissionService   = $permissionService;
        $this->loginProxy          = $loginProxy;
        $this->notificationService = $notificationService;
        $this->oauthClientService  = $oauthClientService;
        parent::__construct($repo);
    }

    /**
     * Return the logged in user account.
     *
     * @param  array   $relations
     * @return boolean
     */
    public function account($relations = ['roles.permissions'])
    {
        $permissions = [];
        $user        = $this->repo->find(\Auth::id(), $relations);
        foreach ($user->roles as $role) {
            $role->permissions->each(function ($permission) use (&$permissions) {
                $permissions[$permission->repo][$permission->id] = $permission->name;
            });
        }
        $user->permissions = $permissions;

        return $user;
    }

    /**
     * Check if the logged in user or the given user
     * has the given permissions on the given model.
     *
     * @param  string $permissionName
     * @param  string $model
     * @param  mixed  $userId
     * @return boolean
     */
    public function can($permissionName, $model, $userId = false)
    {
        $permission = $this->permissionService->first([
            'and' => [
                'model' => $model,
                'name'  => $permissionName,
                'roles' => [
                    'op' => 'has',
                    'val' => [
                        'users' => [
                            'op' => 'has',
                            'val' => [
                                'users.id' => $userId ?: \Auth::id()
                            ]
                        ]
                    ]
                ]
            ]
        ]);

        return $permission ? true : false;
    }

    /**
     * Check if the logged in or the given user has the given role.
     *
     * @param  string[] $roles
     * @param  mixed    $user
     * @return boolean
     */
    public function hasRoles($roles, $user = false)
    {
        return $this->repo->countRoles($user ?: \Auth::id(), $roles) ? true : false;
    }

    /**
     * Assign the given role ids to the given user.
     *
     * @param  integer $userId
     * @param  array   $roleIds
     * @return object
     */
    public function assignRoles($userId, $roleIds)

    {
        $user = false;
        \DB::transaction(function () use ($userId, $roleIds, &$user) {
            $user = $this->repo->find($userId);
            $this->repo->detachPermissions($userId);
            $this->repo->attachPermissions($userId, $roleIds);
        });

        return $user;
    }

    /**
     * Handle the login request to the application.
     *
     * @param  string  $email
     * @param  string  $password
     * @param  string  $role
     * @return object
     */
    public function login($email, $password, $role = false)

    {
        if (! $user = $this->repo->first(['email' => $email])) {
            \Errors::loginFailed();
        } elseif ($user->blocked) {
            \Errors::userIsBlocked();
        } elseif (! config('skeleton.disable_confirm_email') && ! $user->confirmed) {
            \Errors::emailNotConfirmed();
        }

        return ['user' => $user, 'tokens' => $this->loginProxy->login($user->email, $password)];
    }

    /**
     * Handle the social login request to the application.
     *
     * @param  string $authCode
     * @param  string $accessToken
     * @return array
     */
    public function loginSocial($authCode, $accessToken, $type)
    {
        $access_token = $authCode ? Arr::get(\Socialite::driver($type)->getAccessTokenResponse($authCode), 'access_token') : $accessToken;
        $user         = \Socialite::driver($type)->userFromToken($access_token);

        if (! $user->email) {
            \Errors::noSocialEmail();
        }

        if (! $this->repo->first(['email' => $user->email])) {
            $this->register($user->email, '', true);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        return $this->loginProxy->login($user->email, config('skeleton.social_pass'));
    }
    
    /**
     * Handle the registration request.
     *
     * @param  string  $name
     * @param  string  $email
     * @param  string  $password
     * @param  boolean $skipConfirmEmail
     * @return array
     */
    public function register($name, $email, $password, $skipConfirmEmail = false)
    {
        $user = $this->repo->save([
            'name'      => $name,
            'email'     => $email,
            'password'  => $password,
            'confirmed' => $skipConfirmEmail
        ]);

        if (! $skipConfirmEmail && ! config('skeleton.disable_confirm_email')) {
            $this->sendConfirmationEmail($user->email);
        }

        return $user;
    }
    
    /**
     * Block the user.
     *
     * @param  integer $userId
     * @return object
     */
    public function block($userId)
    {
        if (\Auth::id() == $userId) {
            \Errors::noPermissions();
        }
        
        return $this->repo->save(['id' => $userId, 'blocked' => 1]);
    }

    /**
     * Unblock the user.
     *
     * @param  integer $userId
     * @return object
     */
    public function unblock($userId)
    {
        return $this->repo->save(['id' => $userId, 'blocked' => 0]);
    }

    /**
     * Send a reset link to the given user.
     *
     * @param  string  $email
     * @return void
     */
    public function sendReset($email)
    {
        if (! $user = $this->repo->first(['email' => $email])) {
            \Errors::notFound('email');
        }

        $token = \Password::getService()->create($user);
        $this->notificationService->notify($user, 'ResetPassword', $token);
    }

    /**
     * Reset the given user's password.
     *
     * @param   string  $email
     * @param   string  $password
     * @param   string  $passwordConfirmation
     * @param   string  $token
     * @return string|void
     */
    public function resetPassword($email, $password, $passwordConfirmation, $token)
    {
        $response = \Password::reset([
            'email'                 => $email,
            'password'              => $password,
            'password_confirmation' => $passwordConfirmation,
            'token'                 => $token
        ], function ($user, $password) {
            $this->repo->save(['id' => $user->id, 'password' => $password]);
        });

        switch ($response) {
            case \Password::PASSWORD_RESET:
                return 'success';
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case \Password::INVALID_TOKEN:
                \Errors::invalidResetToken();
                break;

            case \Password::INVALID_PASSWORD:
                \Errors::invalidResetPassword();
                break;

            case \Password::INVALID_USER:
                \Errors::notFound('user');
                break;
        }
    }

    /**
     * Change the logged in user password.
     *
     * @param  string  $password
     * @param  string  $oldPassword
     * @return void
     */
    public function changePassword($password, $oldPassword)
    {
        $user = \Auth::user();
        if (! \Hash::check($oldPassword, $user->password)) {
            \Errors::invalidOldPassword();
        }

        $this->repo->save(['id' => $user->id, 'password' => $password]);
    }

    /**
     * Confirm email using the confirmation code.
     *
     * @param  string $confirmationCode
     * @return void
     */
    public function confirmEmail($confirmationCode)
    {
        if (! $user = $this->repo->first(['confirmation_code' => $confirmationCode])) {
            \Errors::invalidConfirmationCode();
        }

        $this->repo->save(['id' => $user->id, 'confirmed' => 1, 'confirmation_code' => null]);
    }

    /**
     * Send the confirmation mail.
     *
     * @param  string $email
     * @return void
     */
    public function sendConfirmationEmail($email)
    {
        $user = $this->repo->first(['email' => $email]);
        if ($user->confirmed) {
            \Errors::emailAlreadyConfirmed();
        }

        $this->repo->save(['id' => $user->id, 'confirmation_code' => sha1(microtime())]);
        $this->notificationService->notify($user, 'ConfirmEmail');
    }

    /**
     * Save the given data to the logged in user.
     *
     * @param  string $name
     * @param  string $email
     * @param  string $profilePicture
     * @return void
     */
    public function saveProfile($name, $email, $profilePicture = false)
    {
        if ($profilePicture) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $data['profile_picture'] = \Media::uploadImageBas64($profilePicture, 'users/profile_pictures');
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        }
        
        $data['id'] = \Auth::id();
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        return $this->repo->save([
            'id'             => \Auth::id(),
            'name'           => $name,
            'email'          => $email,
            'profilePicture' => $profilePicture,
        ]);
    }

    /**
     * Logs out the user, revoke access token and refresh token.
     *
     * @return void
     */
    public function logout()
    {
        $this->oauthClientService->revokeAccessToken(\Auth::user()->token());
    }

    /**
     * Attempt to refresh the access token using the given refresh token.
     *
     * @param  string $refreshToken
     * @return array
     */
    public function refreshToken($refreshToken)
    {
        return $this->loginProxy->refreshToken($refreshToken);
    }
}


1		<?php
2
3		namespace App\Modules\Users\Services;
4
5		use App\Modules\Core\BaseClasses\BaseService;
6		use Illuminate\Support\Arr;
7		use App\Modules\Users\Repositories\UserRepository;
8		use App\Modules\Permissions\Services\PermissionService;
9		use App\Modules\OauthClients\Services\OauthClientService;
10		use App\Modules\Notifications\Services\NotificationService;
11		use App\Modules\Users\Proxy\LoginProxy;
12
13		class UserService extends BaseService
14		{
15		/**
16		* @var PermissionService
17		*/
18		protected $permissionService;
19
20		/**
21		* @var LoginProxy
22		*/
23		protected $loginProxy;
24
25		/**
26		* @var NotificationService
27		*/
28		protected $notificationService;
29
30		/**
31		* @var OauthClientService
32		*/
33		protected $oauthClientService;
34
35		/**
36		* Init new object.
37		*
38		* @param UserRepository $repo
39		* @param PermissionService $permissionService
40		* @param LoginProxy $loginProxy
41		* @param NotificationService $notificationService
42		* @param OauthClientService $oauthClientService
43		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2020-03-30 10:13 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
44		*/
45		public function __construct(
46		UserRepository $repo,
47		PermissionService $permissionService,
48		LoginProxy $loginProxy,
49		NotificationService $notificationService,
50		OauthClientService $oauthClientService
51		) {
52		$this->permissionService = $permissionService;
53		$this->loginProxy = $loginProxy;
54		$this->notificationService = $notificationService;
55		$this->oauthClientService = $oauthClientService;
56		parent::__construct($repo);
57		}
58
59		/**
60		* Return the logged in user account.
61		*
62		* @param array $relations
63		* @return boolean
64		*/
65		public function account($relations = ['roles.permissions'])
66		{
67		$permissions = [];
68		$user = $this->repo->find(\Auth::id(), $relations);
69		foreach ($user->roles as $role) {
70		$role->permissions->each(function ($permission) use (&$permissions) {
71		$permissions[$permission->repo][$permission->id] = $permission->name;
72		});
73		}
74		$user->permissions = $permissions;
75
76		return $user;
77		}
78
79		/**
80		* Check if the logged in user or the given user
81		* has the given permissions on the given model.
82		*
83		* @param string $permissionName
84		* @param string $model
85		* @param mixed $userId
86		* @return boolean
87		*/
88		public function can($permissionName, $model, $userId = false)
89		{
90		$permission = $this->permissionService->first([
91		'and' => [
92		'model' => $model,
93		'name' => $permissionName,
94		'roles' => [
95		'op' => 'has',
96		'val' => [
97		'users' => [
98		'op' => 'has',
99		'val' => [
100		'users.id' => $userId ?: \Auth::id()
101		]
102		]
103		]
104		]
105		]
106		]);
107
108		return $permission ? true : false;
109		}
110
111		/**
112		* Check if the logged in or the given user has the given role.
113		*
114		* @param string[] $roles
115		* @param mixed $user
116		* @return boolean
117		*/
118		public function hasRoles($roles, $user = false)
119		{
120		return $this->repo->countRoles($user ?: \Auth::id(), $roles) ? true : false;
121		}
122
123		/**
124		* Assign the given role ids to the given user.
125		*
126		* @param integer $userId
127		* @param array $roleIds
128		* @return object
129		*/
130	View Code Duplication	public function assignRoles($userId, $roleIds)
		0 ignored issues – show Duplication introduced 2020-03-30 10:13 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...
131		{
132		$user = false;
133		\DB::transaction(function () use ($userId, $roleIds, &$user) {
134		$user = $this->repo->find($userId);
135		$this->repo->detachPermissions($userId);
136		$this->repo->attachPermissions($userId, $roleIds);
137		});
138
139		return $user;
140		}
141
142		/**
143		* Handle the login request to the application.
144		*
145		* @param string $email
146		* @param string $password
147		* @param string $role
148		* @return object
149		*/
150		public function login($email, $password, $role = false)
		0 ignored issues – show Unused Code introduced 2020-04-20 00:03 UTC by Report Bug Copy Issue Report The parameter `$role` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
151		{
152		if (! $user = $this->repo->first(['email' => $email])) {
153		\Errors::loginFailed();
154		} elseif ($user->blocked) {
155		\Errors::userIsBlocked();
156		} elseif (! config('skeleton.disable_confirm_email') && ! $user->confirmed) {
157		\Errors::emailNotConfirmed();
158		}
159
160		return ['user' => $user, 'tokens' => $this->loginProxy->login($user->email, $password)];
161		}
162
163		/**
164		* Handle the social login request to the application.
165		*
166		* @param string $authCode
167		* @param string $accessToken
168		* @return array
169		*/
170		public function loginSocial($authCode, $accessToken, $type)
171		{
172		$access_token = $authCode ? Arr::get(\Socialite::driver($type)->getAccessTokenResponse($authCode), 'access_token') : $accessToken;
173		$user = \Socialite::driver($type)->userFromToken($access_token);
174
175		if (! $user->email) {
176		\Errors::noSocialEmail();
177		}
178
179		if (! $this->repo->first(['email' => $user->email])) {
180		$this->register($user->email, '', true);
		0 ignored issues – show Documentation introduced 2020-04-05 00:47 UTC by Report Bug Copy Issue Report `true` is of type `boolean`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
181		}
182
183		return $this->loginProxy->login($user->email, config('skeleton.social_pass'));
184		}
185
186		/**
187		* Handle the registration request.
188		*
189		* @param string $name
190		* @param string $email
191		* @param string $password
192		* @param boolean $skipConfirmEmail
193		* @return array
194		*/
195		public function register($name, $email, $password, $skipConfirmEmail = false)
196		{
197		$user = $this->repo->save([
198		'name' => $name,
199		'email' => $email,
200		'password' => $password,
201		'confirmed' => $skipConfirmEmail
202		]);
203
204		if (! $skipConfirmEmail && ! config('skeleton.disable_confirm_email')) {
205		$this->sendConfirmationEmail($user->email);
206		}
207
208		return $user;
209		}
210
211		/**
212		* Block the user.
213		*
214		* @param integer $userId
215		* @return object
216		*/
217		public function block($userId)
218		{
219		if (\Auth::id() == $userId) {
220		\Errors::noPermissions();
221		}
222
223		return $this->repo->save(['id' => $userId, 'blocked' => 1]);
224		}
225
226		/**
227		* Unblock the user.
228		*
229		* @param integer $userId
230		* @return object
231		*/
232		public function unblock($userId)
233		{
234		return $this->repo->save(['id' => $userId, 'blocked' => 0]);
235		}
236
237		/**
238		* Send a reset link to the given user.
239		*
240		* @param string $email
241		* @return void
242		*/
243		public function sendReset($email)
244		{
245		if (! $user = $this->repo->first(['email' => $email])) {
246		\Errors::notFound('email');
247		}
248
249		$token = \Password::getService()->create($user);
250		$this->notificationService->notify($user, 'ResetPassword', $token);
251		}
252
253		/**
254		* Reset the given user's password.
255		*
256		* @param string $email
257		* @param string $password
258		* @param string $passwordConfirmation
259		* @param string $token
260		* @return string\|void
261		*/
262		public function resetPassword($email, $password, $passwordConfirmation, $token)
263		{
264		$response = \Password::reset([
265		'email' => $email,
266		'password' => $password,
267		'password_confirmation' => $passwordConfirmation,
268		'token' => $token
269		], function ($user, $password) {
270		$this->repo->save(['id' => $user->id, 'password' => $password]);
271		});
272
273		switch ($response) {
274		case \Password::PASSWORD_RESET:
275		return 'success';
276		break;
		0 ignored issues – show Unused Code introduced 2020-03-30 10:13 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
277
278		case \Password::INVALID_TOKEN:
279		\Errors::invalidResetToken();
280		break;
281
282		case \Password::INVALID_PASSWORD:
283		\Errors::invalidResetPassword();
284		break;
285
286		case \Password::INVALID_USER:
287		\Errors::notFound('user');
288		break;
289		}
290		}
291
292		/**
293		* Change the logged in user password.
294		*
295		* @param string $password
296		* @param string $oldPassword
297		* @return void
298		*/
299		public function changePassword($password, $oldPassword)
300		{
301		$user = \Auth::user();
302		if (! \Hash::check($oldPassword, $user->password)) {
303		\Errors::invalidOldPassword();
304		}
305
306		$this->repo->save(['id' => $user->id, 'password' => $password]);
307		}
308
309		/**
310		* Confirm email using the confirmation code.
311		*
312		* @param string $confirmationCode
313		* @return void
314		*/
315		public function confirmEmail($confirmationCode)
316		{
317		if (! $user = $this->repo->first(['confirmation_code' => $confirmationCode])) {
318		\Errors::invalidConfirmationCode();
319		}
320
321		$this->repo->save(['id' => $user->id, 'confirmed' => 1, 'confirmation_code' => null]);
322		}
323
324		/**
325		* Send the confirmation mail.
326		*
327		* @param string $email
328		* @return void
329		*/
330		public function sendConfirmationEmail($email)
331		{
332		$user = $this->repo->first(['email' => $email]);
333		if ($user->confirmed) {
334		\Errors::emailAlreadyConfirmed();
335		}
336
337		$this->repo->save(['id' => $user->id, 'confirmation_code' => sha1(microtime())]);
338		$this->notificationService->notify($user, 'ConfirmEmail');
339		}
340
341		/**
342		* Save the given data to the logged in user.
343		*
344		* @param string $name
345		* @param string $email
346		* @param string $profilePicture
347		* @return void
348		*/
349		public function saveProfile($name, $email, $profilePicture = false)
350		{
351		if ($profilePicture) {
		0 ignored issues – show Bug Best Practice introduced 2020-03-30 10:13 UTC by Report Bug Copy Issue Report The expression `$profilePicture` of type `false\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
352		$data['profile_picture'] = \Media::uploadImageBas64($profilePicture, 'users/profile_pictures');
		0 ignored issues – show Coding Style Comprehensibility introduced 2020-03-30 10:13 UTC by Report Bug Copy Issue Report `$data` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$data = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
353		}
354
355		$data['id'] = \Auth::id();
		0 ignored issues – show Bug introduced 2020-03-30 10:13 UTC by Report Bug Copy Issue Report The variable `$data` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
356		return $this->repo->save([
357		'id' => \Auth::id(),
358		'name' => $name,
359		'email' => $email,
360		'profilePicture' => $profilePicture,
361		]);
362		}
363
364		/**
365		* Logs out the user, revoke access token and refresh token.
366		*
367		* @return void
368		*/
369		public function logout()
370		{
371		$this->oauthClientService->revokeAccessToken(\Auth::user()->token());
372		}
373
374		/**
375		* Attempt to refresh the access token using the given refresh token.
376		*
377		* @param string $refreshToken
378		* @return array
379		*/
380		public function refreshToken($refreshToken)
381		{
382		return $this->loginProxy->refreshToken($refreshToken);
383		}
384		}
385

SherifElfadaly / Laravel-Api-Skeleton