inblank\activeuser\models\User

Complexity

Total Complexity

85

Size/Duplication

Total Lines	632
Duplicated Lines	6.65 %

Coupling/Cohesion

Components	4
Dependencies	6

Test Coverage

Coverage

89.21%

Importance

Changes	1
Bugs	0	Features	0

37 Methods

Rating	Name	Duplication	Size	Complexity
A	tableName()	0	4	1
A	find()	0	5	1
A	findIdentity()	0	4	1
A	findByToken()	0	4	2
A	findIdentityByAccessToken()	0	7	2
A	confirm()	0	20	3
A	isConfirmed()	0	4	1
A	isTokenExpired()	0	4	1
A	isConfirmTokenExpired()	0	4	1
A	isRestoreTokenExpired()	0	4	1
B	rules()	0	42	4
A	attributeLabels()	0	23	1
A	getProfile()	0	4	1
A	beforeSave()	0	10	4
A	afterSave()	0	11	2
A	transactions()	0	6	1
A	getId()	0	4	1
A	validateAuthKey()	0	5	3
A	getAuthKey()	0	4	1
A	isActive()	0	4	1
B	create()	3	30	6
C	register()	3	30	7
A	generatePassword()	0	4	1
A	generateToken()	0	8	1
A	restore()	0	19	4
A	isBlocked()	0	4	1
B	block()	18	18	5
A	unblock()	18	18	4
B	changePassword()	0	18	5
A	newPassword()	0	20	4
A	isRestore()	0	4	1
A	getStatusText()	0	8	3
A	statusesList()	0	9	1
A	getGenderText()	0	8	3
A	gendersList()	0	8	1
A	resend()	0	9	4
A	behaviors()	0	11	1

<?php
/**
 * User model for the module yii2-activeuser
 *
 * @link https://github.com/inblank/yii2-activeuser
 * @copyright Copyright (c) 2016 Pavel Aleksandrov <inblank@yandex.ru>
 * @license http://opensource.org/licenses/MIT
 */

namespace inblank\activeuser\models;

use inblank\activeuser\traits\CommonTrait;
use inblank\image\ImageBehavior;
use yii;
use yii\db\ActiveRecord;
use yii\web\IdentityInterface;

/**
 * This is the model class for table "{{%activeuser_users}}"
 *
 * Table fields:
 * @property integer $id user identifier
 * @property integer $status user status. STATUS_ACTIVE, STATUS_BLOCKED, STATUS_CONFIRM, STATUS_RESTORE
 * @property string $email user email used as login
 * @property string $pass_hash hash of user password
 * @property string $name real user name
 * @property int $gender user gender. User::MALE, User::FEMALE. If empty, not set
 * @property string $birth user birth date
 * @property string $avatar user avatar filename
 * @property string $access_token user access token for use site API
 * @property string $auth_key user key for access by `remember me`
 * @property string $token token for registration confirm or restore password
 * @property int $token_created_at the time when the token was created
 * @property string $registered_at user registration date
 *
 * By getters:
 * @property $statusText user status as text
 * @property $genderText user gender as text
 *
 * Relations:
 * @property Profile $profile user profile data
 *
 * @mixin ImageBehavior
 */
class User extends ActiveRecord implements yii\web\IdentityInterface
{
    use CommonTrait;

    /** Male gender */
    const MALE = 1;
    /** Female gender */
    const FEMALE = 2;

    /** Active user status */
    const STATUS_ACTIVE = 1;
    /** Blocked user status */
    const STATUS_BLOCKED = 2;
    /** User await email confirmation status */
    const STATUS_CONFIRM = 3;
    /** User await access restore status */
    const STATUS_RESTORE = 4;

    // TODO where store password between data enter and confirmation email? Password must be send with congratulation email
    /** @var string password field on registration on restore */
    public $password;

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

    /**
     * @inheritdoc
     * @return UserQuery the active query used by this AR class.
     */
    public static function find()
    {
        $queryClass = self::di('UserQuery');
        return new $queryClass(get_called_class());
    }

