common/models/User.php

<?php
    namespace common\models;
    use common\modules\comment\models\Comment;
    use common\modules\comment\models\CommentProject;
    use common\modules\comment\models\Rating;
    use Yii;
    use yii\base\InvalidConfigException;
    use yii\base\NotSupportedException;
    use yii\behaviors\TimestampBehavior;
    use yii\db\ActiveQuery;
    use yii\db\ActiveRecord;
    use yii\helpers\Url;
    use yii\rbac\ManagerInterface;
    use yii\rbac\Role;
    use yii\web\IdentityInterface;
    use developeruz\db_rbac\interfaces\UserRbacInterface;
    /**
     * User model
     * @property integer              $id
     * @property string               $username
     * @property string               $password_hash
     * @property string               $password_reset_token
     * @property string               $email
     * @property string               $auth_key
     * @property integer              $status
     * @property integer              $created_at
     * @property integer              $updated_at
     * @property string               $password write-only password
     * @property string               $type
     * @property UserInfo             $userInfo
     * @property string               $userName
     * @property array[]              $roles
     * @property CompanyInfo          $companyInfo
     * @property array[]              $phones
     * @property array[]              $site
     * @property string               $address
     * @property string               $liveTime
     * @property Payment[]            $payments
     * @property integer[]            $paymentInput
     * @property Specialization[]     $specializations
     * @property integer[]            $specializationInput
     * @property Blog[]               $blog
     * @property Job[]                $jobs
     * @property Job                  $currentJob
     * @property Portfolio[]          $portfolios
     * @property Project[]            $projects
     * @property Team[]               $teams
     * @property Vacancy[]            $vacancies
     * @property Gallery[]            $galleries
     * @property UserInfo|CompanyInfo $owner
     * @property string               $name
     * @property Comment[]            $comments
     * @property Rating[]             $commentRating
     * @property int                  $ratingPG
     * @property string               $lastVisit
     * @property string               $link
     * @method string minImg( string $dir, $width, $height = NULL ) Resizes image
     * @method array ShowGallery( string $array ) Splits string to image paths array
     */
    class User extends ActiveRecord implements IdentityInterface, UserRbacInterface
    {
        const STATUS_DELETED = 0;
        const STATUS_ACTIVE = 10;
        public $profile;
        public $old_password;
        public $new_password;
        public $password_reply;
        /**
         * @inheritdoc
         */
        public static function tableName()
        {
            return '{{%user}}';
        }
        /**
         * @inheritdoc
         */
        public function behaviors()
        {
            return [
                [
                    'class' => 'common\behaviors\ShowImage',
                ],
                TimestampBehavior::className(),
            ];
        }
        /**
         * @inheritdoc
         */
        public function rules()
        {
            return [
                [
                    'status',
                    'default',
                    'value' => self::STATUS_ACTIVE,
                ],
                [
                    'status',
                    'in',
                    'range' => [
                        self::STATUS_ACTIVE,
                        self::STATUS_DELETED,
                    ],
                ],
                [
                    [
                        'username',
                        'lastname',
                        'firstname',
                        'middlename',
                    ],
                    'string',
                    'max' => 255,
                ],
                [
                    [
                        'specializationInput',
                        'paymentInput',
                        'type',
                    ],
                    'safe',
                ],
                [
                    'type',
                    'default',
                    'value' => 1,
                ],
                [
                    [
                        'specializationInput',
                        'paymentInput',
                    ],
                    'default',
                    'value' => [ ],
                ],
            ];
        }
        /**
         * @inheritdoc
         */
        public function attributeLabels()
        {
            return [
                'firstname' => Yii::t('app', 'firstname'),
                'lastname'  => Yii::t('app', 'lastname'),
                'email'     => Yii::t('app', 'email'),
            ];
        }
        /**
         * @inheritdoc
         */
        public static function findIdentity($id)
        {
            if(Yii::$app->getSession()
                        ->has('user-' . $id)
            ) {
                if(Yii::$app->getSession()
                            ->has('user-' . $id)
                ) {
                    return new self(Yii::$app->getSession()
                                             ->get('user-' . $id));
                } else {
                    return isset( self::$users[ $id ] ) ? new self(self::$users[ $id ]) : NULL;
                }
            } else {
                return static::findOne([
                    'id'     => $id,
                    'status' => self::STATUS_ACTIVE,
                ]);
            }
        }
        /**
         * @param \nodge\eauth\ServiceBase $service
         *
         * @return User
         * @throws 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'),
                'authKey'  => md5($id),
                'profile'  => $service->getAttributes(),
            ];
            $attributes[ 'profile' ][ 'service' ] = $service->getServiceName();
            Yii::$app->getSession()
                     ->set('user-' . $id, $attributes);
            return new self($attributes);
        }
        public $authKey;
        /**
         * @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 boolean
         */
        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 boolean 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;
        }
        /**
         * Returns name of the User
         * @return string
         */
        public function getUserName()
        {
            return $this->username;
        }
        /**
         * Return array of all User's roles
         * @return array
         */
        public function getRoles()
        {
            $auth = \Yii::$app->authManager;
            $roles = $this->getRoleChildrenRecursive($auth->getRolesByUser($this->id), $auth);
            return $roles;
        }
        /**
         * @param       Role[]           $roles User roles returned by
         *                                      [ManagerInterface]->[getRolesByUser($id)]
         * @param       ManagerInterface $auth  Auth manager
         * @param array                  $result
         *
         * @return array
         */
        protected function getRoleChildrenRecursive($roles, $auth, $result = [ ])
        {
            if(is_array($roles) && !empty( $roles )) {
                foreach($roles as $role => $item) {
                    if(!( $item instanceof \yii\rbac\Role )) {
                        continue;
                    }
                    $result[] = $role;
                    $result = self::getRoleChildrenRecursive($auth->getChildren($role), $auth, $result);
                }
                return $result;
            } else {
                return $result;
            }
        }
        /**
         * Return UserInfo for this User
         * @return \yii\db\ActiveQuery
         */
        public function getUserInfo()
        {
            return $this->hasOne(UserInfo::className(), [ 'user_id' => 'id' ])
                        ->inverseOf('user');
        }
        /**
         * Check if User is Performer
         * <i>currently in development mode</i>
         * @return bool
         */
        public function getIsPerformer()
        {
            return true;
        }
        /**
         * Return CompanyInfo for this User
         * @return \yii\db\ActiveQuery
         */
        public function getCompanyInfo()
        {
            return $this->hasOne(CompanyInfo::className(), [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of User's phones
         * @return array
         */
        public function getPhones()
        {
            return Fields::getData($this->id, self::className(), 'phone');
        }
        /**
         * Return array of User's site
         * @return array
         */
        public function getSite()
        {
            return Fields::getData($this->id, self::className(), 'site');
        }
        /**
         * Return full address of User in view like:
         * <code>{country}, {city}, {street}, {house}</code>
         * @return string
         */
        public function getAddress()
        {
            $address = $this->userInfo->city;
            if(!empty( $this->userInfo->country )) {
                $address = $this->userInfo->country . ', ' . $address;
            }
            if($this->type == 2) {
                if(!empty( $this->companyInfo->street )) {
                    $address .= ', ' . $this->companyInfo->street;
                }
                if(!empty( $this->companyInfo->house )) {
                    $address .= ', ' . $this->companyInfo->house;
                }
            }
            return $address;
        }
        /**
         * Return relative interval of time from User registration date until now.
         * @return string
         */
        public function getLiveTime()
        {
            $now = new \DateTime('now');
            $date1 = new \DateTime(date('Y-m-d H:i:s', $this->created_at));
            $result = explode(',', \Yii::$app->formatter->asDuration($date1->diff($now)));
            if($result >= 4) {
                array_splice($result, 2);
            }
            return implode(',', $result);
        }
        /**
         * Check if User is Customer
         * <i>currently in development</i>
         * @return bool
         */
        public function getIsCustomer()
        {
            return true;
        }
        /**
         * Return array of payments types accepted by the user.
         * @return ActiveQuery
         */
        public function getPayments()
        {
            return $this->hasMany(Payment::className(), [ 'payment_id' => 'payment_id' ])
                        ->viaTable('user_payment', [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of Payment IDs, accepted by the user.
         * @return integer[]
         */
        public function getPaymentInput()
        {
            return $this->getPayments()
                        ->asArray()
                        ->column();
        }
        /**
         * Setter which allow to set User's payment ID's for further saving to the DB.
         *
         * @param integer[] $value
         */
        public function setPaymentInput($value)
        {
            $this->paymentInput = $value;
        }
        /**
         * Return array of Specializations in which the User works.
         * @return ActiveQuery
         */
        public function getSpecializations()
        {
            return $this->hasMany(Specialization::className(), [ 'specialization_id' => 'specialization_id' ])
                        ->viaTable('user_specialization', [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of User's blogs
         * @return ActiveQuery
         */
        public function getBlog()
        {
            return $this->hasMany(Blog::className(), [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of User's jobs.
         * @return ActiveQuery
         */
        public function getJobs()
        {
            return $this->hasMany(Job::className(), [ 'user_id' => 'id' ])
                        ->orderBy([
                            'current'    => SORT_DESC,
                            'date_start' => SORT_DESC,
                        ]);
        }
        /**
         * Return ActiveRecord of current User's place of work.
         * @return ActiveQuery
         */
        public function getCurrentJob()
        {
            return $this->hasOne(Job::className(), [ 'user_id' => 'id' ])
                        ->where([ 'current' => 1 ]);
        }
        /**
         * Return array of User's specialization IDs
         * @return integer[]
         */
        public function getSpecializationInput()
        {
            return $this->getSpecializations()
                        ->asArray()
                        ->indexBy('specialization_id')
                        ->column();
        }
        /**
         * Setter which allow to set User's specializations for further saving to the DB.
         *
         * @param integer[] $value
         */
        public function setSpecializationInput($value)
        {
            $this->specializationInput = $value;
        }
        /**
         * Return array of User's portfolios.
         * @return ActiveQuery
         */
        public function getPortfolios()
        {
            return $this->hasMany(Portfolio::className(), [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of User's projects.
         * @return ActiveQuery
         */
        public function getProjects()
        {
            return $this->hasMany(Project::className(), [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of company's Team members.
         * @return ActiveQuery
         */
        public function getTeams()
        {
            return $this->hasMany(Team::className(), [ 'user_id' => 'id' ]);
        }
        /**
         * Return array of company's Vacancies.
         * @return ActiveQuery
         */
        public function getVacancies()
        {
            return $this->hasMany(Vacancy::className(), [ 'user_id' => 'id' ])
                        ->inverseOf('user');
        }
        /**
         * Return all user's galleries
         * @return ActiveQuery
         */
        public function getGalleries()
        {
            $portfolio_galleries = PortfolioGallery::find()
                                                   ->select('gallery_id')
                                                   ->asArray()
                                                   ->where([ 'user_id' => $this->id ])
                                                   ->column();
            return $this->hasMany(Gallery::className(), [ 'user_id' => 'id' ])
                        ->andWhere([
                            'not',
                            [ 'gallery_id' => $portfolio_galleries ],
                        ]);
        }
        /**
         * Return company info or user info according to user type
         * @return ActiveQuery
         */
        public function getOwner()
        {
            if($this->type == 2) {
                return $this->hasOne(CompanyInfo::className(), [ 'user_id' => 'id' ]);
            } else {
                return $this->hasOne(UserInfo::className(), [ 'user_id' => 'id' ]);
            }
        }
        /**
         * Return company name or user firstname and lastname according to user type
         * @return string
         */
        public function getName()
        {
            if($this->type == 2) {
                return $this->companyInfo->name;
            } else {
                return $this->firstname . ' ' . $this->lastname;
            }
        }
        /**
         * Return all comments to user
         * @return ActiveQuery
         */
        public function getComments()
        {
            return $this->hasMany(Comment::className(), [
                'model_id' => 'id',
            ])
                        ->andWhere([
                            'comment.model' => $this->className(),
                        ])
                        ->orderBy([ 'date_update' => SORT_DESC ]);
        }
        /**
         * Return all ratings to user
         * @return ActiveQuery
         */
        public function getCommentRating()
        {
            return $this->hasMany(Rating::className(), [ 'model_id' => 'comment_id' ])
                        ->via('comments')
                        ->andWhere([
                            'rating.model' => Comment::className(),
                        ]);
        }
        /**
         * Return user's rating<br>
         * <b>Available only for PostgreSQL</b>
         * @return int
         * @throws InvalidConfigException
         */
        public function getRatingPG()
        {
            if(\Yii::$app->db->driverName != 'pgsql') {
                throw new InvalidConfigException('This method is available only in PostgreSQL');
            }
            return $this->getCommentRating()
                        ->select([ 'rating' => 'ROUND(SUM("rating"."value")/COUNT("rating"."rating_id")::numeric, 2)' ])
                        ->andWhere([
                            'not',
                            [ 'rating.value' => NULL ],
                        ])
                        ->scalar();
        }
        /**
         * Recalculate rating and write it to db.
         * <b>Only for PostgreSQL</b>
         * @see \common\models\User::getRatingPG()
         * @throws InvalidConfigException
         */
        public function updateRating()
        {
            if($rating = $this->getRatingPG()) {
                $this->userInfo->rating = $rating;
                $this->userInfo->save();
            }
        }
        public function getLastVisit()
        {
            return \Yii::$app->formatter->asRelativeTime($this->userInfo->date_visit);
        }
        /**
         * Return link to user personal page according to user type
         * @return string
         */
        public function getLink($page = 'common')
        {
            if($this->type == 2) {
                return Url::to([
                    'company/' . $page,
                    'company_id' => $this->id,
                ]);
            } else {
                return Url::to([
                    'performer/' . $page,
                    'performer_id' => $this->id,
                ]);
            }
        }
        public function getIsBookmarked($type = Bookmark::TYPE_PERFORMER)
        {
            if(!empty( \Yii::$app->user->identity )) {
                if(!empty( $this->hasOne(Bookmark::className(), [ 'model_id' => 'id' ])
                                ->andWhere([
                                    'model'   => $this->className(),
                                    'user_id' => \Yii::$app->user->getId(),
                                    'type'    => $type,
                                ])
                                ->one() )
                ) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        public function getBookmarks()
        {
            return $this->hasMany(Bookmark::className(), [ 'user_id' => 'id' ]);
        }
        public function getBookmarksPerformers()
        {
            return $this->hasMany(User::className(), [ 'id' => 'model_id' ])
                        ->viaTable('{{%bookmark}}', [ 'user_id' => 'id' ], function($query) {
                            /**
                             * @var ActiveQuery $query
                             */
                            $query->andWhere([
                                'model' => User::className(),
                                'type'  => Bookmark::TYPE_PERFORMER,
                            ]);
                        });
        }
        public function getBookmarksCustomers()
        {
            return $this->hasMany(User::className(), [ 'id' => 'model_id' ])
                        ->viaTable('{{%bookmark}}', [ 'user_id' => 'id' ], function($query) {
                            /**
                             * @var ActiveQuery $query
                             */
                            $query->andWhere([
                                'model' => User::className(),
                                'type'  => Bookmark::TYPE_CUSTOMER,
                            ]);
                        });
        }
        public function getBookmarksProjects()
        {
            return $this->hasMany(Project::className(), [ 'project_id' => 'model_id' ])
                        ->viaTable('{{%bookmark}}', [ 'user_id' => 'id' ], function($query) {
                            /**
                             * @var ActiveQuery $query
                             */
                            $query->andWhere([
                                'model' => Project::className(),
                                'type'  => Bookmark::TYPE_PROJECT,
                            ]);
                        });
        }
        public function getBookmarksVacancies()
        {
            return $this->hasMany(Vacancy::className(), [ 'vacancy_id' => 'model_id' ])
                        ->viaTable('{{%bookmark}}', [ 'user_id' => 'id' ], function($query) {
                            /**
                             * @var ActiveQuery $query
                             */
                            $query->andWhere([
                                'model' => Vacancy::className(),
                                'type'  => Bookmark::TYPE_VACANCY,
                            ]);
                        });
        }
        public function getChatCount()
        {
            return Chat::find()
                       ->select('COUNT(*)')
                       ->where([
                           'or',
                           [ 'from_user' => $this->id ],
                           [ 'to_user' => $this->id ],
                       ])
                       ->scalar();
        }
        public function getCommentProjects()
        {
            return $this->hasMany(CommentProject::className(), [ 'user_id' => 'id' ]);
        }
        public function getChat($user_id)
        {
            return Chat::find()
                       ->where([
                           'or',
                           [ 'from_user' => $user_id, ],
                           [ 'to_user' => $user_id, ],
                       ])
                       ->andWhere([
                           'or',
                           [ 'from_user' => $this->id, ],
                           [ 'to_user' => $this->id, ],
                       ])
                       ->with('messages.user');
        }
        public function getIsOnline()
        {
            if(( time() - \Yii::$app->formatter->asTimestamp($this->userInfo->date_visit) ) < 1800) {
                return true;
            } else {
                return false;
            }
        }
    }