User::create() - Code Metrics - Inspection of "Merge pull request #18 from sunsingerus/preparatio..." - kot13/bootstrapi - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 85e40f...7b165f )

by Pavel

created 2017-07-23 14:16 UTC

User::create() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	10
rs	9.4285
cc	2
eloc	6
nc	2
nop	2

<?php
namespace App\Model;

use Illuminate\Database\Eloquent\SoftDeletes;
use App\Common\Helper;
use App\Common\Auth;

/**
 * Class User
 *
 * @property integer        $id
 * @property string         $email
 * @property string         $full_name
 * @property string         $password
 * @property string         $password_reset_token
 * @property integer        $role_id
 * @property integer        $created_by
 * @property integer        $updated_by
 * @property \Carbon\Carbon $created_at
 * @property \Carbon\Carbon $updated_at
 * @property \Carbon\Carbon $deleted_at
 * @property integer        $status
 * @property-read Role      $role
 *
 * @package App\Model
 */
final class User extends BaseModel
{
    use SoftDeletes;

    const STATUS_BLOCKED     = 0;
    const STATUS_ACTIVE      = 1;
    const STATUS_WAIT        = 2;

    const ROLE_ADMIN         = 1;
    const ROLE_USER          = 2;

    const EXPIRE_RESET_TOKEN = 3600;

    protected $table = 'users';

    protected $fillable = [
        'full_name',
        'email',
        'role_id',
        'status'
    ];

    protected $hidden = [
        'password',
        'password_reset_token',
    ];

    public static $rules = [
        'create' => [
            'email'    => 'required|email',
            'role_id'  => 'required',
            'password' => 'required',
        ],
        'update' => [
            'email'   => 'required|email',
            'role_id' => 'required',
        ]
    ];

    public function role()
    {
        return $this->hasOne('App\Model\Role', 'id', 'role_id');
    }

    public function access_tokens()

    {
        return $this->hasMany('App\Model\AccessToken', 'user_id', 'id');
    }

    public function refresh_tokens()

    {
        return $this->hasMany('App\Model\RefreshToken', 'user_id', 'id');
    }

    public function scopeCurrentUser($query)

    {
        $user = Auth::getUser();

        if ($user) {
            if ($user->role_id == self::ROLE_ADMIN) {
                return $query;
            }

            $query->where('id', $user->id);
        } else {
            $query->where('id', 0);
        }

        return $query;
    }

    /**
     * Create new User instance and save it
     *
     * @param $attributes
     * @param $password
     * @return User|null
     */
    public static function create($attributes, $password)
    {
        $user = new self($attributes);
        $user->setPassword($password);
        if (!$user->save()) {
            return null;
        }

        return $user;
    }


    /**
     * @param $email
     *
     * @return bool
     */
    public static function exist($email)
    {
        return self::where('email', $email)->count() > 0;
    }

    /**
     * @param string $email
     *
     * @return User|null
     */
    public static function findUserByEmail($email)
    {
        return self::where('email', $email)->where('status', self::STATUS_ACTIVE)->first();
    }

    /**
     * @param string $resetToken
     *
     * @return User|null
     */
    public static function findByPasswordResetToken($resetToken)
    {
        if (!self::isPasswordResetTokenValid($resetToken)) {
            return null;
        }

        return self::where('password_reset_token', $resetToken)->where('status', self::STATUS_ACTIVE)->first();
    }

    /**
     * @param string $token
     *
     * @return bool
     */
    public static function isPasswordResetTokenValid($token)
    {
        if (empty($token)) {
            return false;
        }

        $timestamp = (int)substr($token, strrpos($token, '_') + 1);
        $expire    = self::EXPIRE_RESET_TOKEN;
        return $timestamp + $expire >= time();
    }

    /**
     * @void
     */
    public function generatePasswordResetToken()
    {
        $this->password_reset_token = Helper::generateRandomString().'_'.time();
    }

    /**
     * @void
     */
    public function removePasswordResetToken()
    {
        $this->password_reset_token = null;
    }

    /**
     * @param string $password
     */
    public function setPassword($password)
    {
        // we need to invalidate tokens when changing password
        AccessToken::where('user_id', $this->id)->delete();
        RefreshToken::where('user_id', $this->id)->delete();

        $this->password = password_hash($password, PASSWORD_DEFAULT, ['cost' => 13]);
    }
}


