Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/common/models/
Linux eb5096292c53 5.15.0-102-generic #112-Ubuntu SMP Tue Mar 5 16:50:32 UTC 2024 x86_64
Current File : /home/vmanager/www/common/models/Users.php
<?php

namespace common\models;

use Yii;
use yii\db\ActiveRecord;
use yii\db\Expression;
use yii\behaviors\TimestampBehavior;
use common\components\validators\Password;
use common\components\behaviors\DeleteRelatedModelsBehavior;
use common\models\types\Status;
use common\models\types\UserProfile;
use yii\web\IdentityInterface;

class Users extends ActiveRecord implements IdentityInterface
{
    use \common\components\traits\ImagesVariants;
    use \common\components\traits\DirectoriesFunctions;
    
    public $file;
    public $orDeleteCurrentFile = 0;
    
    protected static $acceptedImageSizes = ['64x64', '160x160', '250x250'];
    
    private $_settings = null;
    
    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return '{{%users}}';
    }
    
    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            [
                'class' => TimestampBehavior::className(),
                'value' => new Expression('LOCALTIMESTAMP'),
            ],
            [
                'class' => DeleteRelatedModelsBehavior::className(),
            ]
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function scenarios()
    {
        $scenarios = parent::scenarios();
        $scenarios['create'] = ['login', 'password', 'forename', 'surname', 'description', 'status', 'settings', 'avatar_filename', 'profile', 'referrer', 'orDeleteCurrentFile'];
        $scenarios['createBasic'] = ['login', 'password', 'forename', 'surname', 'description', 'referrer'];
        $scenarios['update'] = ['login', 'password', 'forename', 'surname', 'description', 'status', 'settings', 'avatar_filename', 'profile', 'referrer', 'orDeleteCurrentFile'];
        $scenarios['updateBasic'] = ['login', 'forename', 'surname', 'description', 'status', 'avatar_filename', 'orDeleteCurrentFile'];
        $scenarios['updateOwn'] = ['forename', 'surname', 'description', 'avatar_filename', 'orDeleteCurrentFile'];
        return $scenarios;                
    }
    
    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            ['login', 'required'],
            ['login', 'trim'], 
            ['login', 'string', 'min' => 2, 'max' => 60],
            ['login', 'unique', 'filter' => ($this->id_user) ? ['!=', 'login', $this->getOldAttribute('login')] : null],
            
            ['password', 'required', 'on' => 'create'],
            ['password', 'string', 'min' => 8, 'max' => 60],
            ['password', Password::className(), 'minStrength' => 3],
            
            ['forename', 'required'],
            ['forename', 'trim'], 
            ['forename', 'string', 'min' => 1, 'max' => 30],
            
            ['surname', 'required'],
            ['surname', 'trim'], 
            ['surname', 'string', 'min' => 1, 'max' => 40],
            
            ['description', 'default'],
            ['description', 'string', 'min' => 5, 'max' => 255],
            
            ['status', 'default', 'value' => Status::ACTIVE],
            ['status', 'required'],
            ['status', 'in', 'range' => Status::$values],
            
            ['settings', 'default', 'value' => new \stdClass()],
            ['settings', 'required'],
            
            ['avatar_filename', 'default'],
            ['avatar_filename', 'string', 'min' => 5, 'max' => 255],
            ['avatar_filename', 'image', 'extensions' => ['jpg', 'gif', 'png'], 'maxFiles' => 1, 'maxSize' => 3145728, 'maxWidth' => 1920, 'maxHeight' => 1080, 'checkExtensionByMimeType' => true],
