IdentityUser::validateAuthKey() - Code Metrics - Inspection of "refactoring" - Dominus77/yii2-advanced-start - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4b0bfb...40d7bb )

by Alexey

created 2018-07-20 18:59 UTC

IdentityUser::validateAuthKey() A

↳ Parent: IdentityUser

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

namespace modules\users\models;

use Yii;
use yii\behaviors\TimestampBehavior;
use yii2tech\ar\softdelete\SoftDeleteBehavior;
use yii\db\ActiveRecord;
use yii\web\IdentityInterface;
use modules\users\traits\ModuleTrait;
use modules\users\Module;

/**
 * Class IdentityUser
 * @package modules\users\models
 *
 * This is the model class for table "{{%user}}".
 *
 * @property int $id ID
 * @property string $username Username
 * @property string $auth_key Authorization Key
 * @property string $password_hash Hash Password
 * @property string $password_reset_token Password Token
 * @property string $email_confirm_token Email Confirm Token
 * @property string $email Email
 * @property int|string $status Status
 * @property int $last_visit Last Visit
 * @property int $created_at Created
 * @property int $updated_at Updated
 * @property string $first_name First Name
 * @property string $last_name Last Name
 */
class IdentityUser extends ActiveRecord implements IdentityInterface
{
    use ModuleTrait;

    // Status
    const STATUS_BLOCKED = 0;
    const STATUS_ACTIVE = 1;
    const STATUS_WAIT = 2;
    const STATUS_DELETED = 3;

    // Type of registration
    const TYPE_REGISTRATION_SYSTEM = 0;

    /**
     * @inheritdoc
     * @return string
     */
    public static function tableName()
    {
        return '{{%user}}';
    }

    /**
     * @inheritdoc
     * @return array
     */
    public function behaviors()
    {
        return [
            'timestamp' => [
                'class' => TimestampBehavior::class,
            ],
            'softDeleteBehavior' => [
                'class' => SoftDeleteBehavior::class,
                'softDeleteAttributeValues' => [
                    'status' => self::STATUS_DELETED,
                ],
            ],
        ];
    }

    /**
     * @inheritdoc
     * @return array
     */
    public function rules()
    {
        return [
            ['username', 'required'],
            ['username', 'match', 'pattern' => '#^[\w_-]+$#i'],
            ['username', 'unique', 'targetClass' => self::class, 'message' => Module::t('module', 'This username is already taken.')],
            ['username', 'string', 'min' => 2, 'max' => 255],

            ['email', 'required'],
            ['email', 'email'],
            ['email', 'unique', 'targetClass' => self::class, 'message' => Module::t('module', 'This email is already taken.')],
            ['email', 'string', 'max' => 255],

            [['first_name', 'last_name'], 'string', 'max' => 45],
            [['registration_type'], 'safe'],
        ];
    }

    /**
     * @inheritdoc
     * @return array
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'created_at' => Module::t('module', 'Created'),
            'updated_at' => Module::t('module', 'Updated'),
            'last_visit' => Module::t('module', 'Last Visit'),
            'username' => Module::t('module', 'Username'),
            'email' => Module::t('module', 'Email'),
            'auth_key' => Module::t('module', 'Auth Key'),
            'status' => Module::t('module', 'Status'),
            'first_name' => Module::t('module', 'First Name'),
            'last_name' => Module::t('module', 'Last Name'),
            'registration_type' => Module::t('module', 'Registration Type'),
        ];
    }

    /**
     * @inheritdoc
     * @param int|string $id
     * @return IdentityInterface
     */
    public static function findIdentity($id)
    {
        /** @var IdentityInterface $result */
        $result = static::findOne(['id' => $id, 'status' => self::STATUS_ACTIVE]);
        return $result;
    }

    /**
     * @inheritdoc
     * @param mixed $token
     * @param mixed $type
     * @return IdentityInterface
     */
    public static function findIdentityByAccessToken($token, $type = null)
    {
        /** @var IdentityInterface $result */
        $result = static::findOne(['auth_key' => $token, 'status' => self::STATUS_ACTIVE]);
        return $result;
    }