1			<?php
2			namespace App\Model;
3
4			use Illuminate\Database\Eloquent\SoftDeletes;
5			use App\Common\Helper;
6			use App\Common\Auth;
7
8			/**
9			* Class User
10			*
11			* @property integer $id
12			* @property string $email
13			* @property string $full_name
14			* @property string $password
15			* @property string $password_reset_token
16			* @property integer $role_id
17			* @property integer $created_by
18			* @property integer $updated_by
19			* @property \Carbon\Carbon $created_at
20			* @property \Carbon\Carbon $updated_at
21			* @property \Carbon\Carbon $deleted_at
22			* @property integer $status
23			* @property-read Role $role
24			*
25			* @package App\Model
26			*/
27			final class User extends BaseModel
28			{
29			use SoftDeletes;
30
31			const STATUS_BLOCKED = 0;
32			const STATUS_ACTIVE = 1;
33			const STATUS_WAIT = 2;
34
35			const ROLE_ADMIN = 1;
36			const ROLE_USER = 2;
37
38			const EXPIRE_RESET_TOKEN = 3600;
39
40			protected $table = 'users';
41
42			protected $fillable = [
43			'full_name',
44			'email',
45			'role_id',
46			'status'
47			];
48
49			protected $hidden = [
50			'password',
51			'password_reset_token',
52			];
53
54			public static $rules = [
55			'create' => [
56			'email' => 'required\|email',
57			'role_id' => 'required',
58			'password' => 'required',
59			],
60			'update' => [
61			'email' => 'required\|email',
62			'role_id' => 'required',
63			]
64			];
65
66			public function role()
67			{
68			return $this->hasOne('App\Model\Role', 'id', 'role_id');
69			}
70
71			public function access_tokens()
			0 ignored issues – show Coding Style introduced 2017-02-18 09:33 UTC by Report Bug Copy Issue Report This method is not in camel caps format. This check looks for method names that are not written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection seeker becomes `databaseConnectionSeeker`. Loading history...
72			{
73			return $this->hasMany('App\Model\AccessToken', 'user_id', 'id');
74			}
75
76			public function refresh_tokens()
			0 ignored issues – show Coding Style introduced 2017-02-18 09:33 UTC by Report Bug Copy Issue Report This method is not in camel caps format. This check looks for method names that are not written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection seeker becomes `databaseConnectionSeeker`. Loading history...
77			{
78			return $this->hasMany('App\Model\RefreshToken', 'user_id', 'id');
79			}
80
81			public function scopeCurrentUser($query)
			0 ignored issues – show Documentation introduced 2017-01-07 12:55 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
82			{
83			$user = Auth::getUser();
84
85			if ($user) {
86			if ($user->role_id == self::ROLE_ADMIN) {
87			return $query;
88			}
89
90			$query->where('id', $user->id);
91			} else {
92			$query->where('id', 0);
93			}
94
95			return $query;
96			}
97
98			/**
99			* Create new User instance and save it
100			*
101			* @param $attributes
102			* @param $password
103			* @return User\|null
104			*/
105			public static function create($attributes, $password)
106			{
107			$user = new self($attributes);
108			$user->setPassword($password);
109			if (!$user->save()) {
110			return null;
111			}
112
113			return $user;
114			}
115
116
117			/**
118			* @param $email
119			*
120			* @return bool
121			*/
122			public static function exist($email)
123			{
124			return self::where('email', $email)->count() > 0;
125			}
126
127			/**
128			* @param string $email
129			*
130			* @return User\|null
131			*/
132			public static function findUserByEmail($email)
133			{
134			return self::where('email', $email)->where('status', self::STATUS_ACTIVE)->first();
135			}
136
137			/**
138			* @param string $resetToken
139			*
140			* @return User\|null
141			*/
142			public static function findByPasswordResetToken($resetToken)
143			{
144			if (!self::isPasswordResetTokenValid($resetToken)) {
145			return null;
146			}
147
148			return self::where('password_reset_token', $resetToken)->where('status', self::STATUS_ACTIVE)->first();
149			}
150
151			/**
152			* @param string $token
153			*
154			* @return bool
155			*/
156			public static function isPasswordResetTokenValid($token)
157			{
158			if (empty($token)) {
159			return false;
160			}
161
162			$timestamp = (int)substr($token, strrpos($token, '_') + 1);
163			$expire = self::EXPIRE_RESET_TOKEN;
164			return $timestamp + $expire >= time();
165			}
166
167			/**
168			* @void
169			*/
170			public function generatePasswordResetToken()
171			{
172			$this->password_reset_token = Helper::generateRandomString().'_'.time();
173			}
174
175			/**
176			* @void
177			*/
178			public function removePasswordResetToken()
179			{
180			$this->password_reset_token = null;
181			}
182
183			/**
184			* @param string $password
185			*/
186			public function setPassword($password)
187			{
188			// we need to invalidate tokens when changing password
189			AccessToken::where('user_id', $this->id)->delete();
190			RefreshToken::where('user_id', $this->id)->delete();
191
192			$this->password = password_hash($password, PASSWORD_DEFAULT, ['cost' => 13]);
193			}
194			}
195

kot13 / bootstrapi

Push — master ( 85e40f...7b165f )

User::create() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like