Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/backend/controllers/
Linux 9dbcd5f6333d 5.15.0-102-generic #112-Ubuntu SMP Tue Mar 5 16:50:32 UTC 2024 x86_64
Current File : /home/vmanager/www/backend/controllers/UsersController.php
<?php

namespace backend\controllers;

use Yii;
use common\models\Users;
use common\models\UsersContactData;
use common\models\UsersAddresses;
use common\models\Emails;
use common\models\types\ContactDataType;
use common\models\types\UserChangeType;
use backend\models\UsersSearch;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;
use yii\filters\VerbFilter;
use yii\caching\TagDependency;
use yii\helpers\ArrayHelper;

/**
 * UsersController implements the CRUD actions for Users model.
 */
class UsersController extends Controller
{
    use \backend\components\traits\ControllerFunctions;
    use \backend\components\traits\CacheTagsFunctions;
    
    public function behaviors()
    {
        $behaviors = parent::behaviors();
        $behaviors['access'] = [
            'class' => \yii\filters\AccessControl::className(),
            'only' => ['index', 'create', 'create-regular-user', 'delete', 'assign-new-companies'],
            'rules' => [
                ['allow' => true, 'actions' => ['index'], 'roles' => ['indexUsers']],
                ['allow' => true, 'actions' => ['create'], 'roles' => ['createUsers']],
                ['allow' => true, 'actions' => ['create-regular-user'], 'roles' => ['createBasicUsers']],
                ['allow' => true, 'actions' => ['delete'], 'roles' => ['deleteUsers']],
                ['allow' => true, 'actions' => ['assign-new-companies'], 'roles' => ['assignNewCompaniesToOperators']],
            ],
        ];
        return $behaviors;
    }

