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;
          }
          

      }