//            ['file', 'file', 'extensions' => array('jpg', 'gif', 'png'), 'maxFiles' => 1, 'maxSize' => 204800, 'checkExtensionByMimeType' => true, 'skipOnEmpty' => true],
            
            
            
            ['auth_key', 'required'],
            ['auth_key', 'string', 'min' => 64, 'max' => 255],
            ['auth_key', 'unique'],
            
            ['profile', 'default', 'value' => UserProfile::COMPANY],
            ['profile', 'required'],
            ['profile', 'in', 'range' => UserProfile::$values]            ,
            
            ['referrer', 'default'],
            ['referrer', 'filter', 'filter' => function($value) { $value = trim((string)$value); return !empty($value) ? $value : null; }],
            ['referrer', 'string', 'min' => 1, 'max' => 60],
            
            ['orDeleteCurrentFile', 'safe']
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id_user' => \Yii::t('common-models', 'ID użytkownika'),
            'login' => \Yii::t('common-models', 'Login'),
            'password' => \Yii::t('common-models', 'Hasło'),
            'forename' => \Yii::t('common-models', 'Imię'),
            'surname' => \Yii::t('common-models', 'Nazwisko'),
            'description' => \Yii::t('common-models', 'Opis'),
            'status' => \Yii::t('common-models', 'Status'),
            'profile' => \Yii::t('common-models', 'Profil'),
            'referrer' => \Yii::t('common-models', 'Polecający'),
            'settings' => \Yii::t('common-models', 'Ustawienia'),
            'avatar_filename' => \Yii::t('common-models', 'Avatar'),
            'auth_key' => \Yii::t('common-models', 'Klucz autoryzacji'),
            'created_at' => \Yii::t('common-models', 'Data utworzenia'),
            'updated_at' => \Yii::t('common-models', 'Data aktualizacji'),
            
            'file' => \Yii::t('common-models', 'Avatar'),
        ];
    }
    
    public function getIdOwner() 
    {
        return $this->id_user;
    }
    
    public static function getDependentModels() 
    {   
        return [
            'companies',
            'passwordsReset',
            'advertisements',
            'inquiries',
            'contactData',
            'addresses',
            'salesDistributions',
            'relationsWithManagedCompanies',
            'advertisementsMessages',
            'shoppingAddressBook',
            'shoppingDataToAccount'
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function afterDelete() {
        parent::afterDelete();
        
        if(!empty($this->avatar_filename)) {
            $file = \Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/'.$this->avatar_filename;
            if(file_exists($file)) {
                self::deleteVariants($file);
                @unlink($file);
            } 
        }
        
        if(file_exists(Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/')) {
            $this->removeDir(Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/');
        }

        \common\models\Emails::deleteAll(['id_user' => $this->id_user]);
        
        \common\models\Notifications::deleteAll(['id_user' => $this->id_user]);
        
        \common\models\UsersChanges::deleteAll(['id_user' => $this->id_user]);
        
        Yii::$app->authManager->revoke(Yii::$app->authManager->getRole($this->profile), $this->id_user);        
    }
    
    public function afterFind() {
        parent::afterFind();        
        if($this->_settings === null) {
//            $this->_settings = (!empty($this->settings) ? json_decode($this->settings, true) : []);
            $this->_settings = (!empty($this->settings) ? $this->settings : []); //#JSON-hack#
        }
    }
    
    public function beforeSave($insert) 
    {
        if (parent::beforeSave($insert)) {
//            $this->settings = (!empty($this->_settings)) ? json_encode($this->_settings) : '{}'; 
            $this->settings = (!empty($this->_settings)) ? $this->_settings : []; //#JSON-hack#
            return true;
        } else {
            return false;
        }
    }
    
    public function setSettingsKey($key, $value) 
    {
        $this->_settings[$key] = $value;
    }
    
    public function getSettingsKey($key)
    {
        return isset($this->_settings[$key]) ? $this->_settings[$key] : null;
    }
    
    public function deleteSettingsKey($key) 
    {
        unset($this->_settings[$key]);
    }
    
    public function saveSettings()
    {
//        $this->settings = json_encode($this->_settings);
        $this->settings = $this->_settings; //#JSON-hack#
        $flag = $this->save(false);
        
        return $flag;
    }
    
    public function getSettings() 
    {
        return $this->_settings;
    }
    
    public static function createAvatarFileName($baseName, $extension) 
    {
        $baseName = strtolower(iconv('UTF-8', 'ASCII//TRANSLIT', $baseName));
        $baseName = preg_replace('/\s+/i', '-', $baseName);
        $baseName = preg_replace('/[^a-zA-Z0-9_\-]/i', '', $baseName); 
        
        return $baseName.'-'.str_replace(' ', '', substr(microtime(), 2)).'.'.  strtolower($extension);
    }
    
//    public function getAvatarUrl()
//    {
//        return (!empty($this->avatar_filename)) ? \Yii::getAlias('@usersImagesUrl').'/'.$this->id_user.'/'.$this->avatar_filename : null;        
//    }
    
    public static function getAvatarUrlForUser($filename, $idUser, $absolute = false)
    {
        if(empty($filename)) {
            return null;
        }
        $path = ($absolute === true) ? Yii::getAlias('@usersImagesUrl') : Yii::getAlias('@usersImagesRealPath');
        return $path.'/'.$idUser.'/'.$filename;        
    }
    
    public function getAvatarUrl($absolute = false)
    {
        $path = ($absolute === true) ? Yii::getAlias('@usersImagesUrl') : Yii::getAlias('@usersImagesRealPath');
        return (!empty($this->avatar_filename)) ? $path.'/'.$this->id_user.'/'.$this->avatar_filename : null;        
    }
    
    public function loadAvatarFile()
    {
        $oldImagePath = null;  
        if($this->isNewRecord) {
            $this->file = \yii\web\UploadedFile::getInstance($this, 'file');
            if($this->file) {
                $this->avatar_filename = self::createAvatarFileName($this->file->baseName, $this->file->extension);
            }
        } else {
            $oldImageFilename = $this->getOldAttribute('avatar_filename');
            $orDeleteCurrentFile = intval($this->orDeleteCurrentFile);            
            if($orDeleteCurrentFile !== 1) {                
                $this->file = \yii\web\UploadedFile::getInstance($this, 'file');
                if($this->file) {        
                    if(!empty($oldImageFilename)) {
                        $oldImagePath = Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/'.$oldImageFilename;
                    }
                    $this->avatar_filename = self::createAvatarFileName($this->file->baseName, $this->file->extension);
                }
                else {
                    $this->avatar_filename = (!empty($oldImageFilename)) ? $oldImageFilename : null;
                }
            }
            elseif(!empty($oldImageFilename)) {
                $oldImagePath = Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/'.$oldImageFilename;
                $this->avatar_filename = null;
            }
            else {
                $this->avatar_filename = null;
            }
        }
        
        return $oldImagePath;
    }
    
    public function saveAvatarFile()
    {
        $newImagePath = null;
        if($this->file) {
            $dir = Yii::getAlias('@usersImagesRealPath').'/'.$this->id_user.'/';
            if(!file_exists($dir)) {
                mkdir($dir, 0777, true);
            }
            $newImagePath = $dir.$this->avatar_filename;

            if(!$this->file->saveAs($newImagePath)) {
                return false;
            } 
        }
        
        return $newImagePath;
    }
    
    /**
     * Finds user by username
     *
     * @param string $username
     * @return static|null
     */
    public static function findByUsername($username)
    {
        return static::findOne(['login' => $username, 'status' => Status::ACTIVE]);
    }
    
    /**
     * Validates password
     *
     * @param string $password password to validate
     * @return boolean if password provided is valid for current user
     */
    public function validatePassword($password)
    {
        //proteza
//        $hash = \Yii::$app->getSecurity()->generatePasswordHash($password);
        $hash = $this->password;
        return \Yii::$app->security->validatePassword($password, $hash);
    }
    
    /**
     * Generates password hash from password and sets it to the model
     *
     * @param string $password
     */
    public function generateHashPassword($password)
    {
        $this->password = \Yii::$app->security->generatePasswordHash($password);
    }
    
    /**
     * @inheritdoc
     */
    public static function findIdentity($id)
    {
        return static::findOne(['id_user' => $id, 'status' => Status::ACTIVE]);
    }
    
    /**
     * @inheritdoc
     */
    public static function findIdentityByAccessToken($token, $type = null)
    {
        $rowset = \Yii::$app->db->createCommand('SELECT user_id AS id FROM oauth_access_tokens WHERE access_token=:token')->bindValue(':token', $token)->query();
        $row = $rowset->read();
        if(!$row) {
            return null;
        }
        return self::findIdentity(intval($row['id']));
//        throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
    }
    
    /**
     * @inheritdoc
     */
    public function getId()
    {
        return $this->getPrimaryKey();
    }
    
    /**
     * @inheritdoc
     */
    public function getAuthKey()
    {
        return $this->auth_key;
    }
    
    /**
     * Generates "remember me" authentication key
     */
    public function generateAuthKey()
    {
        $this->auth_key = \Yii::$app->security->generateRandomString(64);
    }
    
    /**
     * @inheritdoc
     */
    public function validateAuthKey($authKey)
    {
        return $this->getAuthKey() === $authKey;
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getPasswordsReset()
    {
        return $this->hasMany(UsersPasswordsReset::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompanies()
    {
        return $this->hasMany(Companies::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    //@todo - do usunięcia, powiązanie potrzebne tylko do prezentacji elementów testowych (Samples)
    public function getUserPosts()
    {
        return $this->hasMany(\backend\models\Posts::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompaniesCases()
    {
        return $this->hasMany(CompaniesCases::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompaniesCasesEntries()
    {
        return $this->hasMany(CompaniesCasesEntries::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompaniesOrders()
    {
        return $this->hasMany(CompaniesOrders::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getPortals()
    {
        return $this->hasMany(Portals::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getMailingsReservations()
    {
        return $this->hasMany(MailingsReservations::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAdvertisements()
    {
        return $this->hasMany(Advertisements::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getInquiries()
    {
        return $this->hasMany(Inquiries::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getContactData()
    {
        return $this->hasMany(UsersContactData::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAddresses()
    {
        return $this->hasMany(UsersAddresses::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getBookstoreOrders()
    {
        return $this->hasMany(BookstoreOrders::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompaniesOrdersItems()
    {
        return $this->hasMany(CompaniesOrdersItems::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithServicedPortals()
    {
        return $this->hasMany(PortalsHasOperators::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getServicedPortals()
    {
        return $this->hasMany(Portals::className(), ['id_portal' => 'id_portal'])->via('relationsWithServicedPortals');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithOperatorsSections()
    {
        return $this->hasMany(OperatorsSectionsHasUsers::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getOperatorsSections()
    {
        return $this->hasMany(OperatorsSections::className(), ['id_section' => 'id_section'])->via('relationsWithOperatorsSections');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getSalesDistributions()
    {
        return $this->hasMany(CompaniesOrdersSalesDistributions::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCooperatedCompaniesOrders()
    {
        return $this->hasMany(CompaniesOrders::className(), ['id_order' => 'id_order'])->via('salesDistributions');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithManagedCompanies()
    {
        return $this->hasMany(OperatorsHasCompanies::className(), ['id_user' => 'id_user'])->inverseOf('operator');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getManagedCompanies()
    {
        return $this->hasMany(Companies::className(), ['id_company' => 'id_company'])->via('relationsWithManagedCompanies');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAdvertisementsMessages()
    {
        return $this->hasMany(AdvertisementsMessages::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    public function getRelationsWithPortals()
    {
        return $this->hasMany(UsersHasPortals::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    public function getActivePortals()
    {
        return $this->hasMany(Portals::className(), ['id_portal' => 'id_portal'])->via('relationsWithPortals');
    }
    
    public function getPayments()
    {
        return $this->hasMany(UsersPayments::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    public function getCompaniesChanges()
    {
        return $this->hasMany(CompaniesChanges::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    public function getShoppingAddressBook()
    {
        return $this->hasMany(ShoppingAddressBook::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    public function getShoppingDataToAccount()
    {
        return $this->hasMany(ShoppingDataToAccount::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getArticlesComments()
    {
        return $this->hasMany(ArticlesComments::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getBannersReservations()
    {
        return $this->hasMany(BannersReservations::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getOffers()
    {
        return $this->hasMany(Offers::className(), ['id_user' => 'id_user'])->inverseOf('user');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAgencyArticles()
    {
        return $this->hasMany(Articles::className(), ['agency_id_operator' => 'id_user'])->inverseOf('operator');
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com