Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/backend/models/
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/models/PresentationForm.php
<?php
namespace backend\models;

use Yii;
use yii\base\Model;
use common\models\PresentationsPackages;
use common\models\Portals;
use common\models\CompaniesPresentations;
use common\models\Services;
use common\models\PresentationsTabs;
use common\models\CompaniesPresentationsTabs;
use common\models\CompaniesPresentationsPages;
use common\models\CompaniesPresentationsHasCompaniesPhotogalleries;
use common\models\CompaniesPresentationsHasCompaniesVideogalleries;
use common\models\CompaniesPresentationsHasCompaniesAwards;
use common\models\CompaniesPresentationsHasCompaniesDownloads;
use common\models\CompaniesPresentationsHasCompaniesBranches;
use common\models\CompaniesPresentationsHasCompaniesDepartments;
use common\models\CompaniesPresentationsHasCountries;
use common\models\CompaniesPresentationsHasRegions;
use common\models\CompaniesPresentationsHasProducts;
use common\models\CompaniesPresentationsHasPresentationsTags;
use common\models\CompaniesPresentationsMirroring;
use common\models\types\Status;

class PresentationForm extends Model
{
    public $id_portal;
    public $id_package;    
    public $id_presentation;
    
    public $modelCompany;
    
    /**
     * @inheritdoc
     */
    public function rules()
    {
        $idCompany = $this->modelCompany->id_company;
        return [
            ['id_portal', 'required'],
            ['id_portal', 'number', 'integerOnly' => true, 'min' => 1],
            ['id_portal', 'exist', 'targetClass' => Portals::className(), 'targetAttribute' => 'id_portal'],
            
            ['id_package', 'required'],
            ['id_package', 'string', 'max' => 30],
            ['id_package', 'exist', 'targetClass' => PresentationsPackages::className(), 'targetAttribute' => 'id_package'],

            ['id_presentation', 'number', 'integerOnly' => true, 'min' => 1],
            ['id_presentation', 'exist', 'targetClass' => CompaniesPresentations::className(), 'targetAttribute' => 'id_presentation', 'filter' => ['id_company' => $idCompany]],
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id_portal' => Yii::t('backend', 'Portal'),
            'id_package' => Yii::t('backend', 'Pakiet'),
            'id_presentation' => Yii::t('backend', 'Utwórz prezentację na podstawie wybranej prezentacji'),
        ];
    }
    
    public function save()
    {        
        if(!empty($this->id_presentation)) {
            $idNewPresentation = $this->copyPresentation();
        } else {
            $idNewPresentation = $this->createPresentation();
        }
        
        $idPortalParent = Portals::find()->select(['id_parent_portal'])->where(['id_portal' => $this->id_portal])->scalar();
        if(!empty($idPortalParent) && !empty($idNewPresentation)) {
            $flag = $this->crateEntriesForPresentationsMirroring($idPortalParent, $idNewPresentation);
            if($flag === false) {
                return false;
            }
        }
        
        return $idNewPresentation;
    }
    
    protected function crateEntriesForPresentationsMirroring($idPortalParent, $idNewPresentation)
    {
        $idsRelatedPortals = Portals::find()->select(['id_portal'])->where(['id_parent_portal' => $idPortalParent])->column();
        $idsPresentations = CompaniesPresentations::find()
                ->select(['id_presentation'])
                ->where([
                    'id_portal' => $idsRelatedPortals, 
                    'id_company' => $this->modelCompany->id_company
                ])->column();
        $idsPresentations = array_unique(array_merge($idsPresentations, [$idNewPresentation]));
        
        if(count($idsPresentations) > 1) {
            $existingRelations = [];
            $relations = CompaniesPresentationsMirroring::find()->where(['id_presentation' => $idsPresentations])->orWhere(['id_presentation' => $idsPresentations])->asArray()->all();
            if(!empty($relations)) {
                foreach($relations as $relation) {
                    $existingRelations[$relation['id_presentation'].'-'.$relation['id_related_presentation']] = true;
                }
            }
            
            foreach($idsPresentations as $idPresentation1) {
                foreach($idsPresentations as $idPresentation2) {
                    if($idPresentation1 !== $idPresentation2 && !isset($existingRelations[$idPresentation1.'-'.$idPresentation2])) {
                        $modelCompanyPresentationMirroring = new CompaniesPresentationsMirroring();
                        $modelCompanyPresentationMirroring->id_presentation = $idPresentation1;
                        $modelCompanyPresentationMirroring->id_related_presentation = $idPresentation2;
                        if(!$modelCompanyPresentationMirroring->validate() || !$modelCompanyPresentationMirroring->save(false)) {
                            return false;
                        }
                    }
                }
            }
        }
        
        return true;        
    }
    
