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/WebsitesController.php
<?php

namespace backend\controllers;

use Yii;
use common\models\Websites;
use common\models\WebsitesTranslations;
use backend\models\WebsitesSearch;
use backend\models\CompaniesSearch;
use common\models\types\UserChangeType;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;
use yii\filters\VerbFilter;

/**
 * WebsitesController implements the CRUD actions for Websites model.
 */
class WebsitesController extends Controller
{
    use \backend\components\traits\ControllerFunctions;  
    use \backend\components\traits\WebsitesHelpersFunctions; 

    /**
     * Lists all Websites models.
     * @return mixed
     */
    public function actionIndex()
    {
        $queryParams = Yii::$app->request->queryParams;
        
        $modelCompany = !empty($queryParams['WebsitesSearch']['id_company']) ? \common\models\Companies::findOne((int)$queryParams['WebsitesSearch']['id_company']) : null;
        
        $searchModel = new WebsitesSearch();
        if(Yii::$app->user->can('indexWebsites')) { 
            $dataProvider = $searchModel->search($queryParams);            
        } elseif(Yii::$app->user->can('indexOwnWebsites') && Yii::$app->user->can('viewOwnCompaniesData', ['model' => $modelCompany])) {
            $dataProvider = $searchModel->search($queryParams, true);
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }

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

    /**
     * Displays a single Websites model.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
                
        if(!Yii::$app->user->can('viewWebsites', ['model' => $model])) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));        
        } 
        
        $idMainLanguage = $model->getMainLanguage();
        $websiteLanguages = $model->getSelectedLanguagesList();
        
        $allLanguages = \yii\helpers\ArrayHelper::map(\common\models\Languages::find()->select(['id_language', 'name'])->asArray()->all(), 'id_language', 'name');
        
        $modelsTranslations = $model->getTranslations()->indexBy('id_language')->all();
        
        return $this->render('view', [
            'model' => $model,
            'idMainLanguage' => $idMainLanguage, 
            'websiteLanguages' => $websiteLanguages,
            'allLanguages' => $allLanguages,
            'modelsTranslations' => $modelsTranslations,
        ]);
    }

    /**
     * Creates a new Websites model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreate()
    {
        if(!Yii::$app->user->can('createWebsites')) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }        
        
        $model = new \backend\models\Websites(['scenario' => 'create']);
        $modelManagedCompany = Yii::$app->session->get('managedCompany');
        if(!empty($modelManagedCompany)) {
            $model->id_company = $modelManagedCompany->id_company;
        }
        
        $outputParams = [
            'model' => $model
        ];

        if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['id_company', 'id_template', 'listModules', 'listDomains']);
        }
        
        if(Yii::$app->request->getIsPost()) {  
//            var_dump($_POST); exit;
            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->render('create', $outputParams);
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('create', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);
            $flag = $flag && $model->saveModules();
            $flag = $flag && $model->saveDomains();
            $flag = $flag && $model->saveDefaultLanguages();
            if($flag) {
                $transaction->commit();                
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['view', 'id' => $model->id_website]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('create', $outputParams);
    }

    /**
     * Updates an existing Websites model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionUpdate($id)
    {        
        $model = \backend\models\Websites::findOne($id);
        if($model === null) {
            throw new NotFoundHttpException(Yii::t('backend', 'The requested page does not exist.'));
        }
        
        if(Yii::$app->user->can('updateWebsites')) {
            $model->setScenario('update');
        } elseif(Yii::$app->user->can('updateOwnWebsites', ['model' => $model])) {        
            $model->setScenario('updateBasic');
        } else { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $idMainLanguage = $model->getMainLanguage();
        $websiteLanguages = $model->getSelectedLanguagesList();
        
        $modelsTranslations = $model->getTranslations()->indexBy('id_language')->all();
        foreach($websiteLanguages as $idLanguage => $languageName) {
            if(isset($modelsTranslations[$idLanguage])) {
                $modelsTranslations[$idLanguage]->setScenario($idLanguage === $idMainLanguage ? 'update' : 'updateOptionally');
            } else {
                $modelsTranslations[$idLanguage] = new WebsitesTranslations(['scenario' => $idLanguage === $idMainLanguage ? 'create' : 'createOptionally']);
                $modelsTranslations[$idLanguage]->id_language = $idLanguage;
                $modelsTranslations[$idLanguage]->id_website = $model->id_website;
            }
        } 
        
        $outputParams = [
            'model' => $model,
            'modelsTranslations' => $modelsTranslations, 
            'idMainLanguage' => $idMainLanguage,
            'websiteLanguages' => $websiteLanguages,
        ];
        
        if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post()) && \yii\base\Model::loadMultiple($modelsTranslations, Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return array_merge(\yii\bootstrap\ActiveForm::validate($model, ['id_company', 'id_template', 'listModules', 'listDomains']), \yii\bootstrap\ActiveForm::validateMultiple($modelsTranslations, ['id_website', 'id_photo']));
        }
        
        if(Yii::$app->request->getIsPost()) { 
            $oldLogoFilename = $model->logo_filename;
            $oldLogoSmallFilename = $model->logo_small_filename;
            $oldFaviconFilename = $model->favicon_filename;
            $oldMainImageFilename = $model->main_image_filename;
            
            if(!$model->load(Yii::$app->request->post()) || !\yii\base\Model::loadMultiple($modelsTranslations, Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('update', $outputParams);
            }
            
            $oldLogoPath = $model->loadImageFile(Websites::IMAGE_LOGO);
            $oldLogoSmallPath = $model->loadImageFile(Websites::IMAGE_LOGO_SMALL);
            $oldFaviconPath = $model->loadImageFile(Websites::IMAGE_FAVICON);
            $oldMainImagePath = $model->loadImageFile(Websites::IMAGE_MAIN);
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('update', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);
            
            if($flag && !empty($modelsTranslations)) {
                $flag = $this->validateAndSaveTranslations($modelsTranslations, $model->id_website, 'id_website');
                if(is_array($flag)) {
                    $transaction->rollBack();
                    Yii::$app->session->addFlash('error', $flag);
                    return $this->conditionalRender('update', $outputParams);
                }
            }
            
            $flag = $flag && $model->saveModules();
            $flag = $flag && $model->saveDomains();
            
            $newLogoPath = $model->saveImageFile(Websites::IMAGE_LOGO); 
            $newLogoSmallPath = $model->saveImageFile(Websites::IMAGE_LOGO_SMALL); 
            $newFaviconPath = $model->saveImageFile(Websites::IMAGE_FAVICON);
            $newMainImagePath = $model->saveImageFile(Websites::IMAGE_MAIN);
            if($newLogoPath === false || $newFaviconPath === false || $newMainImagePath === false) {
                $flag = false;
            }
            
            if ($flag) {
                $transaction->commit();                
                $this->createEntryForUserChange(UserChangeType::WEBSITE_BASIC_DATA_MODIFIED, $model->id_website, $model->id_company);
                foreach([$oldLogoPath, $oldLogoSmallPath, $oldFaviconPath, $oldMainImagePath] as $oldFilePath) {
                    if(!empty($oldFilePath)) {
                        Websites::deleteImage($oldFilePath);
                    }
                }                
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['view', 'id' => $model->id_website]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
                $model->logo_filename = $oldLogoFilename;
                $model->logo_small_filename = $oldLogoSmallFilename;
                $model->favicon_filename = $oldFaviconFilename;
                $model->main_image_filename = $oldMainImageFilename;
                foreach([$newLogoPath, $newLogoSmallPath, $newFaviconPath, $newMainImagePath] as $newFilePath) {
                    if(!empty($newFilePath)) {
                        @unlink($newFilePath);
                    }
                }
            }
        }
        
        return $this->render('update', $outputParams);
    }

    /**
     * Deletes an existing Websites model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionDelete($id)
    {
        $model = $this->findModel($id);
        if(Yii::$app->user->can('deleteWebsites')) { 
            $returnAction = ['index'];
            $orCompanyAction = false;
        } elseif(Yii::$app->user->can('deleteOwnWebsites', ['model' => $model])) { 
            $returnAction = ['websites/index', 'WebsitesSearch[id_company]' => $model->id_company];
            $orCompanyAction = true;
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));       
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $idWebsite = $model->id_website;
        $idCompany = $model->id_company;
        $flag = $model->delete();
        
        if($flag !== false) { 
            $transaction->commit();
            if($orCompanyAction) {
                $this->createEntryForUserChange(UserChangeType::WEBSITE_DELETED, $idWebsite, $idCompany);
            }
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.')); 
        } else {
            $transaction->rollBack();
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));   
        }

        return $this->redirect($returnAction);
    }

    public function actionLanguages($id)
    {
        $modelWebsite = $this->findModel($id);
        
        if(Yii::$app->user->can('viewWebsites')) {
            $orCompanyAction = false;
        } elseif(Yii::$app->user->can('viewOwnWebsites', ['model' => $modelWebsite])) { 
            $orCompanyAction = true;
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new \backend\models\WebsiteLanguagesForm();
        $modelForm->setWebsite($modelWebsite);
        $modelForm->populate();
        
        $orCanUpdate = Yii::$app->user->can('updateWebsites', ['model' => $modelWebsite]);
        
        $outputParams = [
            'modelWebsite' => $modelWebsite,
            'modelForm' => $modelForm,
            'orCanUpdate' => $orCanUpdate
        ];

        if(Yii::$app->request->isAjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['languages', 'mainLanguage']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$orCanUpdate) {
                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('languages', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->render('languages', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $modelForm->save(false);
            if ($flag) {
                $transaction->commit();
                if($orCompanyAction) {
                    $this->createEntryForUserChange(UserChangeType::WEBSITE_LANGUAGES_MODIFIED, $modelWebsite->id_website, $modelWebsite->id_company);
                }
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['languages', 'id' => $modelWebsite->id_website]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('languages', $outputParams);
    }
    
    public function actionCompaniesList()
    {
        $searchModel = new CompaniesSearch();
        $queryParams = Yii::$app->request->queryParams;
        if(Yii::$app->user->can('createWebsites') || Yii::$app->user->can('updateWebsites')) { 
            $dataProvider = $searchModel->search($queryParams);            
        } elseif(Yii::$app->user->can('updateOwnWebsites', ['model' => false])) {
            $queryParams['CompaniesSearch']['id_user'] = Yii::$app->user->id;
            $dataProvider = $searchModel->search($queryParams, true);
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }

        return $this->renderAjax('companies_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    /**
     * Finds the Websites model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return Websites the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = Websites::findOne($id)) !== null) {
            return $model;
        }

        throw new NotFoundHttpException(Yii::t('backend', 'The requested page does not exist.'));
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com