    /**
     * Lists all Users models.
     * @return mixed
     */
    public function actionIndex()
    {        
        $searchModel = new UsersSearch(['scenario' => 'administratorListing']);
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
//            'statusTypeValuesWithLabels' => $statusTypeValuesWithLabels
        ]);
    }

    /**
     * Displays a single Users model.
     * @param integer $id
     * @return mixed
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
        if(Yii::$app->user->can('viewUsers')) {
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(Yii::$app->user->can('viewOwnUsers', ['model' => $model])) {
            Yii::$app->params['activeMenuItem'] = 'user-own-basic-data';
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $dataProviderAddresses = new \yii\data\ActiveDataProvider([
            'query' => $model->getAddresses(),
            'pagination' => false,
            'sort' => false
        ]);
        
        if(Yii::$app->user->can('indexUsersShippingData')) {
            $dataProviderShippingData = new \yii\data\ActiveDataProvider([
                'query' => $model->getShoppingAddressBook()->where(['id_company' => null]),
                'pagination' => false,
                'sort' => false
            ]);
        } else {
            $dataProviderShippingData = null;
        }
        
        if(Yii::$app->user->can('indexUsersDataToAccount')) {
            $dataProviderDataToAccount = new \yii\data\ActiveDataProvider([
                'query' => $model->getShoppingDataToAccount()->where(['id_company' => null]),
                'pagination' => false,
                'sort' => false
            ]);
        } else {
            $dataProviderDataToAccount = null;
        }
        
        return $this->render('view', [
            'model' => $model,
            'dataProviderAddresses' => $dataProviderAddresses,
            'dataProviderShippingData' => $dataProviderShippingData,
            'dataProviderDataToAccount' => $dataProviderDataToAccount
        ]);
    }

    /**
     * Creates a new Users model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreate()
    {
        $model = new \backend\models\Users(['scenario' => 'create']);
        $baseModelContactData = new UsersContactData(['scenario' => 'create']);
        
        $labelsForContactDataTypes = ContactDataType::getValuesWithLabels();
        
        $modelsContactData[] = new UsersContactData(['scenario' => 'create', 'data_order' => 1, 'required' => 1, 'data_type' => ContactDataType::EMAIL, 'data_label' => ucfirst($labelsForContactDataTypes[ContactDataType::EMAIL])]);
        $modelsContactData[] = new UsersContactData(['scenario' => 'create', 'data_order' => 2, 'required' => 1, 'data_type' => ContactDataType::MOBILE_PHONE, 'data_label' => ucfirst($labelsForContactDataTypes[ContactDataType::MOBILE_PHONE])]);
        
        if(Yii::$app->request->getIsPost()) {
            $postUsersData = Yii::$app->request->post('UsersContactData', []);            
            if(!empty($postUsersData)) {
                foreach($postUsersData as $key => $value) {
                    if(!isset($modelsContactData[$key])) {
                        $modelsContactData[$key] = new UsersContactData(['scenario' => 'create']);
                    }
                }
            }
        }
        
        Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        
        if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post()) && (empty($modelsContactData) || \yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return array_merge(\yii\bootstrap\ActiveForm::validate($model), !empty($modelsContactData) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsContactData, ['data_type', 'data_value', 'data_label', 'data_order']) : []);
        }
        
        if(Yii::$app->request->getIsPost()) {             
            if(!$model->load(Yii::$app->request->post()) || (!empty($modelsContactData) && !\yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('create', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
            }

            $model->settings = ['advertisements_limit' => Yii::$app->params['limitOfFreeAdvertisementsForUser']];
            $model->password = Yii::$app->getSecurity()->generatePasswordHash($model->password);
            $model->generateAuthKey();
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $model->loadAvatarFile();
            
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
            }
            
            if(!$model->save(false)) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
                return $this->render('create', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
            }
            
            $flag = true;
            $existsEmails = false;
            if(!empty($modelsContactData)) {
                $postData = Yii::$app->request->post('UsersContactData');
                foreach($modelsContactData as $key => $modelContactData) {
                    if($modelContactData->data_type === ContactDataType::EMAIL) {
                        $existsEmails = true;
                    }
                    $modelContactData->data_order = intval($modelContactData->data_order);
                    $modelContactData->id_user = $model->id_user;
//                    $settings = json_decode($modelContactData->settings, true);
                    $settings = $modelContactData->settings; //#JSON-hack#
                    if($modelContactData->data_type === ContactDataType::EMAIL && isset($postData[$key]['purposes'])) { 
                        foreach($postData[$key]['purposes'] as $purposeField => $purposeValue) {
                            $settings['purposes'][$purposeField] = intval($purposeValue);
                        }
//                        $modelContactData->settings = json_encode($settings);
                        $modelContactData->settings = $settings; //#JSON-hack#
                    } elseif(isset($settings['purposes'])) {
                        unset($settings['purposes']);
//                        $modelContactData->settings = !empty($settings) ? json_encode($settings) : '{}'; 
                        $modelContactData->settings = !empty($settings) ? $settings : []; //#JSON-hack#
                    }
                }
                
                if(!\yii\base\Model::validateMultiple($modelsContactData)) {                    
                    $errorsFromModelsContactData = [];
                    foreach($modelsContactData as $modelContactData) {
                        if($modelContactData->hasErrors()) {
                            foreach($modelContactData->getErrors() as $error) {
                                $errorsFromModelsContactData[] = $error;
                            }
                        }
                    }
                    
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', $errorsFromModelsContactData);
                    return $this->render('create', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
                }

                array_walk($modelsContactData, function($value, $key) use (&$flag) {
                    if(!$flag || !$value->save(false)) {
                        $flag = false;
                    }
                });
            }
                        
            if($flag) {            
                $newImagePath = $model->saveAvatarFile();
                if($newImagePath === false) {
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->render('create', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
                } 
                if($existsEmails) {
                    Emails::refreshForUser($model);
                }                
                Yii::$app->authManager->assign(Yii::$app->authManager->getRole($model->profile), $model->id_user);
                
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view', 'id' => $model->id_user]);
                }
                else {
                    $model = new Users(['scenario' => 'create']);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create', [
            'model' => $model,
            'modelsContactData' => $modelsContactData,
            'baseModelContactData' => $baseModelContactData
        ]);
    }
    
    /**
     * Creates a new Users model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreateRegularUser()
    {
        $model = new Users(['scenario' => 'createBasic']);
        $model->status = \common\models\types\Status::ACTIVE;
        $model->profile = \common\models\types\UserProfile::USER;
        
        $baseModelContactData = new UsersContactData(['scenario' => 'create']);
        
        $labelsForContactDataTypes = ContactDataType::getValuesWithLabels();
        
        $modelsContactData[] = new UsersContactData(['scenario' => 'create', 'data_order' => 1, 'required' => 1, 'data_type' => ContactDataType::EMAIL, 'data_label' => ucfirst($labelsForContactDataTypes[ContactDataType::EMAIL])]);
        $modelsContactData[] = new UsersContactData(['scenario' => 'create', 'data_order' => 2, 'required' => 1, 'data_type' => ContactDataType::MOBILE_PHONE, 'data_label' => ucfirst($labelsForContactDataTypes[ContactDataType::MOBILE_PHONE])]);
        
        if(Yii::$app->request->getIsPost()) {
            $postUsersData = Yii::$app->request->post('UsersContactData', []);            
            if(!empty($postUsersData)) {
                foreach($postUsersData as $key => $value) {
                    if(!isset($modelsContactData[$key])) {
                        $modelsContactData[$key] = new UsersContactData(['scenario' => 'create']);
                    }
                }
            }
        }
        
        $modelAddress = new UsersAddresses(['scenario' => 'create']);
        $modelAddress->id_country = 'PL';
        $modelAddress->or_main = 1;
        $modelAddress->label = 'Główny';
        
        $outputParams = [
            'model' => $model, 
            'modelAddress' => $modelAddress,
            'modelsContactData' => $modelsContactData, 
            'baseModelContactData' => $baseModelContactData
        ];
        
        Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        
        if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post()) && $modelAddress->load(Yii::$app->request->post()) && (empty($modelsContactData) || \yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;            
            $orAddressFilled = !empty($modelAddress->street) || !empty($modelAddress->building_number) || !empty($modelAddress->apartment_number) || !empty($modelAddress->postcode) || !empty($modelAddress->locality) || !empty($modelAddress->region) || !empty($modelAddress->lat) || !empty($modelAddress->lng);
            $output = array_merge(\yii\bootstrap\ActiveForm::validate($model), !empty($modelsContactData) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsContactData, ['data_type', 'data_value', 'data_label', 'data_order']) : []);
            if($orAddressFilled) {
                $output = array_merge(\yii\bootstrap\ActiveForm::validate($modelAddress), $output);
            }            
            return $output;
        }
        
        if(Yii::$app->request->getIsPost()) {  
//            var_dump($_POST); exit;
            if(!$model->load(Yii::$app->request->post()) || !$modelAddress->load(Yii::$app->request->post()) || (!empty($modelsContactData) && !\yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('create_regular_user', $outputParams);
            }

            $model->settings = ['advertisements_limit' => Yii::$app->params['limitOfFreeAdvertisementsForUser']];
            $model->password = Yii::$app->getSecurity()->generatePasswordHash($model->password);
            $model->generateAuthKey();

            $modelAddress->or_main = 1;
            $modelAddress->label = 'Główny';
            
            $transaction = Yii::$app->db->beginTransaction();
            
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create_regular_user', $outputParams);
            }
            
            if(!$model->save(false)) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
                return $this->render('create_regular_user', $outputParams);
            }
            
            $orAddressFilled = !empty($modelAddress->street) || !empty($modelAddress->building_number) || !empty($modelAddress->apartment_number) || !empty($modelAddress->postcode) || !empty($modelAddress->locality) || !empty($modelAddress->region) || !empty($modelAddress->lat) || !empty($modelAddress->lng);            
            if($orAddressFilled) {
                $modelAddress->id_user = $model->id_user;
                if(!$modelAddress->validate()) {
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', $modelAddress->getErrors());
                    return $this->conditionalRender('create_regular_user', $outputParams);
                }

                if(!$modelAddress->save(false)) {
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
                    return $this->render('create_regular_user', $outputParams);
                }
            }            
            
            $flag = true;
            $existsEmails = false;
            if(!empty($modelsContactData)) {
                $postData = Yii::$app->request->post('UsersContactData');
                foreach($modelsContactData as $key => $modelContactData) {
                    if($modelContactData->data_type === ContactDataType::EMAIL) {
                        $existsEmails = true;
                    }
                    $modelContactData->data_order = intval($modelContactData->data_order);
                    $modelContactData->id_user = $model->id_user;
//                    $settings = json_decode($modelContactData->settings, true);
                    $settings = $modelContactData->settings; //#JSON-hack#
                    if($modelContactData->data_type === ContactDataType::EMAIL && isset($postData[$key]['purposes'])) { 
                        foreach($postData[$key]['purposes'] as $purposeField => $purposeValue) {
                            $settings['purposes'][$purposeField] = intval($purposeValue);
                        }
//                        $modelContactData->settings = json_encode($settings);
                        $modelContactData->settings = $settings; //#JSON-hack#
                    } elseif(isset($settings['purposes'])) {
                        unset($settings['purposes']);
//                        $modelContactData->settings = !empty($settings) ? json_encode($settings) : '{}'; 
                        $modelContactData->settings = !empty($settings) ? $settings : []; //#JSON-hack#
                    }
                }
                
                if(!\yii\base\Model::validateMultiple($modelsContactData)) {                    
                    $errorsFromModelsContactData = [];
                    foreach($modelsContactData as $modelContactData) {
                        if($modelContactData->hasErrors()) {
                            foreach($modelContactData->getErrors() as $error) {
                                $errorsFromModelsContactData[] = $error;
                            }
                        }
                    }
                    
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', $errorsFromModelsContactData);
                    return $this->render('create_regular_user', $outputParams);
                }

                array_walk($modelsContactData, function($value, $key) use (&$flag) {
                    if(!$flag || !$value->save(false)) {
                        $flag = false;
                    }
                });
            }
                        
            if($flag) {
                $transaction->commit();
                Emails::refreshForUser($model);               
                Yii::$app->authManager->assign(Yii::$app->authManager->getRole($model->profile), $model->id_user); 
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view', 'id' => $model->id_user]);
                }
                else {
                    $outputParams['model'] = new Users(['scenario' => 'createBasic']);
                    $outputParams['modelAddress'] = new UsersAddresses(['scenario' => 'create']);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_regular_user', $outputParams);
    }
    
    /**
     * Updates an existing Users model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdate($id)
    {
        if (($model = \backend\models\Users::findOne($id)) === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        } 
        
        if(\Yii::$app->user->can('updateUsers')) {
            $model->setScenario('update');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateBasicUsers')) {
            $model->setScenario('updateBasic');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateAssignedUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateOwnUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'user-own-basic-data';
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model->password = null;
        $baseModelContactData = new UsersContactData(['scenario' => 'update']);
        $existsEmails = false;
        $modelsContactData = $model->getContactData()->orderBy('data_order')->indexBy('id_contact_data')->all();
        if(!empty($modelsContactData)) {
            foreach($modelsContactData as $modelContactData) {
                $modelContactData->setScenario('update');
                if($modelContactData->data_type === ContactDataType::EMAIL) {
                    $existsEmails = true;
                }
            }  
        }

        if(Yii::$app->request->getIsPost()) {
            $postUsersContactData = Yii::$app->request->post('UsersContactData', []);
            $idsUsersContactData = array_map('intval', array_keys($postUsersContactData));
            if(!empty($postUsersContactData)) {
                foreach($postUsersContactData as $key => $value) {
                    if(!isset($modelsContactData[$key])) {
                        $modelsContactData[$key] = new UsersContactData(['scenario' => 'create', 'id_user' => $model->id_user]);
                    }
                }
            }
        }
        
        if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post()) && (empty($idsUsersContactData) || \yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return array_merge(\yii\bootstrap\ActiveForm::validate($model), !empty($idsUsersContactData) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsContactData, ['data_type', 'data_value', 'data_label', 'data_order']) : []);
        }
        
        if(Yii::$app->request->getIsPost()) {     
            $oldProfile = $model->profile;   
            $oldStatus = $model->status;
            if(!$model->load(Yii::$app->request->post()) || (!empty($idsUsersContactData) && !\yii\base\Model::loadMultiple($modelsContactData, Yii::$app->request->post()))) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('update', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
            }
            
            if(!empty($model->password)) {
                $model->password = Yii::$app->getSecurity()->generatePasswordHash($model->password);
            }
            else {
                $model->password = $model->getOldAttribute('password');
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $oldImagePath = $model->loadAvatarFile();
            
            $flag = true;
            
            if(!empty($modelsContactData)) {                
                foreach($modelsContactData as $key => $modelContactData) {
                    if($modelContactData->data_type === ContactDataType::EMAIL) {
                        $existsEmails = true;
                    }
                    
                    if(!$modelContactData->isNewRecord && !in_array($modelContactData->id_contact_data, $idsUsersContactData)) {
                        $flag = $modelContactData->delete();
                        if($flag === false) {
                            break;
                        }
                        unset($modelsContactData[$key]);
                    } else {
                        $modelContactData->data_order = intval($modelContactData->data_order);
                        $modelContactData->id_user = $model->id_user;
//                        $settings = json_decode($modelContactData->settings, true);
                        $settings = $modelContactData->settings; //#JSON-hack#
                        if($modelContactData->data_type === ContactDataType::EMAIL && isset($postUsersContactData[$key]['purposes'])) { 
                            foreach($postUsersContactData[$key]['purposes'] as $purposeField => $purposeValue) {
                                $settings['purposes'][$purposeField] = intval($purposeValue);
                            }
//                            $modelContactData->settings = json_encode($settings);
                            $modelContactData->settings = $settings; //#JSON-hack#
                        } elseif(isset($settings['purposes'])) {
                            unset($settings['purposes']);
//                            $modelContactData->settings = !empty($settings) ? json_encode($settings) : '{}'; 
                            $modelContactData->settings = !empty($settings) ? $settings : [];  //#JSON-hack#
                        }                     
                    }
                }
            }
            
            if($flag && (!$model->validate() || (!empty($modelsContactData) && !\yii\base\Model::validateMultiple($modelsContactData)))) {
                $errorsFromModelsContactData = [];
                if(!empty($modelsContactData)) {
                    foreach($modelsContactData as $modelContactData) {
                        if($modelContactData->hasErrors()) {
                            foreach($modelContactData->getErrors() as $error) {
                                $errorsFromModelsContactData[] = $error;
                            }
                        }
                    }
                }
                Yii::$app->session->addFlash('error', ArrayHelper::merge($model->getErrors(), $errorsFromModelsContactData));
                return $this->render('update', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
            }
            
//            if(!empty($modelsContactData)) {                
//                foreach($modelsContactData as $key => $modelContactData) {
//                    if($modelContactData->data_type === ContactDataType::EMAIL) {
//                        $existsEmails = true;
//                    }
//                    if(empty($modelContactData->data_value)) {
//                        $flag = $modelContactData->delete();
//                        if($flag === false) {
//                            $transaction->rollBack();
//                            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
//                            return $this->redirect(['update', 'id' => $model->id_user]);
//                        }
//                        unset($modelsContactData[$key]);
//                    }
//                }
//            }
            
//            $flag = true;
            
            if($flag && !empty($modelsContactData)) {                
                ArrayHelper::multisort($modelsContactData, ['data_order'], [SORT_ASC]);
                $i = 1;                
                foreach($modelsContactData as $modelContactData) {
                    $modelContactData->data_order = $i;
                    $i++;
                    if(!$modelContactData->save(false)) {
                        $flag = false;
                        break;
                    }
                }
            }
            
//            if($flag && !empty($modelsContactData)) {
//                $postData = Yii::$app->request->post('UsersContactData');
//                foreach($modelsContactData as $key => $modelContactData) {
//                    $modelContactData->data_order = intval($modelContactData->data_order);
//                    $modelContactData->id_user = $model->id_user;
////                    $settings = json_decode($modelContactData->settings, true);
//                    $settings = $modelContactData->settings; //#JSON-hack#
//                    if($modelContactData->data_type === ContactDataType::EMAIL && isset($postData[$key]['purposes'])) {                          
//                        foreach($postData[$key]['purposes'] as $purposeField => $purposeValue) {
//                            $settings['purposes'][$purposeField] = intval($purposeValue);
//                        }
////                        $modelContactData->settings = json_encode($settings);
//                        $modelContactData->settings = $settings; //#JSON-hack#
//                    } elseif(isset($settings['purposes'])) {
//                        unset($settings['purposes']);
////                        $modelContactData->settings = !empty($settings) ? json_encode($settings) : '{}';
//                        $modelContactData->settings = !empty($settings) ? $settings : []; //#JSON-hack#
//                    }
//                }
//                
//                ArrayHelper::multisort($modelsContactData, ['data_order'], [SORT_ASC]);
//                $i = 1;
//                foreach($modelsContactData as $modelContactData) {
//                    $modelContactData->data_order = $i;
//                    $i++;
//                }
//                
//                array_walk($modelsContactData, function($value, $key) use (&$flag) {
//                    if(!$flag || !$value->save(false)) {
//                        $flag = false;
//                    }
//                });
//            }
            
            if($flag && $model->save(false)) {
                $newImagePath = $model->saveAvatarFile();
                if($newImagePath === false) {
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->render('update', ['model' => $model, 'modelsContactData' => $modelsContactData, 'baseModelContactData' => $baseModelContactData]);
                }  
                if(!empty($oldImagePath)) {
                    Users::deleteImage($oldImagePath);
                }
                
                if($model->status !== $oldStatus) {
                    Emails::refreshForUser($model);
                    if(!empty($model->companies)) {
                        foreach($model->companies as $modelCompany) {
                            Emails::refreshForCompany($modelCompany);
                        }
                    }                    
                } elseif($existsEmails) {
                    Emails::refreshForUser($model);
                }
                
                if($oldProfile !== $model->profile) {        
                    Yii::$app->authManager->revoke(Yii::$app->authManager->getRole($oldProfile), $model->id_user);
                    Yii::$app->authManager->assign(Yii::$app->authManager->getRole($model->profile), $model->id_user); 
                }
                $transaction->commit();
                $this->deleteImportErrorEntryIfExists();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                
                return $this->redirect(Yii::$app->request->get('return_url') ? Yii::$app->request->get('return_url') : ['view', 'id' => $model->id_user]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
            }
        }
        
        return $this->render('update', [
            'model' => $model, 
            'modelsContactData' => $modelsContactData, 
            'baseModelContactData' => $baseModelContactData
        ]);
    }

    /**
     * Deletes an existing Users model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDelete($id)
    {
        $model = $this->findModel($id);
        
        $orForce = intval(Yii::$app->request->get('force', 0));
        
        if(!$orForce) {
            $modelsPresentations = \common\models\CompaniesPresentations::find()
                    ->join('INNER JOIN', 'companies', 'companies.id_company = companies_presentations.id_company')
                    ->with(['portal', 'company'])
                    ->where(['companies.id_user' => $model->id_user])
                    ->all();
            if(!empty($modelsPresentations)) {
                Yii::$app->params['activeMenuItem'] = 'users-basic-data';
                return $this->render('delete', [
                    'model' => $model, 
                    'modelsPresentations' => $modelsPresentations
                ]);
            }
        }
        
        $cacheTags = ['user_'.$model->id_user.'_advertisements'];
        
        $idsPortals = $model->getAdvertisements()->select(['id_portal'])->distinct()->column();        
        if(!empty($idsPortals)) {
            foreach($idsPortals as $idPortal) {
                $cacheTags[] = 'mainpage_box_advertisements_portal_'.$idPortal;
            }
        }
        
        if(!empty($model->companies)) {
            foreach($model->companies as $modelCompany) {
                $cacheTagsFromCompany = $this->getCacheTagsForCompany($modelCompany);
                $cacheTags = array_unique(array_merge($cacheTags, $cacheTagsFromCompany));
            }
        }
        
        $transaction = Yii::$app->db->beginTransaction();

        try {
            $model->delete();
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.'));             
            TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);        
            $this->createEntryForUserChange(UserChangeType::USER_DELETED, $model->id_user);
        } catch (\Exception $ex) {
            $transaction->rollBack();
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));  
            return $this->redirect(['index']);
        }
        
        $transaction->commit();

        return $this->redirect(['index']);
    }
    
    /**
     * Creates a new UsersAddresses model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreateAddress()
    {
        $modelUser = $this->findModel(Yii::$app->request->get('id_user'));
        
        if (!\Yii::$app->user->can('updateUsers', ['model' => $modelUser]) && !\Yii::$app->user->can('updateBasicUsers') && !\Yii::$app->user->can('updateOwnUsers', ['model' => $modelUser])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = new UsersAddresses(['scenario' => 'create']);
        $model->id_user = $modelUser->id_user; 
        
        if(Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['id_user', 'id_country']);
        }
        
        if(Yii::$app->request->getIsPost()) {  
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('create_address', ['model' => $model]);
            }
                        
            $model->id_user = $modelUser->id_user; 
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create_address', ['model' => $model]);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);
            if($flag && $model->or_main) {
                $modelsUserOtherAddresses = UsersAddresses::find()->where(['or_main' => 1, 'id_user' => $modelUser->id_user])->andWhere(['not', ['id_address' => $model->id_address]])->all();
                if(!empty($modelsUserOtherAddresses)) {
                    foreach($modelsUserOtherAddresses as $modelUserOtherAddress) {
                        $modelUserOtherAddress->or_main = 0;
                        if(!$modelUserOtherAddress->save(false)) {
                            $flag = false;
                            break;
                        }
                    }
                }
            }
            
            if($flag) {                
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view', 'id' => $model->id_user]);
                }  
                else {
                    $model = new UsersAddresses(['scenario' => 'create']);
                    $model->id_user = intval(Yii::$app->request->get('id_user', null));
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_address', [
            'model' => $model,
        ]);
    }
    
    /**
     * Updates an existing UsersAddresses model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdateAddress($id)
    {
        $model = $this->findModelAddress($id);
        $model->setScenario('update');
        
        if(\Yii::$app->user->can('updateUsers')) {
            $model->setScenario('update');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateBasicUsers')) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateAssignedUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateOwnUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'user-own-basic-data';
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['id_company', 'id_country']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('update_address', ['model' => $model]);
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('update_address', ['model' => $model]);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);
            if($flag && $model->or_main) {
                $modelsUserOtherAddresses = UsersAddresses::find()->where(['or_main' => 1, 'id_user' => $modelUser->id_user])->andWhere(['not', ['id_address' => $model->id_address]])->all();
                if(!empty($modelsUserOtherAddresses)) {
                    foreach($modelsUserOtherAddresses as $modelUserOtherAddress) {
                        $modelUserOtherAddress->or_main = 0;
                        if(!$modelUserOtherAddress->save(false)) {
                            $flag = false;
                            break;
                        }
                    }
                }
            }
            
            if($flag) {  
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view', 'id' => $model->id_user]);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }

        return $this->conditionalRender('update_address', [
            'model' => $model,
        ]);
    }
    
    /**
     * Deletes an existing UsersAddresses model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeleteAddress($id)
    {
        $model = $this->findModelAddress($id);
        
        if (!\Yii::$app->user->can('updateUsers', ['model' => $model->user]) && !\Yii::$app->user->can('updateBasicUsers') && !\Yii::$app->user->can('updateOwnUsers', ['model' => $model->user])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if ($model->delete() !== false) {
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.')); 
        } else {
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));
        }
        
        return $this->redirect(['view', 'id' => $model->id_user]);
    }
    
    /**
     * Updates an existing UsersHasPortals models.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionActivityOnPortals($id)
    {
        $model = $this->findModel($id);
        
        if(\Yii::$app->user->can('updateUsers')) {
            $model->setScenario('update');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateBasicUsers')) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateAssignedUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
        } elseif(\Yii::$app->user->can('updateOwnUsers', ['model' => $model])) {
            $model->setScenario('updateOwn');
            Yii::$app->params['activeMenuItem'] = 'user-own-basic-data';
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelsUsersHasPortals = $model->getRelationsWithPortals()->indexBy('id_portal')->all();
        if(!empty($modelsUsersHasPortals)) {
            foreach($modelsUsersHasPortals as $key => $modelUserHasPortal) {
                $modelUserHasPortal->setScenario('update');
            }
        }
        
        $idsPortalsFromPresentations = \common\models\CompaniesPresentations::find()
                ->select(['companies_presentations.id_portal'])
                ->join('INNER JOIN', 'companies', 'companies.id_company = companies_presentations.id_company')
                ->where([
                    'companies_presentations.status' => \common\models\types\Status::ACTIVE,
                    'companies.id_user' => $model->id_user
                ])
                ->column();
        $idsPortalsFromPresentations = array_unique($idsPortalsFromPresentations);
        if(!empty($idsPortalsFromPresentations)) {
            foreach($idsPortalsFromPresentations as $idPortalFromPresentation) {
                if(!isset($modelsUsersHasPortals)) {
                    $modelsUsersHasPortals[$idPortalFromPresentation] = new \common\models\UsersHasPortals(['scenario' => 'create']);
                    $modelsUsersHasPortals[$idPortalFromPresentation]->id_user = $model->id_user; 
                    $modelsUsersHasPortals[$idPortalFromPresentation]->id_portal = $idPortalFromPresentation;
                    $modelsUsersHasPortals[$idPortalFromPresentation]->status = \common\models\types\Status::ACTIVE;
                } else {
                    $modelsUsersHasPortals[$idPortalFromPresentation]->setScenario('update');
                }
            }
        }

        $outputParams = [
            'modelUser' => $model,
            'modelsUsersHasPortals' => $modelsUsersHasPortals,
            'idsPortalsFromPresentations' => $idsPortalsFromPresentations
        ];
        
        if(Yii::$app->request->getIsPost()) {   
//            var_dump($_POST); exit;
            $oldStatusesOnPortals = [];
            foreach($modelsUsersHasPortals as $modelUserHasPortal) {
                $oldStatusesOnPortals[$modelUserHasPortal->id_portal] = $modelUserHasPortal->status;
            }
            
            if(!\yii\base\Model::loadMultiple($modelsUsersHasPortals, Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('activity_on_portals', $outputParams);
            }
            
            if(!\yii\base\Model::validateMultiple($modelsUsersHasPortals)) {                    
                $errors = [];
                foreach($modelsUsersHasPortals as $key => $modelUserHasPortal) {
                    if($modelUserHasPortal->hasErrors()) {
                        foreach($modelUserHasPortal->getErrors() as $error) {
                            $errors[] = $error;
                        }
                    }
                }
                Yii::$app->session->addFlash('error', $errors);
                return $this->render('activity_on_portals', $outputParams);
            }
            
            $flag = true;            
            $transaction = Yii::$app->db->beginTransaction();
            
            foreach($modelsUsersHasPortals as $key => $modelUserHasPortal) {
                if($oldStatusesOnPortals[$modelUserHasPortal->id_portal] !== \common\models\types\Status::ACTIVE && $modelUserHasPortal->status === \common\models\types\Status::INACTIVE) {
                    $orExistsPresentationOnPortal = \common\models\CompaniesPresentations::find()
                        ->join('INNER JOIN', 'companies', 'companies.id_company = companies_presentations.id_company')
                        ->where([
                            'companies.id_user' => $modelUserHasPortal->id_user,
                            'companies_presentations.status' => \common\models\types\Status::ACTIVE,
                            'companies_presentations.id_portal' => $modelUserHasPortal->id_portal
                        ])
                        ->exists(); 
                    if($orExistsPresentationOnPortal) {
                        //nie można ustawiać dezaktywacji dla portali, które powiązane są prezentacjami należącymi do firm danego usera
                        $modelUserHasPortal = $oldStatusesOnPortals[$modelUserHasPortal->id_portal];
                    }
                }
                
                if(!$modelUserHasPortal->save(false)) {
                    $flag = true;
                    break;
                }
            }
            
            if($flag) {
                $transaction->commit();
                Emails::refreshForUser($model->id_user);
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['view', 'id' => $model->id_user]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
            }
        }
        
        return $this->render('activity_on_portals', $outputParams);
    }
    
    public function actionPortalsPriorities($id)
    {
        $model = $this->findModel($id);
        
        if(Yii::$app->user->can('viewUsers')) {
            Yii::$app->params['activeMenuItem'] = 'users-basic-data';
            $model->setScenario('update');
        } elseif(Yii::$app->user->can('viewOwnUsers', ['model' => $model])) {
            Yii::$app->params['activeMenuItem'] = 'user-own-basic-data';
            $model->setScenario('updateOwn');
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new \backend\models\PortalsPrioritiesForm();
        $modelForm->loadData($model);
        
        $outputParams = [
            'modelUser' => $model,
            'modelForm' => $modelForm
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['portals']);
        }
        
        if(Yii::$app->request->getIsPost()) {
            if(!\Yii::$app->user->can('updateUsers', ['model' => $model]) && !\Yii::$app->user->can('updateBasicUsers') && !\Yii::$app->user->can('updateOwnUsers', ['model' => $model])) {
                throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
            }
            
            if(!$modelForm->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('portals_priorities', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->render('portals_priorities', $outputParams);
            }
            
            if ($modelForm->save()) {
                Emails::refreshForUser($model);
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));
                return $this->redirect(['view', 'id' => $model->id_user]);
            } else {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('portals_priorities', $outputParams);
    }
    
    public function actionAssignNewCompanies($id)
    {
        $modelUser = $this->findModel($id);
        
        //@todo sprawdzić, czy wybrany użytkownik ma wyższy profil niż firma
        
        Yii::$app->params['activeMenuItem'] = 'users-basic-data';        
        
        $modelForm = new \backend\models\AssignNewCompaniesToOperatorForm();
        $modelForm->setOperator($modelUser);
        
        $queryParams = Yii::$app->request->queryParams;        
        $modelSearch = new \backend\models\CompaniesSimilarSearch(); 
        
        $dataProvider = $modelSearch->search($queryParams);        
        
        if($dataProvider === false) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Wynik wyszukiwania zawiera ponad 65 tysięcy wyników - musisz zawęzić kryteria.'));
            return $this->redirect(['similar']);
        }      
        
        $dataProvider->pagination = false;
        $dataProvider->query->andWhere(['not in', 'id_company', $modelUser->getRelationsWithManagedCompanies()->select(['id_company'])]);
        
        $outputParams = [
            'modelUser' => $modelUser,
            'modelForm' => $modelForm,
            'modelSearch' => $modelSearch,
            'dataProvider' => $dataProvider,
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['listPortals']);
        }
        
        if(Yii::$app->request->getIsPost()) {             
            if(!$modelForm->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('assign_new_companies', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->render('assign_new_companies', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
                        
            if($modelForm->save()) {
                $transaction->commit();                
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['assign-new-companies', 'id' => $modelUser->id_user]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
            }
        }
        
        return $this->render('assign_new_companies', $outputParams);
        
    }

    /**
     * Finds the Users model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return Users the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = Users::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the UsersAddresses model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return UsersAddresses the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelAddress($id)
    {
        if (($model = UsersAddresses::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com