    /**
     * Finds an identity by the given ID.
     * @param string|integer $id the ID to be looked for
     * @return IdentityInterface the identity object that matches the given ID.
     * Null should be returned if such an identity cannot be found
     * or the identity is not in an active state (disabled, deleted, etc.)
     */
    public static function findIdentity($id)
    {
        return static::findOne($id);
    }

    /**
     * Find user by token
     * @param string $token for search
     * @return null|static
     */
    public static function findByToken($token)
    {
        return empty($token) ? null : static::findOne(['token' => $token]);
    }

    /**
     * Finds an identity by the given token.
     * @param mixed $token the token to be looked for
     * @param mixed $type the type of the token. The value of this parameter depends on the implementation.
     * For example, [[\yii\filters\auth\HttpBearerAuth]] will set this parameter to be `yii\filters\auth\HttpBearerAuth`.
     * @return IdentityInterface the identity object that matches the given token.
     * Null should be returned if such an identity cannot be found
     * or the identity is not in an active state (disabled, deleted, etc.)
     */
    public static function findIdentityByAccessToken($token, $type = null)
    {
        if (empty($token)) {
            return null;
        }
        return static::findOne(['access_token' => $token, 'status' => self::STATUS_ACTIVE]);
    }

    /**
     * Confirm user registration
     * @return bool return false if cannot confirm.
     * If in errors list has key `error`, that user already confirmed
     * If in errors list has key `token`, that confirm token was expired
     */
    public function confirm()
    {
        if ($this->isConfirmed()) {
            $this->addError('error', Yii::t('activeuser_general', 'User already confirmed'));
            return false;
        }
        if ($this->isConfirmTokenExpired()) {
            $this->addError('token', Yii::t('activeuser_general', 'You token was expired'));
            return false;
        }
        $this->updateAttributes([
            'token' => null,
            'token_created_at' => 0,
            'status' => self::STATUS_ACTIVE,
        ]);
        $this->module->sendMessage('register', [
            'user' => $this,
        ]);
        return true;
    }

    /**
     * Check that user was confirmed
     * @return bool
     */
    public function isConfirmed()
    {
        return $this->status !== self::STATUS_CONFIRM;
    }

    /**
     * Checks that the token was expired
     * @param int $timeToExpire time
     * @return bool
     */
    public function isTokenExpired($timeToExpire)
    {
        return $this->token_created_at + $timeToExpire < time();
    }

    /**
     * Checks that the confirmation token was expired
     * @return bool
     */
    public function isConfirmTokenExpired()
    {
        return $this->isTokenExpired($this->getModule()->confirmationTime);
    }