    /**
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return string current user auth key
     */
    public function getAuthKey()
    {
        return $this->auth_key;
    }

    /**
     * @param string|mixed $authKey
     * @return bool if auth key is valid for current user
     */
    public function validateAuthKey($authKey)
    {
        return $this->getAuthKey() === $authKey;
    }

    /**
     * Finds user by username
     *
     * @param string $username
     * @return static|null|ActiveRecord
     */
    public static function findByUsername($username)
    {
        return static::findOne(['username' => $username, 'status' => self::STATUS_ACTIVE]);
    }

    /**
     * Finds user by email
     *
     * @param string $email
     * @return array|null|ActiveRecord
     */
    public static function findByUsernameEmail($email)
    {
        return static::findOne(['email' => $email, 'status' => self::STATUS_ACTIVE]);
    }

    /**
     * Finds user by username or email
     *
     * @param string $string
     * @return array|null|ActiveRecord
     */
    public static function findByUsernameOrEmail($string)
    {
        return static::find()
            ->where(['or', ['username' => $string], ['email' => $string]])
            ->andWhere(['status' => self::STATUS_ACTIVE])
            ->one();
    }

    /**
     * Finds user by password reset token
     *
     * @param mixed $token password reset token
     * @return static|null
     */
    public static function findByPasswordResetToken($token)
    {
        if (!static::isPasswordResetTokenValid($token)) {
            return null;
        }
        return static::findOne([
            'password_reset_token' => $token,
            'status' => self::STATUS_ACTIVE,
        ]);
    }

    /**
     * Finds out if password reset token is valid
     *
     * @param mixed $token password reset token
     * @return boolean
     */
    public static function isPasswordResetTokenValid($token)
    {
        if (empty($token)) {
            return false;
        }
        $expire = Yii::$app->params['user.passwordResetTokenExpire'];
        $parts = explode('_', $token);
        $timestamp = (int)end($parts);
        return $timestamp + $expire >= time();
    }

    /**
     * Validates password
     *
     * @param string $password password to validate
     * @return bool if password provided is valid for current user
     */
    public function validatePassword($password)
    {
        return Yii::$app->security->validatePassword($password, $this->password_hash);
    }

    /**
     * Generates password hash from password and sets it to the model
     *
     * @param string $password
     * @throws \yii\base\Exception
     */
    public function setPassword($password)
    {
        $this->password_hash = Yii::$app->security->generatePasswordHash($password);
    }

    /**
     * Generates "remember me" authentication key
     */
    public function generateAuthKey()
    {
        $this->auth_key = Yii::$app->security->generateRandomString();
    }

    /**
     * Generates new password reset token
     */
    public function generatePasswordResetToken()
    {
        $this->password_reset_token = Yii::$app->security->generateRandomString() . '_' . time();
    }

    /**
     * Removes password reset token
     */
    public function removePasswordResetToken()
    {
        $this->password_reset_token = null;
    }

    /**
     * @param mixed $email_confirm_token
     * @return bool|null|static
     */
    public static function findByEmailConfirmToken($email_confirm_token)
    {
        return static::findOne([
            'email_confirm_token' => $email_confirm_token,
            'status' => self::STATUS_WAIT
        ]);
    }

    /**
     * Generates email confirmation token
     */
    public function generateEmailConfirmToken()
    {
        $this->email_confirm_token = Yii::$app->security->generateRandomString();
    }

    /**
     * Removes email confirmation token
     */
    public function removeEmailConfirmToken()
    {
        $this->email_confirm_token = null;
    }
}


