Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/frontend/controllers/
Linux eb5096292c53 5.15.0-102-generic #112-Ubuntu SMP Tue Mar 5 16:50:32 UTC 2024 x86_64
Current File : //home/vmanager/www/frontend/controllers/OgloszeniaController.php
<?php
namespace frontend\controllers;

use Yii;
use yii\web\Controller;
use yii\helpers\ArrayHelper;
use yii\data\ActiveDataProvider;
use common\models\Advertisements;
use common\models\AdvertisementsParams;
use common\models\AdvertisementsCategories;
use common\models\AdvertisementsMessages;
use common\models\AdvertisementsHasAdvertisementsParams;
use common\models\Regions;
use common\models\types\Status;
use common\models\types\AdvertisementStatus;
use common\models\types\AdvertisementParamType;
use common\models\types\AdvertisementType;
use common\models\types\ContactDataType;
use common\models\types\UserProfile;
use frontend\models\AdvertisementsSearchForm;
use frontend\models\AdvertisementsParamsSearchForm;
use frontend\models\AdvertisementMessageForm;
use frontend\models\AdvertisementForm;
use yii\web\NotFoundHttpException;

/**
 * Ogloszenia controller
 */
class OgloszeniaController extends Controller
{
    use \frontend\components\traits\SeoFunctions;
 
    //@todo proteza do czasu przeniesienia regionów na powiązane ID
    protected static $regionsMap = [
        'dolnośląskie' => 1,
        'kujawsko-pomorskie' => 2,
        'lubelskie' => 3,
        'lubuskie' => 4,
        'łódzkie' => 5,
        'małopolskie' => 6,
        'mazowieckie' => 7,
        'opolskie' => 8,
        'podkarpackie' => 9,
        'podlaskie' => 10,
        'pomorskie' => 11,
        'śląskie' => 12,
        'świętokrzyskie' => 13,
        'warmińsko-mazurskie' => 14,
        'wielkopolskie' => 15,
        'zachodniopomorskie' => 16
    ];
    
    /**
     * @inheritdoc
     */
    public function actions()
    {
        return [
            'error' => [
                'class' => 'yii\web\ErrorAction',
            ],
            'captcha' => [
                'class' => 'yii\captcha\CaptchaAction',
//                'fixedVerifyCode' => 'dupa123'
            ],
        ];
    }
    
    public function behaviors()
    {
        $behaviors = parent::behaviors();
        $behaviors['portalDataSets'] = [
            'class' => \frontend\components\filters\PortalDataSetsFilter::class,
            'dataSetsKey' => 'advertisements'
        ];
        return $behaviors;
    }
    
    protected function applyFilters($modelForm, $modelsParamsSearchForms, $query)
    {
        $modelForm->load(Yii::$app->request->queryParams);
        
        if(!$modelForm->validate()) {
            return false;
        }
        
        if(!empty($modelsParamsSearchForms) && \yii\base\Model::loadMultiple($modelsParamsSearchForms, Yii::$app->request->queryParams)) {
            if(!\yii\base\Model::validateMultiple($modelsParamsSearchForms)) {
                return false;
            }          
        }
        if(!empty($modelForm->type[0]) && !$this->checkIfDataSetsIsAvailable($modelForm->type[0])) {
            $modelForm->type = null;
        }
        
        $query->andFilterWhere([
            'advertisements.id_region' => $modelForm->id_region,
            'advertisements.advertisement_type' => $modelForm->type
        ]);
        
        $query->andFilterWhere(['ilike', 'advertisements.title', $modelForm->phrase]);
        $query->andFilterWhere(['ilike', 'advertisements.locality', $modelForm->locality]);
        
        if(!empty($modelsParamsSearchForms)) {
            foreach($modelsParamsSearchForms as $modelParamSearchForm) {
                if(empty($modelParamSearchForm->value)) {
                    continue;
                }
                $modelParam = $modelParamSearchForm->getModelParam();
                $i = $modelParam->id_param;
                $query->join('INNER JOIN', 'advertisements_has_advertisements_params ap'.$i, 'ap'.$i.'.id_advertisement = advertisements.id_advertisement AND ap'.$i.'.id_param = '.$modelParam->id_param);                
                switch($modelParam->param_type) {
                    case AdvertisementParamType::SINGLE_VALUE:
                        $query->andWhere(['ap'.$i.'.param_value' => $modelParamSearchForm->value]);
                        break;
                    case AdvertisementParamType::MANY_VALUES:
                        $query->andWhere(['ilike', 'ap'.$i.'.param_value', $modelParamSearchForm->value]);
                        break;                        
                    case AdvertisementParamType::RANGE_FROM_TO:
                        $pgCastType = \common\models\types\AdvertisementParamDataType::getPgCastOperatorForType($modelParam->data_type);
                        if(empty($pgCastType)) {
                            break;
                        }
                        
                        $query->andWhere(['>=', 'CAST(ap'.$i.'.param_value AS '.$pgCastType.')', $modelParamSearchForm->value]);
                        if(!empty($modelParamSearchForm->value2)) {
                            $query->andWhere(['<=', 'CAST(ap'.$i.'.param_value_2 AS '.$pgCastType.')', $modelParamSearchForm->value2]);
                        }
                        break;
                }
            }
        }
        
        return true;        
    }
    
    protected function getBaseQuery($idsCategories = [])
    {        
        $query = Advertisements::find()
                ->select([
                    'advertisements.id_advertisement', 'advertisements.advertisement_type', 'advertisements.title', 'advertisements.image_filename', 
                    'advertisements.publication_datetime', 'advertisements.expiry_date', 
                    'advertisements.locality', 'advertisements.postcode', 'advertisements.street', 'advertisements.building_number', 'advertisements.apartment_number', 
                    'advertisements.locality', 'advertisements.price', 'regions.name AS region_name'
                ])->joinWith('region')
                ->where([
                    'advertisements.id_portal' => Yii::$app->params['modelPortal']->id_portal,
                    'advertisements.status' => AdvertisementStatus::ACTIVE
                ]);
//                ->andWhere(['>=', 'advertisements.expiry_date', date('Y-m-d')]);
        if(!empty($idsCategories)) {
            $query->andWhere(['advertisements.id_category' => $idsCategories]);
        }
        
        return $query;
    }