    /**
     * Checks that the restore token was expired
     * @return bool
     */
    public function isRestoreTokenExpired()
    {
        return $this->isTokenExpired($this->getModule()->restoreTime);
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        // todo check password length
        return [
            [['email'], 'required'],
            ['password', 'required', 'when' => function ($model) {
                return $model->isNewRecord;
            }],
            ['email', 'unique'],
            ['email', 'string', 'max' => 200],
            ['email', 'email'],
            ['name', 'string', 'max' => 200],
            ['name', function () {
                if (in_array('name', $this->module->registrationFields) && empty($this->name)) {
                    $this->addError('name', Yii::t('activeuser_general', 'Name cannot be blank.'));
                }
            }, 'skipOnEmpty' => false],
            ['status', 'in', 'range' => [
                self::STATUS_ACTIVE,
                self::STATUS_BLOCKED,
                self::STATUS_CONFIRM,
                self::STATUS_RESTORE,
            ]],
            ['status', 'default', 'value' => function () {
                return $this->module->enableConfirmation ? self::STATUS_CONFIRM : self::STATUS_ACTIVE;
            }],
            ['gender', 'in', 'range' => [
                0,
                self::MALE,
                self::FEMALE,
            ]],
            ['birth', 'date', 'format' => 'php:Y-m-d', 'skipOnEmpty' => true,],
            ['token_created_at', 'integer'],
            ['registered_at', 'date', 'format' => 'php:Y-m-d H:i:s'],
            ['registered_at', 'default', 'value' => function () {
                return date('Y-m-d H:i:s');
            }],
            // rules below for prevent nullable value of attributes
            [['name', 'avatar'], 'default', 'value' => ''],
            [['gender', 'token_created_at'], 'default', 'value' => 0],
        ];
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'status' => Yii::t('activeuser_general', 'Status'),
            'email' => Yii::t('activeuser_general', 'Email'),
            'password' => Yii::t('activeuser_general', 'Password'),
            'pass_hash' => Yii::t('activeuser_general', 'Password hash'),
            'name' => Yii::t('activeuser_general', 'Name'),
            'gender' => Yii::t('activeuser_general', 'Gender'),
            'birth' => Yii::t('activeuser_general', 'Birth'),
            'avatar' => Yii::t('activeuser_general', 'Avatar'),
            'access_token' => Yii::t('activeuser_general', 'Access token'),
            'auth_key' => Yii::t('activeuser_general', 'Auth key'),
            'token' => Yii::t('activeuser_general', 'Token'),
            'token_created_at' => Yii::t('activeuser_general', 'Token created'),
            'registered_at' => Yii::t('activeuser_general', 'Registered'),

            'statusText' => Yii::t('activeuser_general', 'Status'),
            'genderText' => Yii::t('activeuser_general', 'Gender'),
            'imageUrl' => Yii::t('activeuser_general', 'Avatar'),
        ];
    }

    /**
     * Get user profile
     * @return yii\db\ActiveQuery
     */
    public function getProfile()
    {
        return $this->hasOne(self::di('Profile'), ['user_id' => 'id']);
    }

    /**
     * @inheritdoc
     */
    public function beforeSave($insert)
    {
        if (!parent::beforeSave($insert)) {
            return false;
        }
        if ($this->getIsNewRecord() && !empty($this->password)) {
            $this->pass_hash = Yii::$app->getSecurity()->generatePasswordHash($this->password);
        }
        return true;
    }

    /**
     * @inheritdoc
     */
    public function afterSave($insert, $changedAttributes)
    {
        if ($insert) {
            // add profile for new user
            Yii::createObject([
                'class' => self::di('Profile'),
                'user_id' => $this->id,
            ])->save();
        }
        parent::afterSave($insert, $changedAttributes);
    }

    /**
     * @inheritdoc
     */
    public function transactions()
    {
        return [
            self::SCENARIO_DEFAULT => self::OP_INSERT,
        ];
    }

    /**
     * Returns an ID that can uniquely identify a user identity.
     * @return string|integer an ID that uniquely identifies a user identity.
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Validates the given auth key.
     *
     * This is required if [[User::enableAutoLogin]] is enabled.
     * @param string $authKey the given auth key
     * @return boolean whether the given auth key is valid.
     * @see getAuthKey()
     */
    public function validateAuthKey($authKey)
    {
        $userAuthKey = $this->getAuthKey();
        return $this->status === self::STATUS_ACTIVE && !empty($userAuthKey) && $userAuthKey === $authKey;
    }

    /**
     * Returns a key that can be used to check the validity of a given identity ID.
     *
     * The key should be unique for each individual user, and should be persistent
     * so that it can be used to check the validity of the user identity.
     *
     * The space of such keys should be big enough to defeat potential identity attacks.
     *
     * This is required if [[User::enableAutoLogin]] is enabled.
     * @return string a key that is used to check the validity of a given identity ID.
     * @see validateAuthKey()
     */
    public function getAuthKey()
    {
        return $this->auth_key;
    }

    /**
     * Check active user
     * @return bool
     */
    public function isActive()
    {
        return $this->status === self::STATUS_ACTIVE;
    }

    /**
     * User creation
     * For create the user you always must set attributes `email`, `password` and `name`
     * @param bool $sendEmail whether to send email about registration
     * @return bool
     */
    public function create($sendEmail = false)
    {
        $oldRegisterFields = $this->module->registrationFields;
        $this->module->registrationFields = ['password', 'name'];
        if ($this->getIsNewRecord() == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

This code seems to be duplicated across your project.

            throw new \RuntimeException('Calling "' . __CLASS__ . '::' . __METHOD__ . '" on existing user');
        }
        $generatedPassword = false;
        if (empty($this->password)) {
            // password autogenerate
            $generatedPassword = true;
            $this->password = $this->generatePassword();

It seems like $this->generatePassword() can also be of type array. However, the property $password is declared as type string. Maybe add an additional type check?

        }
        $this->status = self::STATUS_ACTIVE;
        $isCreated = $this->save();
        $this->module->registrationFields = $oldRegisterFields;
        if (!$isCreated) {
            if ($generatedPassword) {
                $this->password = null;
            }
            return false;
        }
        if ($sendEmail) {
            // send email with registration congratulation
            $this->module->sendMessage('register', [
                'user' => $this,
            ]);
        }
        return true;
    }

    /**
     * User registration
     * @return bool
     */
    public function register()
    {
        if ($this->getIsNewRecord() == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

This code seems to be duplicated across your project.

            throw new \RuntimeException('Calling "' . __CLASS__ . '::' . __METHOD__ . '" on existing user');
        }
        if (!$this->module->enableRegistration) {
            $this->addError('registration', Yii::t('activeuser_general', 'Registration is not available'));
            return false;
        }
        if (!in_array('password', $this->module->registrationFields)) {
            // password autogenerate
            $this->password = $this->generatePassword();

It seems like $this->generatePassword() can also be of type array. However, the property $password is declared as type string. Maybe add an additional type check?

        }
        if (!$this->save()) {
            return false;
        }
        if ($this->module->enableConfirmation) {
            $this->generateToken();
            // send email with confirm link
            $this->module->sendMessage('confirm', [
                'user' => $this,
            ]);
        } elseif ($this->module->enableRegistrationEmail) {
            // send email with registration congratulation
            $this->module->sendMessage('register', [
                'user' => $this,
            ]);
        }
        return true;
    }

    /**
     * Password generator
     * @return mixed
     */
    public function generatePassword()
    {
        return (new \PWGen())->generate();
    }

    /**
     * Generate special hash
     * @return string
     */
    public function generateToken()
    {
        $this->updateAttributes([
            'token' => Yii::$app->security->generateRandomString(40),
            'token_created_at' => time(),
        ]);
        return $this->token;
    }

    /**
     * Start password restore procedure
     * @return bool
     */
    public function restore()
    {
        if (!$this->module->enablePasswordRestore) {
            $this->addError('error', Yii::t('activeuser_general', 'Password restore by email is disabled'));
            return false;
        }
        if ($this->isBlocked() || !$this->isConfirmed()) {
            $this->addError('error', Yii::t('activeuser_general', 'You cannot start restore procedure'));
            return false;
        }
        $this->generateToken();
        $this->updateAttributes([
            'status' => self::STATUS_RESTORE,
        ]);
        $this->module->sendMessage('restore', [
            'user' => $this,
        ]);
        return true;
    }

    /**
     * Check blocked user
     * @return bool
     */
    public function isBlocked()
    {
        return $this->status === self::STATUS_BLOCKED;
    }

    /**
     * Block user
     * @param bool $sendMail whether to send confirmation email about blocking.
     * If null, use global setting Module::$enableBlockingEmail
     * @return bool return false if user already blocked or not confirmed
     */
    public function block($sendMail = null)

