Yarik / artbox-order

<?php
    
    namespace artbox\order\models;

    use artbox\catalog\models\Product;
    use artbox\catalog\models\Variant;
    use artbox\core\helpers\UnificatorHelper;
    use nodge\eauth\ErrorException;
    use Yii;
    use yii\base\NotSupportedException;
    use yii\behaviors\TimestampBehavior;
    use yii\db\ActiveQuery;
    use yii\db\ActiveRecord;
    use yii\web\IdentityInterface;

    /**
     * This is the model class for table "customer".
     *
     * @property integer $id
     * @property string  $username
     * @property string  $auth_key
     * @property string  $password_hash
     * @property string  $password_reset_token
     * @property string  $email
     * @property integer $status
     * @property integer $created_at
     * @property integer $updated_at
     * @property string  $name
     * @property string  $phone
     * @property integer $gender
     * @property integer $birthday
     * @property string  $city
     * @property string  $address
     * @property array   $wishlist
     * @property Order[] $orders
     * @property string  $social_id
     */
    class Customer extends ActiveRecord implements IdentityInterface
    {
        const STATUS_ACTIVE = 10;
        const STATUS_DELETED = 0;
        const GENDER_MALE = 1;
        const GENDER_FEMALE = 2;
    
        const SCENARIO_SOCIAL = 'social';
        
        protected $wishlist = null;
    
        /**
         * @var array EAuth attributes
         */
        public $profile;
    
        public static $users;
        
        /**
         * @return array|\yii\db\ActiveRecord[]
         */
        public function getWishlist()
        {
            if ($this->wishlist === null) {
                $this->wishlist = Wishlist::find()
                                          ->select('variant_id')
                                          ->where(
                                              [
                                                  'user_id' => $this->id,
                                              ]
                                          )
                                          ->column();
            }
            return $this->wishlist;
        }
    
        public function getBirthDate()
        {
            if (empty($this->birthday)) {
                return '';
            } else {
                return date('d.m.Y', $this->birthday);
            }
        }
    
        public function setBirthDate($value)
        {
            $this->birthday = strtotime($value);
        }
    
        /**
         * @inheritdoc
         */
        public static function tableName()
        {
            return 'customer';
        }
    
        /**
         * @inheritdoc
         */
        public function behaviors()
        {
            return [
                TimestampBehavior::className(),
            ];
        }
    
        /**
         * @inheritdoc
         */
        public function rules()
        {
            return [
                [
                    [
                        'username',
                    ],
                    'required',
                ],
                [
                    [ 'birthDate' ],
                    'safe',
                ],
                [
                    [
                        'status',
                        'gender',
                        'birthday',
                    ],
                    'integer',
                ],
                [
                    [
                        'username',
                        'email',
                        'name',
                        'phone',
                        'city',
                        'address',
                    ],
                    'string',
                    'max' => 255,
                ],
                [
                    [ 'email' ],
                    'unique',
                ],
                [
                    [ 'username' ],
                    'unique',
                ],
                [
                    [ 'status' ],
                    'in',
                    'range' => [
                        self::STATUS_ACTIVE,
                        self::STATUS_DELETED,
                    ],
                ],
                [
                    [ 'gender' ],
                    'in',
                    'range' => [
                        self::GENDER_MALE,
                        self::GENDER_FEMALE,
                    ],
                ],
                [
                    [ 'email', ],
                    'required',
                    'except' => [
                        self::SCENARIO_SOCIAL,
                    ],
                ],
            ];
        }
    
        /**
         * @inheritdoc
         */
        public function attributeLabels()
        {
            return [
                'id'                   => Yii::t('order', 'ID'),
                'username'             => Yii::t('order', 'Username'),
                'auth_key'             => Yii::t('order', 'Auth Key'),
                'password_hash'        => Yii::t('order', 'Password Hash'),
                'password_reset_token' => Yii::t('order', 'Password Reset Token'),
                'email'                => Yii::t('order', 'Email'),
                'status'               => Yii::t('order', 'Status'),
                'created_at'           => Yii::t('order', 'Created At'),
                'updated_at'           => Yii::t('order', 'Updated At'),
                'name'                 => Yii::t('order', 'Name'),
                'phone'                => Yii::t('order', 'Phone'),
                'gender'               => Yii::t('order', 'Gender'),
                'birthday'             => Yii::t('order', 'Birthday'),
                'city'                 => Yii::t('order', 'City'),
                'address'              => Yii::t('order', 'Address'),
            ];
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getOrders()
        {
            return $this->hasMany(Order::className(), [ 'user_id' => 'id' ])
                        ->inverseOf('customer');
        }
    
        /**
         * @return ActiveQuery
         */
        public function getWishProducts()
        {
            return $this->hasMany(Product::className(), [ 'id' => 'product_id' ])
                        ->viaTable(
                            'wishlist',
                            [
                                'user_id' => 'id',
                            ]
                        );
        }
    
        /**
         * @return ActiveQuery
         */
        public function getWishVariants()
        {
            return $this->hasMany(Variant::className(), [ 'id' => 'variant_id' ])
                        ->viaTable(
                            'wishlist',
                            [
                                'user_id' => 'id',
                            ]
                        );
        }
    
        /**
         * @inheritdoc
         */
        public static function findIdentity($id)
        {
            if (\Yii::$app->getSession()
                          ->has('user-' . $id)
            ) {
                return new self(
                    \Yii::$app->getSession()
                              ->get('user-' . $id)
                );
            } else {
                return static::findOne(
                    [
                        'id'     => $id,
                        'status' => self::STATUS_ACTIVE,
                    ]
                );
            }
        }
    
        /**
         * @inheritdoc
         */
        public static function findIdentityByAccessToken($token, $type = null)
        {
            throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
        }
    
        /**
         * Finds user by username
         *
         * @param string $username
         *
         * @return static|null
         */
        public static function findByUsername($username)
        {
            return static::findOne(
                [
                    'username' => $username,
                    'status'   => self::STATUS_ACTIVE,
                ]
            );
        }
    
        /**
         * Finds user by password reset token
         *
         * @param string $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 string $token password reset token
         *
         * @return bool
         */
        public static function isPasswordResetTokenValid($token)
        {
            if (empty($token)) {
                return false;
            }
    
            $timestamp = (int) substr($token, strrpos($token, '_') + 1);
            $expire = Yii::$app->params[ 'user.passwordResetTokenExpire' ];
            return $timestamp + $expire >= time();
        }
    
        /**
         * @inheritdoc
         */
        public function getId()
        {
            return $this->getPrimaryKey();
        }
    
        /**
         * @inheritdoc
         */
        public function getAuthKey()
        {
            return $this->auth_key;
        }
    
        /**
         * @inheritdoc
         */
        public function validateAuthKey($authKey)
        {
            return $this->getAuthKey() === $authKey;
        }
    
        /**
         * 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
         */
        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 \nodge\eauth\ServiceBase $service
         *
         * @return \artbox\order\models\Customer
         * @throws \nodge\eauth\ErrorException
         */
        public static function findByEAuth($service)
        {
            if (!$service->getIsAuthenticated()) {
                throw new ErrorException('EAuth user should be authenticated before creating identity.');
            }
            $id = $service->getServiceName() . '-' . $service->getId();
            $attributes = [
                'id'       => $id,
                'username' => $service->getAttribute('name') ? : $service->getAttribute('username'),
                'authKey'  => md5($id),
                'profile'  => $service->getAttributes(),
            ];
            $attributes[ 'profile' ][ 'service' ] = $service->getServiceName();
            $identity = self::find()
                            ->where(
                                [
                                    'social_id' => $id,
                                ]
                            )
                            ->one();
            if (!$identity) {
                $identityAttrs = $attributes;
                unset($identityAttrs[ 'id' ]);
                $identityAttrs[ 'social_id' ] = $id;
                $identity = self::register($identityAttrs);
            }
            \Yii::$app->getSession()
                      ->set('user-' . $id, $attributes);
            return $identity;
        }
    
        public function setAuthKey($key)
        {
            $this->auth_key = $key;
        }
    
        /**
         * @param array $attributes
         *
         * @return \artbox\order\models\Customer
         */
        protected function register(array $attributes)
        {
            $identity = new self($attributes);
            $identity->scenario = self::SCENARIO_SOCIAL;
            $identity->username = UnificatorHelper::unify(
                $identity->username,
                function ($name) {
                    if (Customer::findByUsername($name)) {
                        return false;
                    } else {
                        return true;
                    }
                }
            );
            $identity->setPassword($attributes[ 'social_id' ]);
            $identity->save();
            return $identity;
        }
        
    }