    public function actionIndex()
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $categoriesTree = AdvertisementsCategories::getCategoryTree($modelPortal->id_portal);
        $categoriesTree = $categoriesTree[0]['children'];
        
        $mainCategories = ArrayHelper::getColumn($categoriesTree, 'text');
        if(count($mainCategories) > 5) {
            $randomKeys = array_rand($mainCategories, 5);
            $mainCategories = [$mainCategories[$randomKeys[0]], $mainCategories[$randomKeys[1]], $mainCategories[$randomKeys[2]], $mainCategories[$randomKeys[3]], $mainCategories[$randomKeys[4]]];
        }
        $mainCategories = implode(", ", $mainCategories);

        $this->setSeoMetadata('notices_all_categories', [
             'title' => [],
             'keywords' => [$mainCategories], //'{kategorie głównego poziomu}'
             'description' => [$mainCategories, $modelPortal->domain] //'{kategorie głównego poziomu}','{domena}'
        ]);         
        
        return $this->render('index', [
            'categoriesTree' => $categoriesTree
        ]);
    }
    
    public function actionLista($id_category = null, $slug = null)
    {
        //@backward_compatibility
        //---------------------------
        $orOldLink = !!Yii::$app->request->get('old');
        if(!empty($id_category) && $orOldLink) {        
            $newId = (int)(new \yii\mongodb\Query())->from('import_advertisements_categories')->select(['target_id'])->where(['source_id' => (string)$id_category, 'status' => 'OK'])->scalar();
            if(!empty($newId)) {
                $urlParams = Yii::$app->request->getQueryParams();                
                $urlParams['id_category'] = $newId;
                unset($urlParams['old']);
                array_unshift($urlParams, 'ogloszenia/lista');
                return $this->redirect($urlParams, 301);
            } else {
                throw new NotFoundHttpException('Not found selected category.');
            }
        }
        //---------------------------
        
        $modelPortal = Yii::$app->params['modelPortal'];
        $modelsParamsSearchForms = [];
        $modelCategory = null;
        $idsCategories = [];
        if(!empty($id_category)) {
            $modelCategory = AdvertisementsCategories::find()->where(['id_category' => $id_category, 'id_portal' => $modelPortal->id_portal])->one();
            if($modelCategory === null) {
                throw new NotFoundHttpException('Not found selected category.');
            }
            
            $idsCategories = AdvertisementsCategories::getIdsSelectedBranch($modelCategory);
            
            $paramsDataForCategory = $modelCategory->getRelationsWithParams()->select(['id_param'])->indexBy('id_param')->orderBy('param_order')->asArray()->all(); 
            $idsParamsForCategory = array_keys($paramsDataForCategory);
            $modelsParams = !empty($idsParamsForCategory) ? AdvertisementsParams::find()->indexBy('id_param')->where(['id_param' => $idsParamsForCategory])->all() : [];
            
            if(!empty($modelsParams)) {
                foreach($modelsParams as $modelParam) {
                    $newModel = new AdvertisementsParamsSearchForm();
                    $newModel->setModelParam($modelParam);
                    $modelsParamsSearchForms[$modelParam->id_param] = $newModel;
                }
            }
        }
        
        $categoriesTree = AdvertisementsCategories::getCategoryTree($modelPortal->id_portal);
        $categoriesTree = $categoriesTree[0]['children'];
        
        $modelSearchForm = new AdvertisementsSearchForm(['availableTypesWithLabels' => $this->getAvailableAdvertisementsTypesWithLabels()]);
        
        if(Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelSearchForm->load(Yii::$app->request->queryParams) && (empty($modelsParamsSearchForms) || \yii\base\Model::loadMultiple($modelsParamsSearchForms, Yii::$app->request->queryParams))) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return array_merge(\yii\bootstrap\ActiveForm::validate($modelSearchForm), !empty($modelsParamsSearchForms) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsParamsSearchForms) : []);
        }
        
        $query = $this->getBaseQuery($idsCategories);
        
        $flag = $this->applyFilters($modelSearchForm, $modelsParamsSearchForms, $query);
        if(!$flag) {
            throw new NotFoundHttpException(Yii::t('frontend', 'Błędne parametry filtrów.'));
        }
        
        $dataProvider = new ActiveDataProvider([
            'query' => $query,
            'pagination' => [
                'defaultPageSize' => 15,
            ],
            'sort' => [
                'attributes' => [
                    'title', 
                    'publication_datetime',
                    'price',
//                    'locality',
//                    'region_name' => [
//                        'asc' => ['regions.name' => SORT_ASC],
//                        'desc' => ['regions.name' => SORT_DESC],
//                        'default' => ['regions.name' => SORT_ASC],
//                        'label' => Yii::t('frontend', 'Województwo')
//                    ],
                ],
                'defaultOrder' => [
                    'publication_datetime' => SORT_DESC
                ],
            ]
        ]);
        
        $seoCategories = [];
        foreach($categoriesTree as $category) {
            if($category['id'] === $modelCategory->id_category) {
                $seoCategoriesTemp = ArrayHelper::getColumn($category['children'], 'text');
                if(count($seoCategoriesTemp) > 3) {
                    $randomKeys = array_rand($seoCategoriesTemp, 3);
                    $seoCategories = [$seoCategoriesTemp[$randomKeys[0]], $seoCategoriesTemp[$randomKeys[1]], $seoCategoriesTemp[$randomKeys[2]]];
                    unset($seoCategoriesTemp);
                }
                break;
            }
        }
        $seoCategories = implode(", ", $seoCategories);  

        if(empty($modelSearchForm->type[0])) {        
            $this->setSeoMetadata('notices_listing_inside_category', [
                'title' => [$modelCategory->name, $modelPortal->domain], //'{wybrana kategoria}','{domena}'
                'keywords' => [$modelCategory->name.' - '.$seoCategories], //'{wybrana kategoria, podkategorie}'
                'description' => [$modelCategory->name, $modelPortal->domain] //'{wybrana kategoria}','{domena}'
            ]); 
        } else {
            $labelsForTypes = AdvertisementType::getValuesWithLabels();            
            $selectedTypesString = implode(", ", array_map(function($item) use ($labelsForTypes) { return $labelsForTypes[$item]; }, $modelSearchForm->type));
            
            $this->setSeoMetadata('notices_group', [
                'title' => [$selectedTypesString], //'{wybrany typ szukania np kupię}',
                'keywords' => [$selectedTypesString, $modelCategory->name.' - '.$seoCategories], //'{wybrany typ szukania np kupię}','{wybrana kategoria, podkategorie}'
                'description' => [$selectedTypesString, $modelCategory->name, $modelPortal->domain] //'{wybrany typ szukania np kupię}','{wybrana kategoria}','{domena}'
            ]);  
        }        

        return $this->render('list', [
            'dataProvider' => $dataProvider,
            'modelSearchForm' => $modelSearchForm,
            'modelsParamsSearchForms' => $modelsParamsSearchForms,
            'categoriesTree' => $categoriesTree,
            'modelCategory' => $modelCategory
        ]);
    }   
    
    public function actionSzczegoly($id, $slug = null)
    {
        //@backward_compatibility
        //---------------------------
        if(!!Yii::$app->request->get('old')) {        
            $newId = (int)(new \yii\mongodb\Query())->from('import_advertisements')->select(['target_id'])->where(['source_id' => (string)$id, 'status' => 'OK'])->scalar();
            if(!empty($newId)) {
                return $this->redirect(['ogloszenia/szczegoly', 'id' => $newId], 301);
            } else {
                throw new NotFoundHttpException('Not found selected advertisement.');
            }
        }
        //---------------------------
        
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $query = Advertisements::find()
                ->select(['advertisements.id_advertisement', 'advertisements.id_user', 'advertisements.id_company', 'advertisements.id_category', 'advertisements.title', 'advertisements.content', 'advertisements.expiry_date', 'advertisements.advertisement_type'])
                ->join('INNER JOIN', 'advertisements_categories', 'advertisements_categories.id_category = advertisements.id_category')
                ->where([
                    'advertisements.id_advertisement' => $id, 
                    'advertisements.id_portal' => $modelPortal->id_portal,
                    'advertisements_categories.id_portal' => $modelPortal->id_portal,
//                    'advertisements.status' => AdvertisementStatus::ACTIVE
                ])
                ->asArray();
        
        if(Yii::$app->user->isGuest || in_array(Yii::$app->user->identity->profile, [UserProfile::USER, UserProfile::COMPANY])) {
            $query->andWhere(['advertisements.status' => AdvertisementStatus::ACTIVE]);
        }
        
        $advertisement = $query->one();
        if($advertisement === null || !$this->checkIfDataSetsIsAvailable($advertisement['advertisement_type'])) {
            throw new NotFoundHttpException('Not found selected advertisement.');
        }

        $this->setSeoMetadata('notice_details', [
             'title' => [strip_tags($advertisement['title']), $modelPortal->domain], //'{tytuł ogłoszenia}','{domena}'
             'keywords' => [strip_tags($advertisement['title']), $modelPortal->domain], //'{tytuł ogłoszenia}','{domena}'
             'description' => [strip_tags($advertisement['title'])] //'{tytuł ogłoszenia}'
        ]); 
        
        $this->view->registerMetaTag(['property' => 'og:site_name', 'content' => $modelPortal->domain]);
        $this->view->registerMetaTag(['property' => 'og:type', 'content' => 'website']);
        $this->view->registerMetaTag(['property' => 'og:title', 'content' => \yii\helpers\Html::encode(strip_tags($advertisement['title']), false)]);
        $this->view->registerMetaTag(['property' => 'og:description', 'content' => \yii\helpers\Html::encode(strip_tags($advertisement['content']), false)]);
        $this->view->registerMetaTag(['property' => 'og:url', 'content' => \yii\helpers\Url::to(['ogloszenia/szczegoly', 'id' => $advertisement['id_advertisement'], 'slug' => \frontend\components\helpers\SlugGenerator::generate($advertisement['title'])], true)]);
        
        if(!empty($advertisement['image_filename'])) {
            list($imgWidth, $imgHeight) = getimagesize(Advertisements::getImageUrlForAdvertisement($advertisement['image_filename'], $advertisement['id_advertisement']));
            $this->view->registerMetaTag(['property' => 'og:image', 'content' => Advertisements::getImageUrlForAdvertisement($advertisement['image_filename'], $advertisement['id_advertisement'], true)]);
            $this->view->registerMetaTag(['property' => 'og:image:width', 'content' => $imgWidth]);
            $this->view->registerMetaTag(['property' => 'og:image:height', 'content' => $imgHeight]);
        }
        
        return $this->render('view', [
            'idAdvertisement' => $advertisement['id_advertisement'],
            'idCompany' => $advertisement['id_company'],
            'idUser' => $advertisement['id_user'],
            'idCategory' => $advertisement['id_category'],
            'orArchival' => strtotime($advertisement['expiry_date']) < time()
        ]);
    }  
    
    public function actionZadajPytanie($id)
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $modelAdvertisement = Advertisements::find()
                ->joinWith(['category'])
                ->where([
                    'advertisements.id_advertisement' => $id, 
                    'advertisements.id_portal' => $modelPortal->id_portal,
                    'advertisements_categories.id_portal' => $modelPortal->id_portal,
                    'advertisements.status' => AdvertisementStatus::ACTIVE
                ])
                ->one();
        if($modelAdvertisement === null || !$this->checkIfDataSetsIsAvailable($modelAdvertisement->advertisement_type)) {
            throw new NotFoundHttpException('Not found selected advertisement.');
        }  
        
        $breadcrumbs = [
            ['label' => Yii::t('frontend', 'Ogłoszenia'), 'url' => ['ogloszenia/index']],
            ['label' => Yii::t('common-models-types', $modelAdvertisement->advertisement_type), 'url' => ['ogloszenia/lista', 'AdvertisementsSearchForm[type][]' => $modelAdvertisement->advertisement_type]]
        ];
        $modelsCategoriesPath = AdvertisementsCategories::getCategoryPath($modelAdvertisement->category);
        foreach($modelsCategoriesPath as $modelCategoryPath) {
            $breadcrumbs[] = ['label' => $modelCategoryPath->name, 'url' => ['ogloszenia/lista', 'id_category' => $modelCategoryPath->id_category, 'AdvertisementsSearchForm[type][]' => $modelAdvertisement->advertisement_type]];
        }
        $breadcrumbs[] = Yii::t('frontend', 'Zadaj pytanie');
        
        if(Yii::$app->user->isGuest) {
            $this->layout = 'vmanager';
            return $this->render('//shared/do_you_have_account', [
                'title' => 'vManager - zadaj pytanie',
                'breadcrumbs' => $breadcrumbs
            ]);
        }
        
        $modelUser = Yii::$app->user->getIdentity();
        $modelsCompanies = $modelUser->getCompanies()->where(['status' => Status::ACTIVE])->orderBy('name')->all();
        
        $modelForm = new AdvertisementMessageForm(['scenario' => 'create']);
        $modelForm->id_advertisement = $modelAdvertisement->id_advertisement;
        $modelForm->id_user = Yii::$app->user->id;
        $modelForm->or_company = 0;
        
        $outputParams = [
            'modelAdvertisement' => $modelAdvertisement,
            'modelForm' => $modelForm,
            'modelsCompanies' => $modelsCompanies,
            'breadcrumbs' => $breadcrumbs
        ];
        
        if(Yii::$app->request->isAjax) {
            $postData = Yii::$app->request->post();
            unset($postData['AdvertisementMessageForm']['captcha']);
            if($modelForm->load($postData)) {
                Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
                return \yii\bootstrap\ActiveForm::validate($modelForm, ['id_company']);
            }
        }
        
        if(Yii::$app->request->getIsPost()) {
            if(!$modelForm->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('ask_question', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Formularz zawiera błędy.'));
                return $this->render('ask_question', $outputParams);
            }

            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $modelAdvertisementMessage = $modelForm->save();
            if(!$modelAdvertisementMessage) {
                $flag = false;
            }
           
            if($flag) {
                //@todo czy zawsze wysyłamy na adres mailowy użytkownika, tzn. ten z parametrem required=1 ?
                $userEmail = $modelUser->getContactData()
                    ->select('data_value')
                    ->where([
                        'required' => 1,
                        'data_type' => \common\models\types\ContactDataType::EMAIL
                    ])
                    ->scalar();
                if(!empty($userEmail)) {
                    //wysyłamy właścicielowi ogłoszenia informację o nowej wiadomości (###MAIL_36###)
                    $mailer = Yii::$app->mailer;
                    $mailer->htmlLayout = 'layouts/main-html';      
                    $mailer->textLayout = 'layouts/main-text';                 
                    $flag = $mailer->compose(
                            [
                                'html' => 'message-for-advertisement-html',
                                'text' => 'message-for-advertisement-text'
                            ],
                            [
                                'domain' => $modelPortal->domain,
                                'advertisementId' => $modelAdvertisement->id_advertisement,
                                'advertisementTitle' => $modelAdvertisement->title
                            ]
                        )
                        ->setFrom([Yii::$app->params['noReplyEmail'] => 'System vManager - '.$modelPortal->domain])
                        ->setTo($userEmail)
                        ->setSubject(Yii::t('common-mails', 'Otrzymałeś wiadomość do ogłoszenia nr {id}', ['id' => $modelAdvertisement->id_advertisement]))
                        ->send();
                }                
            }
            
            if($flag) {                
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('frontend', 'Zapytanie zostało wysłane.'));
                return $this->redirect(Yii::$app->request->getUrl());
            } else {                
                $modelForm->removeUploadedFiles();
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Błąd podczas zapisu.'));                
            }            
        }
        
        return $this->render('ask_question', $outputParams);
    }
    
    public function actionDodaj()
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $breadcrumbs = [
            ['label' => Yii::t('frontend', 'Ogłoszenia'), 'url' => ['ogloszenia/index']]
        ];
        $breadcrumbs[] = Yii::t('frontend', 'Nowe ogłoszenie');
        
        if(Yii::$app->user->isGuest) {
            $this->layout = 'vmanager';
            return $this->render('//shared/do_you_have_account', [
                'header' => Yii::t('frontend', 'Dodaj ogłoszenie – Zaloguj się'),
                'content' => Yii::t('frontend', 'Aby wystawiać ogłoszenia musisz mieć założone konto w naszym systemie zarządzania vManager.<br><br>Jeżeli nie masz jeszcze konta kliknij przycisk "Zarejestruj się bezpłatnie”, włączy się formularz dzięki, któremu utworzysz konto w naszym systemie vManager. Konto pozwala na dodawanie ogłoszeń, składanie zapytań ofertowych i zrządzanie swoimi danymi na wszystkich portalach Grupy Vertica.pl. Z jednego miejsca będziesz mógł/a dodawać ogłoszenia na wielu naszych serwisach branżowych.<br><br>Jeżeli masz już konto kliknij przycisk „Kliknij aby  się zalogować”, po zalogowaniu będziesz mogła/mógł dodać ogłoszenia.'),
                'title' => 'vManager - ogłoszenia',
                'breadcrumbs' => $breadcrumbs
            ]);
        }
        
        $categoriesTree = AdvertisementsCategories::getCategoryTree($modelPortal->id_portal);
        $categoriesTree = $categoriesTree[0]['children'];
        
        $mainCategories = ArrayHelper::getColumn($categoriesTree, 'text');
        if(count($mainCategories) > 5) {
            $randomKeys = array_rand($mainCategories, 5);
            $mainCategories = [$mainCategories[$randomKeys[0]], $mainCategories[$randomKeys[1]], $mainCategories[$randomKeys[2]], $mainCategories[$randomKeys[3]], $mainCategories[$randomKeys[4]]];
        }
        $mainCategories = implode(", ", $mainCategories);

        $this->setSeoMetadata('notices_all_categories', [
             'title' => [],
             'keywords' => [$mainCategories], //'{kategorie głównego poziomu}'
             'description' => [$mainCategories, $modelPortal->domain] //'{kategorie głównego poziomu}','{domena}'
        ]);         
        
        return $this->render('add', [
            'categoriesTree' => $categoriesTree
        ]);
    }
    
    public function actionDodajOgloszenie()
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $breadcrumbs = [
            ['label' => Yii::t('frontend', 'Ogłoszenia'), 'url' => ['ogloszenia/index']]
        ];
        $breadcrumbs[] = Yii::t('frontend', 'Wybierz rodzaj ogłoszenia');
        
        if(Yii::$app->user->isGuest) {
            $this->layout = 'vmanager';
            return $this->render('//shared/do_you_have_account', [
                'header' => Yii::t('frontend', 'Dodaj ogłoszenie – Zaloguj się'),
                'content' => Yii::t('frontend', 'Aby wystawiać ogłoszenia musisz mieć założone konto w naszym systemie zarządzania vManager.<br><br>Jeżeli nie masz jeszcze konta kliknij przycisk "Zarejestruj się bezpłatnie”, włączy się formularz dzięki, któremu utworzysz konto w naszym systemie vManager. Konto pozwala na dodawanie ogłoszeń, składanie zapytań ofertowych i zrządzanie swoimi danymi na wszystkich portalach Grupy Vertica.pl. Z jednego miejsca będziesz mógł/a dodawać ogłoszenia na wielu naszych serwisach branżowych.<br><br>Jeżeli masz już konto kliknij przycisk „Kliknij aby  się zalogować”, po zalogowaniu będziesz mogła/mógł dodać ogłoszenia.'),
                'title' => 'vManager - ogłoszenia',
                'breadcrumbs' => $breadcrumbs
            ]);
        }
        
        return $this->render('select_type', []);
    }
    
    public function actionWyczerpanoLimit()
    {
        return $this->render('exhausted_limit', []);
    }
    
    public function actionNowe($id)
    {         
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $modelCategory = AdvertisementsCategories::find()
                ->where([
                    'id_category' => $id, 
                    'id_portal' => $modelPortal->id_portal
                ])->andWhere('"right" - "left" = 1')
                ->one();
        
        if($modelCategory === null) {
            throw new NotFoundHttpException('Not found selected category.');
        }
        
        $breadcrumbs = [
            ['label' => Yii::t('frontend', 'Ogłoszenia'), 'url' => ['ogloszenia/index']]
        ];
        $modelsCategoriesPath = AdvertisementsCategories::getCategoryPath($modelCategory);
        foreach($modelsCategoriesPath as $modelCategoryPath) {
            $breadcrumbs[] = ['label' => $modelCategoryPath->name, 'url' => ['ogloszenia/lista', 'id_category' => $modelCategoryPath->id_category]];
        }
        $breadcrumbs[] = Yii::t('frontend', 'Nowe ogłoszenie');
        
        if(Yii::$app->user->isGuest) {
            $this->layout = 'vmanager';
            return $this->render('//shared/do_you_have_account', [
                'title' => 'vManager - ogłoszenia',
                'breadcrumbs' => $breadcrumbs
            ]);
        }
        
        $modelUser = Yii::$app->user->getIdentity();
        
        $userAdvertisementsLimits = new \common\models\UserAdvertisementsLimits($modelUser->id_user);
        if($userAdvertisementsLimits->checkPossibilityAdding($modelPortal->id_portal) === \common\models\UserAdvertisementsLimits::NO_POSSIBILITY) {
            return $this->redirect(['ogloszenia/wyczerpano-limit']);            
        }
        
        $userData = $this->getUserData($modelUser);
        $userCompaniesData = $this->getUserCompaniesData($modelUser);
                
        $modelForm = new AdvertisementForm(['scenario' => 'create', 'availableTypesWithLabels' => $this->getAvailableAdvertisementsTypesWithLabels()]);
        $modelForm->setUserAdvertisementsLimits($userAdvertisementsLimits);
        $modelForm->id_user = $modelUser->id_user;
        $modelForm->id_portal = $modelPortal->id_portal;
        $modelForm->id_category = $modelCategory->id_category;             
        $expiryDate = new \DateTime();
        $expiryDate->add(new \DateInterval('P30D'));
        $modelForm->expiry_date = $expiryDate->format('Y-m-d');
        
        if($modelUser->profile === UserProfile::COMPANY && !empty($userCompaniesData)) {
            reset($userCompaniesData);
            foreach($userCompaniesData as $idCompany => $userCompanyData) {
                if($userAdvertisementsLimits->checkPossibilityAdding($modelPortal->id_portal, $idCompany, true) !== \common\models\UserAdvertisementsLimits::NO_POSSIBILITY) {
                    $modelForm->or_company = 1;
                    $modelForm->id_company = $idCompany;
                    $modelForm->lat = $userCompanyData['lat'];
                    $modelForm->lng = $userCompanyData['lng'];
                    $modelForm->person = $userCompanyData['company_name'];
                    $modelForm->email = $userCompanyData['email'];
                    $modelForm->phone = $userCompanyData['phone'];
                    $modelForm->id_country = $userCompanyData['id_country'];
                    $modelForm->locality = $userCompanyData['locality'];
                    $modelForm->postcode = $userCompanyData['postcode'];
                    $modelForm->id_region = $userCompanyData['id_region'];
                    $modelForm->street = $userCompanyData['street'];
                    $modelForm->building_number = $userCompanyData['building_number'];
                    $modelForm->apartment_number = $userCompanyData['apartment_number'];
                    break;
                }
            }            
            reset($userCompaniesData);
        } else {
            if($userAdvertisementsLimits->checkPossibilityAdding($modelPortal->id_portal, $modelUser->id_user) !== \common\models\UserAdvertisementsLimits::NO_POSSIBILITY) {            
                $modelForm->or_company = 0;
                $modelForm->lat = $userData['lat'];
                $modelForm->lng = $userData['lng'];
                $modelForm->person = $userData['forename'].' '.$userData['surname'];
                $modelForm->email = $userData['email'];
                $modelForm->phone = $userData['phone'];
                $modelForm->id_country = $userData['id_country'];
                $modelForm->locality = $userData['locality'];
                $modelForm->postcode = $userData['postcode'];
                $modelForm->id_region = $userData['id_region'];
                $modelForm->street = $userData['street'];
                $modelForm->building_number = $userData['building_number'];
                $modelForm->apartment_number = $userData['apartment_number'];
            }
        }        

        $paramsDataForCategory = $modelCategory->getRelationsWithParams()->select(['id_param', 'required'])->indexBy('id_param')->orderBy('param_order')->asArray()->all(); 
        $idsParamsForCategory = array_keys($paramsDataForCategory);
        $modelsParams = !empty($idsParamsForCategory) ? \frontend\models\AdvertisementsParams::find()->indexBy('id_param')->where(['id_param' => $idsParamsForCategory])->all() : [];

        $modelsAdvertisementsParams = [];
        if(!empty($modelsParams)) {
            foreach($modelsParams as $modelParam) {
                $newModel = new \frontend\models\AdvertisementsHasAdvertisementsParams(['scenario' => 'create']);
                $newModel->setModelParam($modelParam);
                $newModel->setRequired($paramsDataForCategory[$modelParam->id_param]['required']);
                $newModel->id_param = $modelParam->id_param;
                $modelsAdvertisementsParams[$modelParam->id_param] = $newModel;
            }
        }
        
        $outputParams = [
            'modelForm' => $modelForm,
            'userData' => $userData,
            'userCompaniesData' => $userCompaniesData,
            'breadcrumbs' => $breadcrumbs,
            'modelCategory' => $modelCategory,
            'modelsCategoriesPath' => $modelsCategoriesPath,
            'modelsParams' => $modelsParams,
            'modelsAdvertisementsParams' => $modelsAdvertisementsParams,
            'userAdvertisementsLimits' => $userAdvertisementsLimits
        ];
        
        if(Yii::$app->request->isAjax && !Yii::$app->request->isPjax) {
            $postData = Yii::$app->request->post();
            unset($postData['AdvertisementForm']['captcha']);
            if($modelForm->load($postData) && (empty($modelsAdvertisementsParams) || \yii\base\Model::loadMultiple($modelsAdvertisementsParams, $postData))) {
                Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
                return array_merge(\yii\bootstrap\ActiveForm::validate($modelForm), !empty($modelsAdvertisementsParams) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsAdvertisementsParams, ['value', 'value2', 'items']) : []);
            }
        }
        
        if(Yii::$app->request->getIsPost()) {
            if(!$modelForm->load(Yii::$app->request->post()) || (!empty($modelsAdvertisementsParams) && !\yii\base\Model::loadMultiple($modelsAdvertisementsParams, Yii::$app->request->post()))) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('create', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Formularz zawiera błędy.'));
                return $this->render('create', $outputParams);
            }
            
            if(!empty($modelForm->id_company)) {
                $possibilityAddingInfo = $userAdvertisementsLimits->checkPossibilityAdding($modelPortal->id_portal, $modelForm->id_company, true);
                if($possibilityAddingInfo === \common\models\UserAdvertisementsLimits::NO_POSSIBILITY) {
                    Yii::$app->session->addFlash('warning', Yii::t('frontend', 'Wykorzystałeś już limit ogłoszeń na tym portalu dla wybranej firmy.'));
                    return $this->render('create', $outputParams);
                }
            } else {
                $possibilityAddingInfo = $userAdvertisementsLimits->checkPossibilityAdding($modelPortal->id_portal, $modelForm->id_user);
                if($possibilityAddingInfo === \common\models\UserAdvertisementsLimits::NO_POSSIBILITY) {
                    Yii::$app->session->addFlash('warning', Yii::t('frontend', 'Wykorzystałeś już limit prywatnych ogłoszeń na tym portalu.'));
                    return $this->render('create', $outputParams);
                }
            }            

            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $smtpSettings = $modelPortal->getSettingsKey('smtp_settings');
            if(empty($smtpSettings)) {
                $flag = false;
            }
            
            $flag = $flag && $modelForm->saveAdvertisement(); 
            $modelForm->setModelsParams($modelsAdvertisementsParams);            
            
            if($flag) {
                $result = $modelForm->saveAdvertisementParams();
                if(is_array($result)) {
                    $transaction->rollBack();
                    $modelForm->deleteUploadedFiles();
                    Yii::$app->session->addFlash('error', $result);
                    return $this->render('create', $outputParams);
                } else {
                    $flag = $result;
                }
            }
            
            if($flag && $possibilityAddingInfo === \common\models\UserAdvertisementsLimits::USING_PAID_TICKET) {
                if(!empty($modelForm->id_company)) {
                    $modelCompany = \common\models\Companies::findOne($modelForm->id_company);
                    $numberOfTickets = $modelCompany->getSettingsKey('advertisements_tickets');
                    $modelCompany->setSettingsKey('advertisements_tickets', ($numberOfTickets-1));
                    $flag = $modelCompany->saveSettings();
                } else {
                    $numberOfTickets = $modelUser->getSettingsKey('advertisements_tickets');
                    $modelUser->setSettingsKey('advertisements_tickets', ($numberOfTickets-1));
                    $flag = $modelUser->saveSettings();
                }
            }

            $flag = $flag && $modelForm->saveAdvertisementPhotos();

            if($flag) {                
                //wysyłamy potwierdzenie dodania ogłoszenia (###MAIL_8###)
                $mailer = Yii::$app->mailer;
                $mailer->htmlLayout = 'layouts/main-html';      
                $mailer->textLayout = 'layouts/main-text';   
                $mailer->transport = (new \Swift_SmtpTransport($smtpSettings['host'], $smtpSettings['port'], $smtpSettings['encryption']))
                    ->setUsername($smtpSettings['username'])
                    ->setPassword($smtpSettings['password']);                   
                $flag = $mailer->compose(
                        [
                            'html' => 'submitting_advertisement_html',
                            'text' => 'submitting_advertisement_text'
                        ],
                        [
                            'domain' => $modelPortal->domain,
                        ]
                    )
                    ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
                    ->setTo($modelForm->email)
                    ->setSubject(Yii::t('common-mails', 'Twoje ogłoszenie nr {id} zostało przyjęte do weryfikacji', ['id' => $modelForm->getIdAdvertisement()]))
                    ->send();
            }

            if($flag) {                
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('frontend', 'Ogłoszenie zostało dodane.'));
            } else {                
                $transaction->rollBack();
                $modelForm->deleteUploadedFiles();
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Błąd podczas zapisu.'));                
            }
            
            return $this->redirect(Yii::$app->request->getUrl());
        }
        
        return $this->render('create', $outputParams);
    } 
    
    protected function getUserData($modelUser)
    {        
        $outputData = [
            'forename' => $modelUser->forename,
            'surname' => $modelUser->surname,
            'email' => null,
            'phone' => null,
            'street' => null,
            'building_number' => null,
            'apartment_number' => null,
            'postcode' => null,
            'locality' => null,
            'region' => null,
            'id_region' => null,
            'id_country' => null,            
            'lat' => null,
            'lng' => null,
            'addresses' => []
        ];
                    
        $countryNames = [];
        
        if(!empty($modelUser->contactData)) {
            foreach($modelUser->contactData as $modelContactData) {
                if($modelContactData->data_type === ContactDataType::EMAIL) {
                    if(empty($outputData['email']) && $modelContactData->required === 1) {
                        $outputData['email'] = $modelContactData->data_value;
                    } 
                } elseif($modelContactData->data_type === ContactDataType::MOBILE_PHONE) {
                    if(empty($outputData['phone']) && $modelContactData->required === 1) {
                        $outputData['phone'] = $modelContactData->data_value;
                    }
                } 
            }
        }
                    
        $modelMainAddress = null;
        if(!empty($modelUser->addresses)) { 
            foreach($modelUser->addresses as $modelAddress) {
                if(empty($modelMainAddress) && $modelAddress->or_main === 1) {
                    $modelMainAddress = $modelAddress;
                }
                $addressHash = $modelAddress->id_country.$modelAddress->locality.$modelAddress->postcode.$modelAddress->region.$modelAddress->street.$modelAddress->building_number.$modelAddress->apartment_number;
                if(isset($outputData['addresses'][$addressHash])) {
                    continue;
                }
                if(!isset($countryNames[$modelAddress->id_country])) {
                    $countryNames[$modelAddress->id_country] = $modelAddress->country->name;
                }
                $outputData['addresses'][$addressHash] = [
                    'id_country' => $modelAddress->id_country,
                    'country_name' => $countryNames[$modelAddress->id_country],
                    'locality' => $modelAddress->locality,
                    'postcode' => $modelAddress->postcode,
                    'region' => $modelAddress->region,
                    'id_region' => isset(self::$regionsMap[$modelAddress->region]) ? self::$regionsMap[$modelAddress->region] : 1,
                    'street' => $modelAddress->street,
                    'building_number' => $modelAddress->building_number,
                    'apartment_number' => $modelAddress->apartment_number,
                    'lat' => $modelAddress->lat,
                    'lng' => $modelAddress->lng,
                ];
            }
            $outputData['addresses'] = array_values($outputData['addresses']);
            if(empty($modelMainAddress)) {
                $modelMainAddress = $modelUser->addresses[0];
            }

            if(!isset($countryNames[$modelMainAddress->id_country])) {
                $countryNames[$modelAddress->id_country] = $modelMainAddress->country->name;
            }
            $outputData['id_country'] = $modelMainAddress->id_country;
            $outputData['country_name'] = $countryNames[$modelMainAddress->id_country];
            $outputData['locality'] = $modelMainAddress->locality;
            $outputData['postcode'] = $modelMainAddress->postcode;
            $outputData['region'] = $modelMainAddress->region;
            $outputData['id_region'] = isset(self::$regionsMap[$modelMainAddress->region]) ? self::$regionsMap[$modelMainAddress->region] : 1;
            $outputData['street'] = $modelMainAddress->street;
            $outputData['building_number'] = $modelMainAddress->building_number;
            $outputData['apartment_number'] = $modelMainAddress->apartment_number;
            $outputData['lat'] = $modelMainAddress->lat;
            $outputData['lng'] = $modelMainAddress->lng;
        }
        
        return $outputData;
    }
    
    protected function getUserCompaniesData($modelUser)
    {        
        $outputData = [];                    
        $countryNames = [];
                            
        $modelsCompanies = \common\models\Companies::find()
                    ->with([
                        'contactData' => function($q) { $q->orderBy('data_order'); }, 
                        'correspondenceData', 
                        'invoicingData' => function($q) { $q->orderBy('or_main DESC, id_invoicing_data ASC'); }
                    ])
                    ->where(['id_user' => $modelUser->id_user, 'status' => Status::ACTIVE])
                    ->orderBy('name')
                    ->all();
        if(!empty($modelsCompanies)) {
            foreach($modelsCompanies as $modelCompany) {
                if(!isset($countryNames[$modelCompany->id_country])) {
                    $countryNames[$modelCompany->id_country] = $modelCompany->country->name;
                } 
                $addressHash = $modelCompany->id_country.$modelCompany->locality.$modelCompany->postcode.$modelCompany->region.$modelCompany->street.$modelCompany->building_number.$modelCompany->apartment_number;
                $company = [
                    'id_company' => $modelCompany->id_company,
                    'company_name' => $modelCompany->name,
                    'tax_id' => !empty($modelCompany->invoicingData[0]) ? $modelCompany->invoicingData[0]->tax_id : null,
                    'forename' => $modelUser->forename,
                    'surname' => $modelUser->surname,
                    'email' => null,
                    'phone' => null,
                    'street' => $modelCompany->street,
                    'building_number' => $modelCompany->building_number,
                    'apartment_number' => $modelCompany->apartment_number,
                    'postcode' => $modelCompany->postcode,
                    'locality' => $modelCompany->locality,
                    'region' => $modelCompany->region,
                    'id_region' => isset(self::$regionsMap[$modelCompany->region]) ? self::$regionsMap[$modelCompany->region] : 1,
                    'id_country' => $modelCompany->id_country,     
                    'lat' => $modelCompany->lat,
                    'lng' => $modelCompany->lng,
                    'addresses' => [
                        $addressHash => [
                            'id_country' => $modelCompany->id_country,
                            'country_name' => $countryNames[$modelCompany->id_country],
                            'locality' => $modelCompany->locality,
                            'postcode' => $modelCompany->postcode,
                            'region' => $modelCompany->region,
                            'id_region' => isset(self::$regionsMap[$modelCompany->region]) ? self::$regionsMap[$modelCompany->region] : 1,
                            'street' => $modelCompany->street,
                            'building_number' => $modelCompany->building_number,
                            'apartment_number' => $modelCompany->apartment_number,
                            'lat' => $modelCompany->lat,
                            'lng' => $modelCompany->lng,
                        ]
                    ]
                ];
                
                if(!empty($modelCompany->contactData)) {
                    foreach($modelCompany->contactData as $modelContactData) {
                        if($modelContactData->data_type === ContactDataType::EMAIL) {
                            if(empty($company['email'])) {
                                $company['email'] = $modelContactData->data_value;
                            } 
                        } elseif($modelContactData->data_type === ContactDataType::MOBILE_PHONE) {
                            if(empty($company['phone'])) {
                                $company['phone'] = $modelContactData->data_value;
                            } 
                        } 
                    }
                }
                
                if(!empty($modelCompany->correspondenceData)) {
                    foreach($modelCompany->correspondenceData as $modelCorrespondenceData) {
                        $addressHash = $modelCorrespondenceData->id_country.$modelCorrespondenceData->locality.$modelCorrespondenceData->postcode.$modelCorrespondenceData->street.$modelCorrespondenceData->building_number.$modelCorrespondenceData->apartment_number;
                        if(isset($company['addresses'][$addressHash])) {
                            continue;
                        }
                        if(!isset($countryNames[$modelCorrespondenceData->id_country])) {
                            $countryNames[$modelCorrespondenceData->id_country] = $modelCorrespondenceData->country->name;
                        }  
                        $company['addresses'][$addressHash] = [
                            'id_country' => $modelCorrespondenceData->id_country,
                            'country_name' => $countryNames[$modelCorrespondenceData->id_country],
                            'locality' => $modelCorrespondenceData->locality,
                            'postcode' => $modelCorrespondenceData->postcode,
                            'region' => null,
                            'street' => $modelCorrespondenceData->street,
                            'building_number' => $modelCorrespondenceData->building_number,
                            'apartment_number' => $modelCorrespondenceData->apartment_number,
                            'lat' => null,
                            'lng' => null,
                        ];
                    }
                }
                if(!empty($modelCompany->invoicingData)) {
                    foreach($modelCompany->invoicingData as $modelInvoicingData) {
                        $addressHash = $modelInvoicingData->id_country.$modelInvoicingData->locality.$modelInvoicingData->postcode.$modelInvoicingData->street.$modelInvoicingData->building_number.$modelInvoicingData->apartment_number;
                        if(isset($company['addresses'][$addressHash])) {
                            continue;
                        }
                        if(!isset($countryNames[$modelInvoicingData->id_country])) {
                            $countryNames[$modelInvoicingData->id_country] = $modelInvoicingData->country->name;
                        }
                        $company['addresses'][$addressHash] = [
                            'id_country' => $modelInvoicingData->id_country,
                            'country_name' => $countryNames[$modelInvoicingData->id_country],
                            'locality' => $modelInvoicingData->locality,
                            'postcode' => $modelInvoicingData->postcode,
                            'region' => null,
                            'street' => $modelInvoicingData->street,
                            'building_number' => $modelInvoicingData->building_number,
                            'apartment_number' => $modelInvoicingData->apartment_number,
                            'lat' => null,
                            'lng' => null,
                        ];
                    }
                }
                
                $outputData[$modelCompany->id_company] = $company;
            }
        }
        
        return $outputData;
    }
    
    protected function checkIfDataSetsIsAvailable($type)
    {
        if(empty($type)) {
            return true;
        }
        
        return array_key_exists ($type, $this->getAvailableAdvertisementsTypesWithLabels());
    }
    
    protected function getAvailableAdvertisementsTypesWithLabels()
    {
        $dataSets = Yii::$app->params['modelPortal']->getSettingsKey('data_sets');
        $advertisementsTypesWithLabels = AdvertisementType::getValuesWithLabels();
        $dataSetsMap = [
            \common\models\types\AdvertisementType::SELL => 'advertisements_sell',
            \common\models\types\AdvertisementType::BUY => 'advertisements_buy',
            \common\models\types\AdvertisementType::EXCHANGE => 'advertisements_exchange',
            \common\models\types\AdvertisementType::GIVE => 'advertisements_give',
            \common\models\types\AdvertisementType::TAKE => 'advertisements_take',
            \common\models\types\AdvertisementType::PARTNERSHIP => 'advertisements_partnership',
        ];        
        foreach($advertisementsTypesWithLabels as $key => $value) {
            if(intval($dataSets[$dataSetsMap[$key]]) === 0) {
                unset($advertisementsTypesWithLabels[$key]);
            }
        }
        return $advertisementsTypesWithLabels;
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com