This method seems to be duplicated in your project.

    {
        if ($this->isBlocked() || !$this->isConfirmed()) {
            return false;
        }
        if ($sendMail === null) {
            $sendMail = $this->module->enableBlockingEmail;
        }
        $this->updateAttributes([
            'status' => self::STATUS_BLOCKED
        ]);
        if ($sendMail) {
            $this->module->sendMessage('block', [
                'user' => $this,
            ]);
        }
        return true;
    }

    /**
     * Unblock user
     * @param bool $sendMail whether to send confirmation email about unblocking.
     * If null, use global setting Module::$enableUnblockingEmail
     * @return bool return false if user not blocked
     */
    public function unblock($sendMail = null)

This method seems to be duplicated in your project.

    {
        if (!$this->isBlocked()) {
            return false;
        }
        if ($sendMail === null) {
            $sendMail = $this->module->enableBlockingEmail;
        }
        $this->updateAttributes([
            'status' => self::STATUS_ACTIVE
        ]);
        if ($sendMail) {
            $this->module->sendMessage('unblock', [
                'user' => $this,
            ]);
        }
        return true;
    }

    /**
     * Change the user password
     * @return bool
     */
    public function changePassword()
    {
        if (!$this->isRestore()) {
            $this->addError('error', Yii::t('activeuser_general', 'User not request restore procedure'));
            return false;
        }
        if ($this->isRestoreTokenExpired()) {
            $this->addError('token', Yii::t('activeuser_general', 'You token was expired'));
            return false;
        }
        if (empty($this->password) && !$this->module->generatePassOnRestore) {
            $this->addError('password', Yii::t('activeuser_general', 'Password cannot be blank'));
            return false;
        }
        $this->status = self::STATUS_ACTIVE;
        $this->newPassword();
        return true;
    }

    /**
     * Set new password
     * @param bool $sendEmail whether to send email about password change
     * @throws yii\base\Exception
     * @throws yii\base\InvalidConfigException
     */
    public function newPassword($sendEmail = null)
    {
        if (empty($this->password)) {
            $this->password = $this->generatePassword();

It seems like $this->generatePassword() can also be of type array. However, the property $password is declared as type string. Maybe add an additional type check?

        }
        $this->updateAttributes([
            'pass_hash' => Yii::$app->getSecurity()->generatePasswordHash($this->password),
            'token' => null,
            'token_created_at' => 0,
            'status' => $this->status,
        ]);
        if ($sendEmail === null) {
            $sendEmail = $this->getModule()->enableNewPasswordEmail;
        }
        if ($sendEmail) {
            $this->module->sendMessage('passchanged', [
                'user' => $this,
            ]);
        }
    }

    /**
     * Check that user request restore
     * @return bool
     */
    public function isRestore()
    {
        return $this->status === self::STATUS_RESTORE;
    }

    /**
     * Get user status as text
     * @param string $status status value. If not set, get from model
     * @return null|string
     */
    public function getStatusText($status = null)
    {
        if ($status === null) {
            $status = $this->status;
        }
        $statuses = self::statusesList();
        return empty($statuses[$status]) ? '' : $statuses[$status];
    }

    /**
     * Get status list as array
     * @return array
     */
    static public function statusesList()