1			<?php
2
3			namespace modules\users\models;
4
5			use Yii;
6			use yii\behaviors\TimestampBehavior;
7			use yii2tech\ar\softdelete\SoftDeleteBehavior;
8			use yii\db\ActiveRecord;
9			use yii\web\IdentityInterface;
10			use modules\users\traits\ModuleTrait;
11			use modules\users\Module;
12
13			/**
14			* Class IdentityUser
15			* @package modules\users\models
16			*
17			* This is the model class for table "{{%user}}".
18			*
19			* @property int $id ID
20			* @property string $username Username
21			* @property string $auth_key Authorization Key
22			* @property string $password_hash Hash Password
23			* @property string $password_reset_token Password Token
24			* @property string $email_confirm_token Email Confirm Token
25			* @property string $email Email
26			* @property int\|string $status Status
27			* @property int $last_visit Last Visit
28			* @property int $created_at Created
29			* @property int $updated_at Updated
30			* @property string $first_name First Name
31			* @property string $last_name Last Name
32			*/
33			class IdentityUser extends ActiveRecord implements IdentityInterface
34			{
35			use ModuleTrait;
36
37			// Status
38			const STATUS_BLOCKED = 0;
39			const STATUS_ACTIVE = 1;
40			const STATUS_WAIT = 2;
41			const STATUS_DELETED = 3;
42
43			// Type of registration
44			const TYPE_REGISTRATION_SYSTEM = 0;
45
46			/**
47			* @inheritdoc
48			* @return string
49			*/
50			public static function tableName()
51			{
52			return '{{%user}}';
53			}
54
55			/**
56			* @inheritdoc
57			* @return array
58			*/
59			public function behaviors()
60			{
61			return [
62			'timestamp' => [
63			'class' => TimestampBehavior::class,
64			],
65			'softDeleteBehavior' => [
66			'class' => SoftDeleteBehavior::class,
67			'softDeleteAttributeValues' => [
68			'status' => self::STATUS_DELETED,
69			],
70			],
71			];
72			}
73
74			/**
75			* @inheritdoc
76			* @return array
77			*/
78			public function rules()
79			{
80			return [
81			['username', 'required'],
82			['username', 'match', 'pattern' => '#^[\w_-]+$#i'],
83			['username', 'unique', 'targetClass' => self::class, 'message' => Module::t('module', 'This username is already taken.')],
84			['username', 'string', 'min' => 2, 'max' => 255],
85
86			['email', 'required'],
87			['email', 'email'],
88			['email', 'unique', 'targetClass' => self::class, 'message' => Module::t('module', 'This email is already taken.')],
89			['email', 'string', 'max' => 255],
90
91			[['first_name', 'last_name'], 'string', 'max' => 45],
92			[['registration_type'], 'safe'],
93			];
94			}
95
96			/**
97			* @inheritdoc
98			* @return array
99			*/
100			public function attributeLabels()
101			{
102			return [
103			'id' => 'ID',
104			'created_at' => Module::t('module', 'Created'),
105			'updated_at' => Module::t('module', 'Updated'),
106			'last_visit' => Module::t('module', 'Last Visit'),
107			'username' => Module::t('module', 'Username'),
108			'email' => Module::t('module', 'Email'),
109			'auth_key' => Module::t('module', 'Auth Key'),
110			'status' => Module::t('module', 'Status'),
111			'first_name' => Module::t('module', 'First Name'),
112			'last_name' => Module::t('module', 'Last Name'),
113			'registration_type' => Module::t('module', 'Registration Type'),
114			];
115			}
116
117			/**
118			* @inheritdoc
119			* @param int\|string $id
120			* @return IdentityInterface
121			*/
122			public static function findIdentity($id)
123			{
124			/** @var IdentityInterface $result */
125			$result = static::findOne(['id' => $id, 'status' => self::STATUS_ACTIVE]);
126			return $result;
127			}
128
129			/**
130			* @inheritdoc
131			* @param mixed $token
132			* @param mixed $type
133			* @return IdentityInterface
134			*/
135			public static function findIdentityByAccessToken($token, $type = null)
136			{
137			/** @var IdentityInterface $result */
138			$result = static::findOne(['auth_key' => $token, 'status' => self::STATUS_ACTIVE]);
139			return $result;
140			}
141
142			/**
143			* @return integer
144			*/
145			public function getId()
146			{
147			return $this->id;
148			}
149
150			/**
151			* @return string current user auth key
152			*/
153			public function getAuthKey()
154			{
155			return $this->auth_key;
156			}
157
158			/**
159			* @param string\|mixed $authKey
160			* @return bool if auth key is valid for current user
161			*/
162			public function validateAuthKey($authKey)
163			{
164			return $this->getAuthKey() === $authKey;
165			}
166
167			/**
168			* Finds user by username
169			*
170			* @param string $username
171			* @return static\|null\|ActiveRecord
172			*/
173			public static function findByUsername($username)
174			{
175			return static::findOne(['username' => $username, 'status' => self::STATUS_ACTIVE]);
176			}
177
178			/**
179			* Finds user by email
180			*
181			* @param string $email
182			* @return array\|null\|ActiveRecord
183			*/
184			public static function findByUsernameEmail($email)
185			{
186			return static::findOne(['email' => $email, 'status' => self::STATUS_ACTIVE]);
187			}
188
189			/**
190			* Finds user by username or email
191			*
192			* @param string $string
193			* @return array\|null\|ActiveRecord
194			*/
195			public static function findByUsernameOrEmail($string)
196			{
197			return static::find()
198			->where(['or', ['username' => $string], ['email' => $string]])
199			->andWhere(['status' => self::STATUS_ACTIVE])
200			->one();
201			}
202
203			/**
204			* Finds user by password reset token
205			*
206			* @param mixed $token password reset token
207			* @return static\|null
208			*/
209			public static function findByPasswordResetToken($token)
210			{
211			if (!static::isPasswordResetTokenValid($token)) {
212			return null;
213			}
214			return static::findOne([
215			'password_reset_token' => $token,
216			'status' => self::STATUS_ACTIVE,
217			]);
218			}
219
220			/**
221			* Finds out if password reset token is valid
222			*
223			* @param mixed $token password reset token
224			* @return boolean
225			*/
226			public static function isPasswordResetTokenValid($token)
227			{
228			if (empty($token)) {
229			return false;
230			}
231			$expire = Yii::$app->params['user.passwordResetTokenExpire'];
232			$parts = explode('_', $token);
233			$timestamp = (int)end($parts);
234			return $timestamp + $expire >= time();
235			}
236
237			/**
238			* Validates password
239			*
240			* @param string $password password to validate
241			* @return bool if password provided is valid for current user
242			*/
243			public function validatePassword($password)
244			{
245			return Yii::$app->security->validatePassword($password, $this->password_hash);
246			}
247
248			/**
249			* Generates password hash from password and sets it to the model
250			*
251			* @param string $password
252			* @throws \yii\base\Exception
253			*/
254			public function setPassword($password)
255			{
256			$this->password_hash = Yii::$app->security->generatePasswordHash($password);
257			}
258
259			/**
260			* Generates "remember me" authentication key
261			*/
262			public function generateAuthKey()
263			{
264			$this->auth_key = Yii::$app->security->generateRandomString();
265			}
266
267			/**
268			* Generates new password reset token
269			*/
270			public function generatePasswordResetToken()
271			{
272			$this->password_reset_token = Yii::$app->security->generateRandomString() . '_' . time();
273			}
274
275			/**
276			* Removes password reset token
277			*/
278			public function removePasswordResetToken()
279			{
280			$this->password_reset_token = null;
281			}
282
283			/**
284			* @param mixed $email_confirm_token
285			* @return bool\|null\|static
286			*/
287			public static function findByEmailConfirmToken($email_confirm_token)
288			{
289			return static::findOne([
290			'email_confirm_token' => $email_confirm_token,
291			'status' => self::STATUS_WAIT
292			]);
293			}
294
295			/**
296			* Generates email confirmation token
297			*/
298			public function generateEmailConfirmToken()
299			{
300			$this->email_confirm_token = Yii::$app->security->generateRandomString();
301			}
302
303			/**
304			* Removes email confirmation token
305			*/
306			public function removeEmailConfirmToken()
307			{
308			$this->email_confirm_token = null;
309			}
310			}
311

Dominus77 / yii2-advanced-start

Push — master ( 4b0bfb...40d7bb )

IdentityUser::validateAuthKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like