frontend/controllers/PerformerController.php

<?php
    namespace frontend\controllers;

    use common\models\Blog;
    use common\models\Fields;
    use common\models\Gallery;
    use common\models\Portfolio;
    use common\models\PortfolioSpecialization;
    use common\models\PortfolioUser;
    use Yii;
    use yii\data\ActiveDataProvider;
    use yii\data\ArrayDataProvider;
    use yii\data\Pagination;
    use yii\data\Sort;
    use yii\db\ActiveQuery;
    use yii\helpers\ArrayHelper;
    use yii\web\BadRequestHttpException;
    use yii\web\Controller;
    use common\models\User;
    use yii\web\NotFoundHttpException;

    /**
     * Site controller
     */
    class PerformerController extends Controller
    {

        public $layout = 'performer';

        public $user;

        public $defaultAction = 'common';

        public function afterAction($action, $result)
        {
            if(!empty( $action->controller->actionParams[ 'performer_id' ] )) {
                $performer_id = $action->controller->actionParams[ 'performer_id' ];
                $user = User::findOne($performer_id);
                if(!empty( $user->userInfo )) {
                    if($user->userInfo->is_freelancer xor $user->userInfo->is_customer) {
                        $type = $action->controller->actionParams['type'];
                        $get = \Yii::$app->request->get();
                        if(!empty($type)) {
                            if($user->userInfo->is_freelancer && $type == 'customer') {
                                $get['type'] = 'implementer';
                                $this->redirect(array_merge([$action->id], $get));
                            } elseif($user->userInfo->is_customer && $type == 'implementer') {
                                $get['type'] = 'customer';
                                $this->redirect(array_merge([$action->id], $get));
                            }
                        }
                    }
                    $user->userInfo->updateCounters([ 'view_count' => 1 ]);
                }
            }
            return parent::afterAction($action, $result);
        }

        /**
         * @inheritdoc
         */
        public function actions()
        {
            return [
                'error'   => [
                    'class' => 'yii\web\ErrorAction',
                ],
                'captcha' => [
                    'class'           => 'yii\captcha\CaptchaAction',
                    'fixedVerifyCode' => YII_ENV_TEST ? 'testme' : NULL,
                ],
            ];
        }

        public function actionCommon($performer_id, $type = 'implementer')
        {
            $user = User::find()
                        ->where([ 'id' => $performer_id ])
                        ->with('jobs')
                        ->with('comments')
                        ->with('comments.rating')
                        ->one();

            if(!$user instanceof User) {
                throw new NotFoundHttpException('Пользователь не найден');
            }

            $educations = Fields::getData($user->id, $user->className(), 'education');
            $developments = Fields::getData($user->id, $user->className(), 'development');
            $courses = Fields::getData($user->id, $user->className(), 'courses');
            $phones = Fields::getData($user->id, $user->className(), 'phone');
            $sites = Fields::getData($user->id, $user->className(), 'site');
            $soft = implode(', ', ArrayHelper::getColumn(Fields::getData($user->id, $user->className(), 'soft'), 'soft'));
            $geography = $user->getPortfolios()
                              ->select([
                                  'count' => 'COUNT(*)',
                                  'city'  => 'city',
                              ])
                              ->groupBy('city')
                              ->asArray()
                              ->indexBy('city')
                              ->column();
            return $this->render('common', [
                'user'         => $user,
                'educations'   => $educations,
                'developments' => $developments,
                'courses'      => $courses,
                'phones'       => $phones,
                'sites'        => $sites,
                'soft'         => $soft,
                'geography'    => $geography,
            ]);

        }

        public function actionPortfolio($performer_id, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }
            $projects = ArrayHelper::getColumn($user->portfolios, 'portfolio_id');

            $filters = PortfolioSpecialization::find()
                                              ->select([
                                                  "specialization_id",
                                                  "COUNT('specialization_id') AS count",
                                              ])
                                              ->where([ "portfolio_id" => $projects ])
                                              ->groupBy("specialization_id")
                                              ->all();

            $portfolio = new ArrayDataProvider([
                'allModels'  => $user->getPortfolios()
                                     ->orderBy('portfolio_id')
                                     ->all(),
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);

            return $this->render('portfolio', [
                'user'      => $user,
                'filters'   => $filters,
                'portfolio' => $portfolio,
                'count'     => count($user->portfolios),
            ]);

        }

        public function actionPortfolioFilter($performer_id, $filter, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }
            $portfolios = ArrayHelper::getColumn($user->portfolios, 'portfolio_id');

            $filters = PortfolioSpecialization::find()
                                              ->select([
                                                  "specialization_id",
                                                  "COUNT('specialization_id') AS count",
                                              ])
                                              ->where([ "portfolio_id" => $portfolios ])
                                              ->groupBy("specialization_id")
                                              ->all();

            $filter_result = PortfolioSpecialization::find()
                                                    ->where([
                                                        'specialization_id' => $filter,
                                                        'portfolio_id'      => $portfolios,
                                                    ])
                                                    ->all();

            $portfolio = new ArrayDataProvider([
                'allModels'  => Portfolio::find()
                                         ->where([ 'portfolio_id' => ArrayHelper::getColumn($filter_result, 'portfolio_id') ])
                                         ->all(),
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);

            return $this->render('portfolio', [
                'user'      => $user,
                'filters'   => $filters,
                'portfolio' => $portfolio,
                'filter_id' => $filter,
                'count'     => count($user->portfolios),
            ]);
        }

        public function actionPortfolioView($performer_id, $portfolio_id, $portfolio_user = NULL, $type = 'implementer')
        {
            $user = User::findOne($performer_id);
            $portfolio = $user->getPortfolios()
                              ->where([ 'portfolio_id' => $portfolio_id ])
                              ->with([
                                  'portfolioUsers' => function($query) {
                                      /**
                                       * @var ActiveQuery $query
                                       */
                                      $query->andWhere([ 'status' => 1 ]);
                                  },
                              ])
                              ->with('portfolioUsers.gallery')
                              ->one();
            if(empty($portfolio)) {
                throw new NotFoundHttpException('Портфолио не найдено');
            }
            if(!empty( $portfolio_user )) {
                $portfolio_user = PortfolioUser::find()
                                               ->where([
                                                   'portfolio_user_id' => $portfolio_user,
                                                   'status'            => 1,
                                               ])
                                               ->with('gallery')
                                               ->with('user')
                                               ->one();
                if(empty( $portfolio_user )) {
                    $this->redirect([
                        'portfolio-view',
                        'performer_id' => $performer_id,
                        'portfolio_id' => $portfolio_id,
                        'type'         => $type,
                    ]);
                }
            } else {
                $portfolio->updateCounters([ 'view_count' => 1 ]);
            }
            return $this->render('portfolio-view', [
                'user'           => $user,
                'portfolio'      => $portfolio,
                'portfolio_user' => $portfolio_user,
            ]);
        }

        public function actionProjects($performer_id, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $dataProvider = new ActiveDataProvider([
                'query'      => $user->getProjects(),
                'pagination' => [
                    'pageSize' => 10,
                ],
            ]);

            return $this->render('project-list', [
                'user'         => $user,
                'dataProvider' => $dataProvider,
            ]);
        }

        public function actionBlogList($performer_id, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $blog = new ActiveDataProvider([
                'query'      => $user->getBlog(),
                'pagination' => new Pagination([
                    'pageSize' => 5,
                ]),
                'sort'       => new Sort([
                    'defaultOrder' => [
                        'date_add' => SORT_DESC,
                        'name'     => SORT_ASC,
                    ],
                ]),
            ]);

            return $this->render('blog-list', [
                'user' => $user,
                'blog' => $blog,
            ]);
        }

        public function actionBlogView($performer_id, $link, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $article = Blog::find()
                           ->where([
                               'link'    => $link,
                               'user_id' => $performer_id,
                           ])
                           ->with('comments')
                           ->one();
            if(empty($article)) {
                throw new NotFoundHttpException('Запись не найдена');
            }
            $article->updateCounters([ 'view_count' => 1 ]);

            return $this->render('blog-view', [
                'user'    => $user,
                'article' => $article,
            ]);
        }

        public function actionReview($performer_id, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            return $this->render('review', [
                'user' => $user,
            ]);
        }

        public function actionWorkplace($performer_id, $type = 'implementer')
        {
            $user = User::find()
                        ->where([ 'id' => $performer_id ])
                        ->with('jobs')
                        ->one();
            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            return $this->render('workplace', [
                'user' => $user,
            ]);
        }

        public function actionGallery($performer_id, $type = 'implementer')
        {
            $user = User::findOne($performer_id);

            if(!$user instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $gallery = new ActiveDataProvider([
                'query'      => $user->getGalleries()->andWhere(['not', ['photo' => '']])->andWhere(['not', ['photo' => NULL]]),
                'pagination' => [
                    'pageSize' => 5,
                ],
            ]);

            $videos = Fields::getData($user->id, Gallery::className(), 'youtube');

            $this->layout = 'gallery';

            return $this->render('gallery', [
                'user'    => $user,
                'gallery' => $gallery,
                'videos'  => $videos,
            ]);
        }

        public function beforeAction($action)
        {
            if(!empty( \Yii::$app->request->get('type') )) {
                $action->controller->view->params[ 'type' ] = \Yii::$app->request->get('type');
            }
            if(!empty( \Yii::$app->request->get('performer_id') )) {
                $user = User::findOne(\Yii::$app->request->get('performer_id'));
                if(!empty( $user ) && $user->type == 2) {
                    $queryParams = \Yii::$app->request->queryParams;
                    unset( $queryParams[ 'performer_id' ] );
                    $queryParams[ 'company_id' ] = $user->id;
                    return $this->redirect(array_merge([ 'company/' . $action->id ], $queryParams));
                }
            }
            return parent::beforeAction($action);
        }
    }