As per PSR2, the static declaration should come after the visibility declaration.

    {
        return [
            self::STATUS_ACTIVE => Yii::t('activeuser_general', 'Active'),
            self::STATUS_BLOCKED => Yii::t('activeuser_general', 'Blocked'),
            self::STATUS_CONFIRM => Yii::t('activeuser_general', 'Confirm'),
            self::STATUS_RESTORE => Yii::t('activeuser_general', 'Restore'),
        ];
    }

    /**
     * Get user gender as text
     * @param int $gender gender value. If not set, get from model
     * @return null|string
     */
    public function getGenderText($gender = null)
    {
        if ($gender === null) {
            $gender = $this->gender;
        }
        $genders = self::gendersList();
        return empty($genders[$gender]) ? $genders[0] : $genders[$gender];
    }

    /**
     * Get gender list as array
     * @return array
     */
    static public function gendersList()

As per PSR2, the static declaration should come after the visibility declaration.

    {
        return [
            0 => Yii::t('activeuser_general', 'None'),
            self::MALE => Yii::t('activeuser_general', 'Male'),
            self::FEMALE => Yii::t('activeuser_general', 'Female'),
        ];
    }

    /**
     * Resend confirmation message
     */
    public function resend()
    {
        if ($this->getModule()->enableConfirmation && !$this->getIsNewRecord() && $this->status === self::STATUS_CONFIRM) {
            $this->generateToken();
            $this->getModule()->sendMessage('confirm', [
                'user' => $this,
            ]);
        }
    }

    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            [
                'class' => ImageBehavior::className(),
                'imageAttribute' => 'avatar',
                'imageSize' => 150,
                'imageResizeStrategy' => ImageBehavior::CROP,
            ]
        ];
    }
}