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

namespace backend\controllers;

use Yii;
use common\models\Fairs;
use common\models\FairsSeries;
use common\models\FairsTags;
use common\models\types\Status;
use common\models\types\UserChangeType;
use backend\models\FairsSearch;
use backend\models\ArticlesSearch;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;
use yii\filters\VerbFilter;
use yii\caching\TagDependency;
use frontend\models\IndexFairs;

/**
 * FairsController implements the CRUD actions for Fairs model.
 */
class FairsController extends Controller
{
    use \backend\components\traits\ControllerFunctions;
        
    /**
     * Lists all Fairs models.
     * @param integer $id
     * @return mixed
     */
    public function actionIndex($id)
    {
        $modelFairsSeries = $this->findModelFairsSeries($id);
        
//        if(!Yii::$app->user->can('indexFairs', ['model' => $modelFairsSeries])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        } 
        if(!Yii::$app->user->can('indexFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        } 
        
        $searchModel = new FairsSearch();
        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['FairsSearch']['id_series'] = $modelFairsSeries->id_series;
        
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
            'modelFairsSeries' => $modelFairsSeries
        ]);
    }
    
    public function actionIndexAll()
    {
        if(!Yii::$app->user->can('indexFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        } 
        
        $searchModel = new FairsSearch();
        $searchModel->orWithCompanies = true;
        
        $queryParams = Yii::$app->request->queryParams;
        
        $dataProvider = $searchModel->search($queryParams);

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

    /**
     * Displays a single Fairs model.
     * @param integer $id
     * @return mixed
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
        
//        if(!Yii::$app->user->can('viewFairs', ['model' => $model->series])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        } 
        if(!Yii::$app->user->can('viewFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        } 
        
        return $this->render('view', [
            'model' => $model,
        ]);
    }

    /**
     * Creates a new Fairs model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreate()
    {
        $modelFairsSeries = $this->findModelFairsSeries(intval(Yii::$app->request->get('id_series', null)));
        
        $model = new \backend\models\Fairs(['scenario' => 'create']);
        $model->id_series = $modelFairsSeries->id_series;
        $model->id_country = 'PL';
        
//        if(Yii::$app->user->can('createFairs')) {
//            $model->setScenario('create');
//        } elseif(Yii::$app->user->can('createOwnFairs')) {
//            $model->setScenario('createOwn');
//            $modelManagedCompany = Yii::$app->session->get('managedCompany');
//            if(empty($modelManagedCompany) || $modelFairsSeries->id_company !== $modelManagedCompany->id_company) {
//                throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//            }      
//            $model->status = Status::HIDDEN;
//        } else {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        if(!Yii::$app->user->can('createFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));            
        } 
        
        $outputParams = [
            'model' => $model,
            'modelFairsSeries' => $modelFairsSeries,
        ];
        
        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, ['listArticles', 'id_article', 'id_region', 'id_country', 'date_start', 'date_end']);
        }
        
        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->render('create', $outputParams);
            }
            
            $model->id_series = $modelFairsSeries->id_series;
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $nextId = Yii::$app->db->createCommand("SELECT nextval(pg_get_serial_sequence('fairs','id_fair'))")->queryOne();
            if(!empty($nextId)) {
                $model->id_fair = intval($nextId['nextval']);
            }
            else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd odczytu z bazy.'));
                return $this->render('create', $outputParams);
            }
            
            $model->loadImageFile();
            
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('create', $outputParams);
            }
            
            $newImagePath = $model->saveImageFile();
            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', $outputParams);
            }
                      
            $flag = $model->save(false);
            $flag = $flag && $model->saveTags(); 
            $flag = $flag && $model->saveArticles();
            $flag = $flag && $model->saveGoogleIndexingUrls($modelFairsSeries->portals);
            $flag = $flag && $model->repairWysiwygContents(['content']);
            $flag = $flag && IndexFairs::refreshRecord($model->id_fair);
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                $modifiedPortals = $modelFairsSeries->getRelationsWithPortals()->select(['id_portal'])->column();
                if(!empty($modifiedPortals)) {
                    $cacheTags = [];
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_fairs_portal_'.$idPortal;                    
                        $cacheTags[] = 'extended_menu_fairs_portal_'.$idPortal;
                    }
                    TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
                }
//                if($model->getScenario() === 'createOwn') {
//                    $this->createEntryForUserChange(UserChangeType::FAIR_ADDED, $model->id_fair, $modelManagedCompany->id_company);
//                }
                return $this->redirect(['update', 'id' => $model->id_fair]);
            } else {
                $transaction->rollBack();
                $model->rollBackWysiwygContentsChanges();
                Fairs::deleteImage($newImagePath);
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('create', $outputParams);
    }

    /**
     * Updates an existing Fairs model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdate($id)
    {        
        $model = \backend\models\Fairs::findOne($id);        
        if($model === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }        
        
//        if(Yii::$app->user->can('updateFairs')) {
//            $model->setScenario('update');
//        } elseif(Yii::$app->user->can('updateFairs', ['model' => $model->series])) {
//            $model->setScenario('updateOwn');
//            $modelManagedCompany = Yii::$app->session->get('managedCompany');
//            if(empty($modelManagedCompany) || $model->series->id_company !== $modelManagedCompany->id_company) {
//                throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//            } 
//        } else {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        
        if(!Yii::$app->user->can('updateFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }        
        $model->setScenario('update');
        
        $dataProviderAttachments = new \yii\data\ActiveDataProvider([
            'query' => $model->getAttachments()->orderBy('attachment_order'),
            'pagination' => false,
            'sort' => false
        ]);
        
        $dataProviderPhotogalleries = new \yii\data\ActiveDataProvider([
            'query' => $model->getPhotogalleries()->orderBy('gallery_date DESC'),
            'pagination' => false,
            'sort' => false
        ]);
                
        $outputParams = [
            'model' => $model,
            'dataProviderAttachments' => $dataProviderAttachments,
            'dataProviderPhotogalleries' => $dataProviderPhotogalleries
        ];
        
        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_article', 'id_region', 'id_country', 'date_start', 'date_end']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            $oldStatus = $model->status;
            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('update', $outputParams);
            }
            
            $oldImagePath = $model->loadImageFile();
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('update', $outputParams);
            }
            
            $newImagePath = $model->saveImageFile();
            if($newImagePath === false) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                return $this->render('update', $outputParams);
            }
                      
            $flag = $model->save(false);
            $flag = $flag && $model->saveTags(); 
            $flag = $flag && $model->saveArticles(); 
            if($flag && $oldStatus !== Status::ACTIVE && $model->status === Status::ACTIVE) {
                $flag = $model->saveGoogleIndexingUrls($model->series->portals);
            }
            $flag = $flag && IndexFairs::refreshRecord($model->id_fair);
            if($flag) {
                Fairs::deleteImage($oldImagePath);
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                $modifiedPortals = $model->series->getRelationsWithPortals()->select(['id_portal'])->column();
                if(!empty($modifiedPortals)) {
                    $cacheTags = [];
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_fairs_portal_'.$idPortal;
                        $cacheTags[] = 'extended_menu_fairs_portal_'.$idPortal;
                    }
                    TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
                }
//                if($model->getScenario() === 'updateOwn') {
//                    $this->createEntryForUserChange(UserChangeType::FAIR_MODIFIED, $model->id_fair, $modelManagedCompany->id_company);
//                }
                return $this->redirect(['update', 'id' => $model->id_fair]);
            } else {
                Fairs::deleteImage($newImagePath);
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('update', $outputParams);
    }

    /**
     * Deletes an existing Fairs 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);
                   
//        if(!Yii::$app->user->can('deleteFairs', ['model' => $model->series])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        if(!Yii::$app->user->can('deleteFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modifiedPortals = $model->series->getRelationsWithPortals()->select(['id_portal'])->column();
        $idFair = $model->id_fair;
        if($model->delete() !== false) {
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.'));             
            if(!empty($modifiedPortals)) {
                $cacheTags = [];
                foreach($modifiedPortals as $idPortal) {
                    $cacheTags[] = 'mainpage_box_fairs_portal_'.$idPortal;
                    $cacheTags[] = 'extended_menu_fairs_portal_'.$idPortal;
                }
//                $modelManagedCompany = Yii::$app->session->get('managedCompany');
//                if(!empty($modelManagedCompany)) {
//                    $this->createEntryForUserChange(UserChangeType::FAIR_DELETED, $idFair, $modelManagedCompany->id_company);
//                }
                TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
            }
        } else {
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));   
        }

        return $this->redirect(['index', 'id' => $model->id_series]);
    }
    
    /**
     * Creates a new FairsAttachments model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreateAttachment()
    {
        $model = new \common\models\FairsAttachments(['scenario' => 'create']);
        $model->id_fair = intval(Yii::$app->request->get('id_fair', null));
        $modelFair = $this->findModel($model->id_fair); 
        
//        if(!Yii::$app->user->can('updateFairs', ['model' => $modelFair->series])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        if(!Yii::$app->user->can('updateFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        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_attachment', ['model' => $model, 'modelFair' => $modelFair]);
            }
                                  
            $model->loadFile();
            
            if(!empty($model->file)) {
                $model->url = null;
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create_attachment', ['model' => $model, 'modelFair' => $modelFair]);
            }

            $newFilePath = (!empty($model->file)) ? $model->saveFile() : null;
            if($newFilePath === false) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                return $this->conditionalRender('create_attachment', ['model' => $model, 'modelFair' => $modelFair]);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $modelsFairsAttachments = \common\models\FairsAttachments::find()->where(['>=', 'attachment_order', $model->attachment_order])->andWhere(['id_fair' => $model->id_fair])->all();
            if(!empty($modelsFairsAttachments)) {                
                array_walk($modelsFairsAttachments, function($modelFairsAttachments, $key) use (&$flag) {
                    $modelFairsAttachments->attachment_order += 1;
                    if(!$flag || !$modelFairsAttachments->save(false)) {
                        $flag = false;
                    }
                });
            }
            
            if ($flag && $model->save(false)) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane załącznika.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_fair]);
                } 
                else {
                    $model = new \common\models\FairsAttachments(['scenario' => 'create']);
                    $model->id_fair = intval(Yii::$app->request->get('id_fair', null));
                }
//                $this->createEntryForUserChange(UserChangeType::FAIR_MODIFIED, $modelFair->id_fair, $modelFair->series->id_company, 'Dodano załącznik.');
            } else {
                $transaction->rollBack();
                @unlink($newFilePath);
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_attachment', [
            'model' => $model,
            'modelFair' => $modelFair
        ]);
    }
    
    /**
     * Updates an existing FairsAttachments model.
     * If update is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdateAttachment($id)
    {
        $model = $this->findModelAttachment($id);
        
//        if(!Yii::$app->user->can('updateFairs', ['model' => $model->fair->series])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        if(!Yii::$app->user->can('updateFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!empty($model->url)) {
            $model->setScenario('update-url-version');
            $isUrlAttachment = true;
        } else {
            $model->setScenario('update-file-version');
            $isUrlAttachment = false;
        }

        $outputParams = [
            'model' => $model,
            'isUrlAttachment' => $isUrlAttachment
        ];
        
        if(Yii::$app->request->getIsPost()) {  
            $oldOrder = intval($model->getOldAttribute('attachment_order'));
            
            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_attachment', $outputParams);
            }
            
            if(!$isUrlAttachment) {
                $oldFilePath = $model->loadFile();
                $model->url = null;
            } else {
                $oldFilePath = null;
                $model->filename = null;
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('update_attachment', $outputParams);
            }
            
            if(!$isUrlAttachment) {
                $newFilePath = $model->saveFile();
                if($newFilePath === false) {
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->conditionalRender('update_attachment', $outputParams);
                }
            } else {
                $newFilePath = null;
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $newOrder = intval($model->attachment_order);
            
            if($newOrder !== $oldOrder) {
                if($newOrder > $oldOrder) {
                    $modelsFairsAttachments = \common\models\FairsAttachments::find()
                        ->where(['<=', 'attachment_order', $newOrder])
                        ->andWhere(['>', 'attachment_order', $oldOrder])
                        ->andWhere(['id_fair' => $model->id_fair])
                        ->andWhere(['!=', 'id_attachment', $model->id_attachment])
                        ->all();
                    if(!empty($modelsFairsAttachments)) {                
                        array_walk($modelsFairsAttachments, function($modelFairsAttachments, $key) use (&$flag) {
                            $modelFairsAttachments->attachment_order -= 1;
                            if(!$flag || !$modelFairsAttachments->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                } else {
                    $modelsFairsAttachments = \common\models\FairsAttachments::find()
                        ->where(['<', 'attachment_order', $oldOrder])
                        ->andWhere(['>=', 'attachment_order', $newOrder])
                        ->andWhere(['id_fair' => $model->id_fair])
                        ->andWhere(['!=', 'id_attachment', $model->id_attachment])
                        ->all();
                    if(!empty($modelsFairsAttachments)) {                
                        array_walk($modelsFairsAttachments, function($modelFairsAttachments, $key) use (&$flag) {
                            $modelFairsAttachments->attachment_order += 1;
                            if(!$flag || !$modelFairsAttachments->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                }
            }
            
            if ($flag && $model->save(false)) {
                @unlink($oldFilePath);
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane załącznika.')); 
//                $this->createEntryForUserChange(UserChangeType::FAIR_MODIFIED, $model->id_fair, $model->fair->series->id_company, 'Zmodifykowano załącznik.');
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_fair]);
                }
            } else {
                @unlink($newFilePath);
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('update_attachment', $outputParams);
    }
    
    /**
     * Deletes an existing FairsAttachments model.
     * If deletion is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeleteAttachment($id)
    {
        $model = $this->findModelAttachment($id);
        
//        if(!Yii::$app->user->can('updateFairs', ['model' => $model->fair->series])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
        if(!Yii::$app->user->can('updateFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $flag = true;
        $modelsFairsAttachments = \common\models\FairsAttachments::find()
            ->andWhere(['>', 'attachment_order', $model->attachment_order])
            ->andWhere(['id_fair' => $model->id_fair])
            ->andWhere(['!=', 'id_attachment', $model->id_attachment])
            ->all();
        if(!empty($modelsFairsAttachments)) {                
            array_walk($modelsFairsAttachments, function($modelFairsAttachments, $key) use (&$flag) {
                $modelFairsAttachments->attachment_order -= 1;
                if(!$flag || !$modelFairsAttachments->save(false)) {
                    $flag = false;
                }
            });
        }
                
        $idFair = $model->id_fair;
        $idCompany = $model->fair->series->id_company;
        if($flag && $model->delete() !== false) {
            $transaction->commit();
//            $this->createEntryForUserChange(UserChangeType::FAIR_MODIFIED, $idFair, $idCompany, 'Usunięto załącznik.');
        } else {
            $transaction->rollBack();
        }
        
        
        return Yii::$app->getResponse()->redirect(['fairs/update', 'id' => $model->id_fair], 302, false);
    }

    public function actionArticlesList()
    {
        $idCompany = Yii::$app->request->get('id_company');
        $idsExcludedArticles = Yii::$app->request->get('ids_excluded');
        $queryParams = Yii::$app->request->queryParams;

        if(!empty($idCompany)) {
            $idCompany = intval($idCompany);
            $queryParams['ArticlesSearch']['id_company'] = $idCompany;
        }
        
        if(!empty($idsExcludedArticles)) {
            $queryParams['ArticlesSearch']['idsExcluded'] = array_map('intval', array_map('trim', explode(',', $idsExcludedArticles)));
        }
        
//        if(Yii::$app->user->can('updateFairs') || Yii::$app->user->can('createFairs')) {
//            
//        } else {
//            $modelManagedCompany = Yii::$app->session->get('managedCompany');
//            if(empty($idCompany) || empty($modelManagedCompany) || $idCompany !== $modelManagedCompany->id_company || !Yii::$app->user->can('viewOwnCompaniesData', ['model' => $modelManagedCompany])) {
//                throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//            }
//        }
        if(!Yii::$app->user->can('updateFairs') && !Yii::$app->user->can('createFairs')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        } 

        $searchModel = new ArticlesSearch();
        $dataProvider = $searchModel->search($queryParams);

        return $this->renderAjax('articles_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionAutocompleteTags()
    {
        $phrase = Yii::$app->request->get('phrase');
        $tags = [];
        if(!empty($phrase['term'])) {
            $tags = FairsTags::find()->select(['name'])->where(['ilike', 'name', $phrase['term']])->orderBy('quantity')->asArray()->column();
        }
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        
        return $tags;
    }
    
    /**
     * Finds the Fairs model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return Fairs the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = Fairs::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the FairsSeries model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return FairsSeries the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelFairsSeries($id)
    {
        if (($model = FairsSeries::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the FairsAttachments model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return FairsAttachments the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelAttachment($id)
    {
        if (($model = \common\models\FairsAttachments::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com