    protected function copyPresentation()
    {
        $modelBaseCompanyPresentation = CompaniesPresentations::find()
                ->with([
                    'relationsWithTabs', 'relationsWithTabs.page', 'relationsWithPhotogalleries', 'relationsWithVideogalleries', 'relationsWithAwards', 
                    'relationsWithDownloads', 'relationsWithBranches', 'relationsWithDepartments', 'relationsWithCountries', 'relationsWithRegions', 
//                    'relationsWithProducts', 
                    'relationsWithTags', 'relationsWithTags.tag',
                ])
                ->where(['id_presentation' => $this->id_presentation])
                ->one();
        if(empty($modelBaseCompanyPresentation)) {
            return false;
        }
                
        $modelCompanyPresentation = new CompaniesPresentations(['scenario' => 'create']);
        $modelCompanyPresentation->id_company = $this->modelCompany->id_company;
        $modelCompanyPresentation->id_portal = $this->id_portal;
        $modelCompanyPresentation->id_package = $this->id_package;
        $modelCompanyPresentation->status = $modelBaseCompanyPresentation->status;

        $modelService = \common\models\Services::findOne('COMPANY_PRESENTATION_'.$this->id_package);
        if($this->id_package !== PresentationsPackages::PACKAGE_STARTER) {
            $settings = [
                'visible_contact_data_fields' => !empty($modelBaseCompanyPresentation->settings['visible_contact_data_fields']) ? $modelBaseCompanyPresentation->settings['visible_contact_data_fields'] : ['name', 'short_name', 'street', 'address_cont', 'building_number', 'apartment_number', 'postcode', 'locality', 'region', 'id_country', 'business_registration_number', 'national_court_register_number'],
                'visible_contact_data_items' => !empty($modelBaseCompanyPresentation->settings['visible_contact_data_items']) ? $modelBaseCompanyPresentation->settings['visible_contact_data_items'] : $this->modelCompany->getContactData()->select(['id_contact_data'])->column()
            ];
        } else {
            $settings = [
                'visible_contact_data_fields' => ['name', 'short_name', 'street', 'address_cont', 'building_number', 'apartment_number', 'postcode', 'locality', 'region', 'id_country'],
                'visible_contact_data_items' => []
            ];
        }
        foreach(['products_limit', 'banners_limit', 'articles_limit', 'branches_limit', 'mailings_limit', 'advertisements_limit', 'top_position_in_companies_categories_tree', 'top_positions_in_products_categories_tree_limit'] as $field) {
            $settings[$field] = $modelService->params[$field];
        }
        
        $modelCompanyPresentation->settings = $settings;
        
        if(!$modelCompanyPresentation->validate() || !$modelCompanyPresentation->save(false)) {
            return false;
        } 
        
        $orExistsProductsTab = false;
        $availableTabs = \common\models\PresentationsPackagesHasPresentationsTabs::find()->select(['id_tab'])->where(['id_package' => $this->id_package])->column();     
        $availableTabs = array_merge($availableTabs, [PresentationsTabs::TAB_ABOUT_COMPANY, PresentationsTabs::TAB_OFFER]);
        foreach($modelBaseCompanyPresentation->relationsWithTabs as $companyPresentationTab) {
            if(!in_array($companyPresentationTab->id_tab, $availableTabs)) {
                $companyPresentationTab->status = Status::INACTIVE;
                if(!$companyPresentationTab->save(false)) {
                    return false;
                } 
                if($companyPresentationTab->id_tab === PresentationsTabs::TAB_PRODUCTS_AND_SERVICES) {
                    $orExistsProductsTab = true;
                }
                continue;
            }
            
            $modelCompanyPresentationTab = new CompaniesPresentationsTabs(['scenario' => 'create']);
            $modelCompanyPresentationTab->id_presentation = $modelCompanyPresentation->id_presentation;
            $modelCompanyPresentationTab->id_tab = $companyPresentationTab->id_tab;
            $modelCompanyPresentationTab->tab_order = $companyPresentationTab->tab_order;
            $modelCompanyPresentationTab->status = $companyPresentationTab->status;
            $modelCompanyPresentationTab->or_empty = $companyPresentationTab->or_empty;
            if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
                return false;
            } 
            if(($companyPresentationTab->id_tab === PresentationsTabs::TAB_ABOUT_COMPANY || $companyPresentationTab->id_tab === PresentationsTabs::TAB_OFFER) && !empty($companyPresentationTab->page)) {
                $modelCompanyPresentationPage = new CompaniesPresentationsPages(['scenario' => 'create']);
                $modelCompanyPresentationPage->id_company_tab = $modelCompanyPresentationTab->id_company_tab;
                $modelCompanyPresentationPage->lead = $companyPresentationTab->page->lead;
                $modelCompanyPresentationPage->content = $companyPresentationTab->page->content;
                if(!$modelCompanyPresentationPage->validate() || !$modelCompanyPresentationPage->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithPhotogalleries)) {
            foreach($modelBaseCompanyPresentation->relationsWithPhotogalleries as $relationWithPhotogallery) {
                $modelCompanyPresentationHasCompanyPhotogallery = new CompaniesPresentationsHasCompaniesPhotogalleries(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyPhotogallery->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyPhotogallery->id_gallery = $relationWithPhotogallery->id_gallery;
                $modelCompanyPresentationHasCompanyPhotogallery->gallery_order = $relationWithPhotogallery->gallery_order;
                if(!$modelCompanyPresentationHasCompanyPhotogallery->validate() || !$modelCompanyPresentationHasCompanyPhotogallery->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithVideogalleries)) {
            foreach($modelBaseCompanyPresentation->relationsWithVideogalleries as $relationWithVideogallery) {
                $modelCompanyPresentationHasCompanyVideogallery = new CompaniesPresentationsHasCompaniesVideogalleries(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyVideogallery->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyVideogallery->id_gallery = $relationWithVideogallery->id_gallery;
                $modelCompanyPresentationHasCompanyVideogallery->gallery_order = $relationWithVideogallery->gallery_order;
                if(!$modelCompanyPresentationHasCompanyVideogallery->validate() || !$modelCompanyPresentationHasCompanyVideogallery->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithAwards)) {
            foreach($modelBaseCompanyPresentation->relationsWithAwards as $relationWithAward) {
                $modelCompanyPresentationHasCompanyAward = new CompaniesPresentationsHasCompaniesAwards(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyAward->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyAward->id_award = $relationWithAward->id_award;
                $modelCompanyPresentationHasCompanyAward->award_order = $relationWithAward->award_order;
                if(!$modelCompanyPresentationHasCompanyAward->validate() || !$modelCompanyPresentationHasCompanyAward->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithDownloads)) {
            foreach($modelBaseCompanyPresentation->relationsWithDownloads as $relationWithDownload) {
                $modelCompanyPresentationHasCompanyDownload = new CompaniesPresentationsHasCompaniesDownloads(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyDownload->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyDownload->id_download = $relationWithDownload->id_download;
                $modelCompanyPresentationHasCompanyDownload->download_order = $relationWithDownload->download_order;
                if(!$modelCompanyPresentationHasCompanyDownload->validate() || !$modelCompanyPresentationHasCompanyDownload->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithBranches)) {
            foreach($modelBaseCompanyPresentation->relationsWithBranches as $relationWithBranch) {
                $modelCompanyPresentationHasCompanyBranch = new CompaniesPresentationsHasCompaniesBranches(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyBranch->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyBranch->id_branch = $relationWithBranch->id_branch;
                $modelCompanyPresentationHasCompanyBranch->branch_order = $relationWithBranch->branch_order;
                if(!$modelCompanyPresentationHasCompanyBranch->validate() || !$modelCompanyPresentationHasCompanyBranch->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithDepartments)) {
            foreach($modelBaseCompanyPresentation->relationsWithDepartments as $relationWithDepartment) {
                $modelCompanyPresentationHasCompanyDepartment = new CompaniesPresentationsHasCompaniesDepartments(['scenario' => 'create']);
                $modelCompanyPresentationHasCompanyDepartment->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCompanyDepartment->id_department = $relationWithDepartment->id_department;
                $modelCompanyPresentationHasCompanyDepartment->department_order = $relationWithDepartment->department_order;
                if(!$modelCompanyPresentationHasCompanyDepartment->validate() || !$modelCompanyPresentationHasCompanyDepartment->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithCountries)) {
            foreach($modelBaseCompanyPresentation->relationsWithCountries as $relationWithCountry) {
                $modelCompanyPresentationHasCountry = new CompaniesPresentationsHasCountries();
                $modelCompanyPresentationHasCountry->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasCountry->id_country = $relationWithCountry->id_country;
                if(!$modelCompanyPresentationHasCountry->validate() || !$modelCompanyPresentationHasCountry->save(false)) {
                    return false;
                } 
            }
        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithRegions)) {
            foreach($modelBaseCompanyPresentation->relationsWithRegions as $relationWithRegion) {
                $modelCompanyPresentationHasRegion = new CompaniesPresentationsHasRegions();
                $modelCompanyPresentationHasRegion->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasRegion->id_region = $relationWithRegion->id_region;
                if(!$modelCompanyPresentationHasRegion->validate() || !$modelCompanyPresentationHasRegion->save(false)) {
                    return false;
                } 
            }
        }
        
//        if(!empty($modelBaseCompanyPresentation->relationsWithProducts)) {
//            foreach($modelBaseCompanyPresentation->relationsWithProducts as $relationWithProduct) {
//                $modelCompanyPresentationHasProduct = new CompaniesPresentationsHasProducts(['scenario' => 'create']);
//                $modelCompanyPresentationHasProduct->id_presentation = $modelCompanyPresentation->id_presentation;
//                $modelCompanyPresentationHasProduct->id_product = $relationWithProduct->id_product;
//                $modelCompanyPresentationHasProduct->product_order = $relationWithProduct->product_order;
//                if(!$modelCompanyPresentationHasProduct->validate() || !$modelCompanyPresentationHasProduct->save(false)) {
//                    return false;
//                } 
//            }
//        }
        
        if(!empty($modelBaseCompanyPresentation->relationsWithTags)) {
            foreach($modelBaseCompanyPresentation->relationsWithTags as $relationWithTag) {
                $modelCompanyPresentationHasPresentationsTag = new CompaniesPresentationsHasPresentationsTags();
                $modelCompanyPresentationHasPresentationsTag->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationHasPresentationsTag->id_tag = $relationWithTag->id_tag;
                if(!$modelCompanyPresentationHasPresentationsTag->validate() || !$modelCompanyPresentationHasPresentationsTag->save(false)) {
                    return false;
                } 
                
                $relationWithTag->tag->quantity += 1;
                if(!$relationWithTag->save(false)) {
                    return false;
                }
            }
        }
        
        if($orExistsProductsTab) {
            $idsRelatedProducts = $modelBaseCompanyPresentation->getRelationsWithProducts()
                        ->select(['id_product'])
                        ->column();
            $results = \frontend\models\IndexProducts::refreshRecords($idsRelatedProducts);
            if(!empty($results)) {
                foreach($results as $result) {
                    if(!$result) {
                        return false;
                    }
                }
            }
        }
        
        return $modelCompanyPresentation->id_presentation;
    }
    
    protected function createPresentation()
    {
        $modelService = Services::findOne('COMPANY_PRESENTATION_'.$this->id_package);
        if(empty($modelService)) {
            return false;
        }
        
        $idsCompanyContactData = $this->modelCompany->getContactData()->select(['id_contact_data'])->column();
        //@todo na razie usuwamy ten warunek
//        if(empty($idsCompanyContactData)) {
//            return false;
//        }
        
        $modelCompanyPresentation = new CompaniesPresentations(['scenario' => 'create']);
        $modelCompanyPresentation->id_company = $this->modelCompany->id_company;
        $modelCompanyPresentation->id_portal = $this->id_portal;
        $modelCompanyPresentation->id_package = $this->id_package;
        $modelCompanyPresentation->status = Status::ACTIVE;
        if($this->id_package !== PresentationsPackages::PACKAGE_STARTER) {
            $settings = [
                'visible_contact_data_fields' => ['name', 'short_name', 'street', 'address_cont', 'building_number', 'apartment_number', 'postcode', 'locality', 'region', 'id_country', 'business_registration_number', 'national_court_register_number'],
                'visible_contact_data_items' => $idsCompanyContactData
            ];
        } else {
            $settings = [
                'visible_contact_data_fields' => ['name', 'short_name', 'street', 'address_cont', 'building_number', 'apartment_number', 'postcode', 'locality', 'region', 'id_country'],
                'visible_contact_data_items' => []
            ];
        }        
        foreach(['products_limit', 'banners_limit', 'articles_limit', 'branches_limit', 'mailings_limit', 'top_position_in_companies_categories_tree', 'top_positions_in_products_categories_tree_limit'] as $field) {
            $settings[$field] = $modelService->params[$field];
        }        
        $modelCompanyPresentation->settings = $settings;
        
        if(!$modelCompanyPresentation->validate() || !$modelCompanyPresentation->save(false)) {
            return false;
        } 
        
        //@todo sprawdzić co z zakładką "O firmie" - w obecnej chwili powinna być ona dodawana niezależnie od pakietu,
        //ale status aktywny powinna mieć wyłącznie w sytuacji, gdy wynika to z pakietu.
        $presentationTabs = PresentationsTabs::find()
                ->select(['presentations_tabs.id_tab', 'presentations_tabs.tab_order'])
                ->join('INNER JOIN', 'portals_has_presentations_tabs', 'portals_has_presentations_tabs.id_tab = presentations_tabs.id_tab')
                ->join('INNER JOIN', 'presentations_packages_has_presentations_tabs', 'presentations_packages_has_presentations_tabs.id_tab = presentations_tabs.id_tab')
                ->where([
                    'portals_has_presentations_tabs.id_portal' => $this->id_portal,
                    'presentations_packages_has_presentations_tabs.id_package' => $this->id_package
                ])
                ->orderBy('presentations_tabs.tab_order')
                ->indexBy('id_tab')
                ->asArray()
                ->all();
        foreach($presentationTabs as $presentationTab) {
            $modelCompanyPresentationTab = new CompaniesPresentationsTabs(['scenario' => 'create']);
            $modelCompanyPresentationTab->id_presentation = $modelCompanyPresentation->id_presentation;
            $modelCompanyPresentationTab->id_tab = $presentationTab['id_tab'];
            $modelCompanyPresentationTab->tab_order = $presentationTab['tab_order'];
            $modelCompanyPresentationTab->status = Status::ACTIVE;
            if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
                return false;
            } 
            
            if(($modelCompanyPresentationTab->id_tab === PresentationsTabs::TAB_ABOUT_COMPANY || $modelCompanyPresentationTab->id_tab === PresentationsTabs::TAB_OFFER)) {
                $modelCompanyPresentationPage = new CompaniesPresentationsPages(['scenario' => 'create']);
                $modelCompanyPresentationPage->id_company_tab = $modelCompanyPresentationTab->id_company_tab;
                $modelCompanyPresentationPage->lead = 'Uzupełnij';
                $modelCompanyPresentationPage->content = 'Uzupełnij';
                if(!$modelCompanyPresentationPage->validate() || !$modelCompanyPresentationPage->save(false)) {
                    return false;
                } 
            }
        }
        
        $additionalPresentationTabs = PresentationsTabs::find()
                ->select(['presentations_tabs.id_tab', 'presentations_tabs.tab_order'])
                ->where(['id_tab' => [PresentationsTabs::TAB_ABOUT_COMPANY, PresentationsTabs::TAB_OFFER]])
                ->orderBy('tab_order')
                ->asArray()
                ->all();
        
        foreach($additionalPresentationTabs as $additionalPresentationTab) {
            if(in_array($additionalPresentationTab['id_tab'], array_keys($presentationTabs))) {
                continue;
            }
            
            $modelCompanyPresentationTab = new CompaniesPresentationsTabs(['scenario' => 'create']);
            $modelCompanyPresentationTab->id_presentation = $modelCompanyPresentation->id_presentation;
            $modelCompanyPresentationTab->id_tab = $additionalPresentationTab['id_tab'];
            $modelCompanyPresentationTab->tab_order = $additionalPresentationTab['tab_order'];
            $modelCompanyPresentationTab->status = Status::INACTIVE;
            if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
                return false;
            } 
            
            $modelCompanyPresentationPage = new CompaniesPresentationsPages(['scenario' => 'create']);
            $modelCompanyPresentationPage->id_company_tab = $modelCompanyPresentationTab->id_company_tab;
            $modelCompanyPresentationPage->lead = 'Uzupełnij';
            $modelCompanyPresentationPage->content = 'Uzupełnij';
            if(!$modelCompanyPresentationPage->validate() || !$modelCompanyPresentationPage->save(false)) {
                return false;
            } 
        }
        
        return $modelCompanyPresentation->id_presentation;;
    }
    
}
Creat By MiNi SheLL
Email: jattceo@gmail.com