Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/console/controllers/
Linux 9dbcd5f6333d 5.15.0-102-generic #112-Ubuntu SMP Tue Mar 5 16:50:32 UTC 2024 x86_64
Current File : /home/vmanager/www/console/controllers/ImportNewCompaniesController.php
<?php

namespace console\controllers;

use \Yii;
use \yii\console\Controller;
use \yii\helpers\Console;
use yii\console\ExitCode;
use common\models\CompaniesToImport;

class ImportNewCompaniesController extends Controller
{
    public $limit;
    public $presentationsStatus;
    public $presentationsPackage;
    
    public $operatorsLogins = [];
    public $idsPortals = [];
    public $withoutPresentations = false;
    
    protected $tree;
    
    protected $removedCompaniesIds = [];
    protected $existsTaxIds = [];
    protected $idsOperators = [];
    protected $idsActivePortals = [];
    
    public function options($actionID)
    {
        switch($actionID) {
            case 'import':
                return ['limit', 'presentationsStatus', 'presentationsPackage', 'operatorsLogins', 'idsPortals', 'withoutPresentations'];
            default:
                return [];
        }
    }
    
    public function actionParsePhrasesFromCategoriesTree($idPortal)
    {
        $modelPortal = \common\models\Portals::findOne($idPortal);
        if(empty($modelPortal)) {
            $this->stderr('Nie znaleziono portalu.');
            return ExitCode::NOINPUT;
        }
        
        $idPortalForCategoriesTree = empty($modelPortal->id_parent_portal) ? $modelPortal->id_portal : $modelPortal->id_parent_portal;
        
        $categoriesTree = \common\models\CompaniesCategories::getCategoryTree($idPortalForCategoriesTree);
        if(empty($categoriesTree)) {
            $this->stdout('Wybrany portal nie zawiera drzewa kategorii.');
            return ExitCode::OK;
        }
        $categoriesTree = $categoriesTree[0]['children'];

        $outputCategories = [];
        if(!empty($categoriesTree)) {            
            foreach($categoriesTree as $category) {
                $this->traverseNestedSetTreeForPhrasesForCategories($outputCategories, $category);
            }
        }
        
        if(empty($outputCategories)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }

        $fp = fopen(Yii::getAlias('@runtime/temp/new_phrases_from_categories_'.$idPortalForCategoriesTree.'.csv'), 'w');
        foreach($outputCategories as $idCategory => $outputCategory) {
            fputcsv($fp, [$idCategory, mb_strtolower($outputCategory['path'])]);
        }
        fclose($fp);
    }
    
    protected function traverseNestedSetTreeForPhrasesForCategories(&$categories, $category, $path = '')
    { 
        if($category['text'] !== 'Inne' && $category['text'] !== 'Pozostałe') {
            $path = !empty($path) ? $path.' '.$category['text'] : $category['text'];
        }
        
        if(empty($category['children'])) {
            if(!empty($path)) {
                $categories[$category['id']] = [
                    'name' => $category['text'],
                    'path' => $path
                ];
            }
            return true;
        } else {
            foreach($category['children'] as $subcategory) {
                $this->traverseNestedSetTreeForPhrasesForCategories($categories, $subcategory, $path);
            }
        }
        
        return true;
    }
    
    public function actionParseCategoriesTree($idPortal)
    {
        ini_set('xdebug.var_display_max_depth', 10);
        
        $modelPortal = \common\models\Portals::findOne($idPortal);
        if(empty($modelPortal)) {
            $this->stderr('Nie znaleziono portalu.');
            return ExitCode::NOINPUT;
        }
        
        $idPortalForCategoriesTree = empty($modelPortal->id_parent_portal) ? $modelPortal->id_portal : $modelPortal->id_parent_portal;
        
        $categoriesTree = \common\models\CompaniesCategories::getCategoryTree($idPortalForCategoriesTree);
        if(empty($categoriesTree)) {
            $this->stdout('Wybrany portal nie zawiera drzewa kategorii.');
            return ExitCode::OK;
        }
        $categoriesTree = $categoriesTree[0]['children'];

        $outputCategories = [];
        if(!empty($categoriesTree)) {            
            foreach($categoriesTree as $category) {
                $this->traverseNestedSetTree($outputCategories, $category);
            }
        }
        
        if(empty($outputCategories)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }

        $fp = fopen(Yii::getAlias('@runtime/temp/new_categories_'.$idPortalForCategoriesTree.'.csv'), 'w');
        foreach($outputCategories as $idCategory => $outputCategory) {
            fputcsv($fp, [$idCategory, mb_strtolower($outputCategory['phrase']), $outputCategory['path']]);
        }
        fclose($fp);
    }
    
    protected function traverseNestedSetTree(&$categories, $category, $phrase = '', $path = '')
    { 
        if($category['text'] !== 'Inne' && $category['text'] !== 'Pozostałe') {
            $phrase = !empty($phrase) ? $phrase.' '.$category['text'] : $category['text'];
        }
        
        $path = !empty($path) ? $path.' -> '.$category['text'] : $category['text'];
        
        if(empty($category['children'])) {
            if(!empty($path)) {
                $categories[$category['id']] = [
                    'name' => $category['text'],
                    'phrase' => $phrase,
                    'path' => $path
                ];
            }
            return true;
        } else {
            foreach($category['children'] as $subcategory) {
                $this->traverseNestedSetTree($categories, $subcategory, $phrase, $path);
            }
        }
        
        return true;
    }
    
    public function actionImportFromCsvToTemporaryCollection($filename = 'new_companies_to_import')
    {
        $sourceDatafilePath = Yii::getAlias('@runtime/temp/'.$filename.'.csv');
        
        if(!file_exists($sourceDatafilePath)) {
            $this->stderr('Brak plik z danymi.');
            return ExitCode::NOINPUT;
        }
        
        $existsIds = [];
        $ids = CompaniesToImport::find()->select(['_id'])->column();
        foreach($ids as $id) {
            $existsIds[(string)$id] = true;
        }
        unset($ids);
        
        $counter = 0;
        $columns = [];
        $fp = fopen($sourceDatafilePath, "r");
        while (($data = fgetcsv($fp, null, "|", '^')) !== FALSE) {
            if($counter === 0) {
                $columns = $data;
                $counter++;
                continue;
            } 
            
            $counter++;
            $data = array_combine($columns, $data);
            
            foreach(['ids_categories', 'searched_by_phrases', 'tags', 'source_business_sectors'] as $fieldName) {
                if(empty($data[$fieldName]) || $data[$fieldName] === '[]') {
                    $data[$fieldName] = [];
                } else {
                    $data[$fieldName] = json_decode($data[$fieldName], true);
                }
            }
            
            if(isset($existsIds[(string)$data['id']])) {
//                continue;
                $modelCompanyToImport = CompaniesToImport::find()->where(['_id' => (string)$data['id']])->one();
                
                if(!empty($data['ids_categories'])) {
//                    var_dump($data['ids_categories']); exit;
                    $idsCategories = array_unique(array_merge($modelCompanyToImport->ids_categories, $data['ids_categories']));
                    $modelCompanyToImport->ids_categories = $idsCategories;
                }
                
                if(!empty($data['ids_portals'])) {
                    $idsPortals = array_unique(array_merge($modelCompanyToImport->ids_portals, [$data['id_portal']]));
                    $modelCompanyToImport->ids_portals = $idsPortals;
                }
                
                if(!empty($data['searched_by_phrases'])) {
                    $searchedByPhrases = array_unique(array_merge($modelCompanyToImport->searched_by_phrases, $data['searched_by_phrases']));
                    $modelCompanyToImport->searched_by_phrases = $searchedByPhrases;
                }
                
                if(!empty($data['source_business_sectors'])) {
                    $sourceBusinessSectors = array_unique(array_merge($modelCompanyToImport->source_business_sectors, $data['source_business_sectors']));
                    $modelCompanyToImport->source_business_sectors = $sourceBusinessSectors;
                }
                
                if(!empty($data['tags'])) {
                    $tags = array_unique(array_merge($modelCompanyToImport->tags, $data['tags']));
                    $modelCompanyToImport->tags = $tags;
                }
            } else {
                $modelCompanyToImport = new CompaniesToImport();
                foreach($data as $key => $value) {
                    if($key === 'id') {
                        $modelCompanyToImport->_id = $value;
                    } elseif($key === 'created_at' || $key === 'updated_at') {
                        $modelCompanyToImport->$key = new \MongoDB\BSON\UTCDateTime(strtotime($value) * 1000);
                    } elseif(in_array($key, ['ids_categories', 'searched_by_phrases', 'source_business_sectors', 'tags'])) {
//                        $modelCompanyToImport->$key = json_decode($value, true);
                        $modelCompanyToImport->$key = $value;
                    } elseif($key === 'id_portal' && !empty($value)) {
                        $modelCompanyToImport->ids_portals = [(int)$value];
                    } elseif(in_array($key, ['or_visited', 'or_verified', 'or_removed_duplicates'])) {
                        $modelCompanyToImport->$key = (int)$value;
                    } elseif(in_array($key, ['lat', 'lng'])) {
                        $modelCompanyToImport->$key = $value ? (double)$value : null;
                    } else {
                        $modelCompanyToImport->$key = $value;
                    }
                }
            }
            
//            $modelCompanyToImport->validate();
//            var_dump($modelCompanyToImport->getErrors(), $modelCompanyToImport->lat, $modelCompanyToImport->lng);
//            exit;

            if(!$modelCompanyToImport->save()) {
                var_dump($modelCompanyToImport->getErrors(), (string)$modelCompanyToImport->_id, $modelCompanyToImport->lng); exit;
                $this->stderr('Blad podczas zapisu do bazy.');
                return ExitCode::CANTCREAT;
            } else {
                $existsIds[(string)$modelCompanyToImport->_id] = true;
            }
            
//            break;
        }
        fclose($fp);
        
        $this->stdout('Przetworzono plik z danymi.');
        return ExitCode::OK;
    }
    
    public function actionRemoveDuplicates()
    {   
        $this->removedCompaniesIds = [];
        
        $models = CompaniesToImport::find()
//                ->where(['or_visited' => 1])                
                ->orderBy('created_at ASC')
                ->limit(15000)
                ->all();
        if(empty($models)) {
            $this->stdout('Brak firm do przetworzenia.');
            return ExitCode::OK;
        }

        foreach($models as $model) {
            if(isset($this->removedCompaniesIds[$model->_id])) {
                continue;
            }
            
            $flag = $this->removeDuplicatesForCompany($model);

            if($flag === false) {
                $this->stderr('Blad przy przetwarzaniu firmy: "'.$model->source_name.'" (#'.$model->_id.')');
                exit;
            }
        }
        
        return ExitCode::OK;        
    }
    
    protected $existsCompanies = [];
    
    public function actionImport()
    {
        $limit = !empty($this->limit) ? (int)$this->limit : 1;
        
        if(!empty($this->operatorsLogins)) {
            $this->idsOperators = \common\models\Users::find()
                    ->select(['id_user'])
                    ->where(['profile' => [
                        \common\models\types\UserProfile::MARKETER, 
                        \common\models\types\UserProfile::EDITOR, 
                        \common\models\types\UserProfile::OPERATOR, 
                        \common\models\types\UserProfile::MODERATOR]
                    ])->andWhere(['login' => $this->operatorsLogins])
                    ->column();
        }
        
        $this->idsActivePortals = \common\models\Portals::find()
                    ->select(['id_portal'])
                    ->where(['status' => \common\models\types\Status::ACTIVE])
                    ->orderBy('id_portal')
                    ->column();
        
        if(!empty($this->idsPortals)) {
            $this->idsPortals = \common\models\Portals::find()
                    ->select(['id_portal'])
                    ->where(['id_portal' => $this->idsPortals])
                    ->column();
        } else {
            $this->idsPortals = \common\models\Portals::find()
                    ->select(['id_portal'])
                    ->where(['status' => \common\models\types\Status::ACTIVE])
                    ->orderBy('id_portal')
                    ->column();
        }
        
        $companiesInvoicingData = \common\models\CompaniesInvoicingData::find()->select(['tax_id', 'id_company'])->distinct()->asArray()->all();
        $this->existsTaxIds = [];
        foreach($companiesInvoicingData as $data) {
            $taxId = preg_replace('|[^0-9]|', '', $data['tax_id']);
            $this->existsTaxIds[$taxId] = $data['id_company'];
        }

        $this->removedCompaniesIds = [];
        
//        $model = CompaniesToImport::find()
////                ->where(['or_visited' => 1])                
//                ->orderBy('created_at ASC')
//                ->limit($limit)
//                ->one();
//        if(empty($model)) {
//            $this->stdout('Brak firm do zaimportowania.');
//            return ExitCode::OK;
//        }
        $models = CompaniesToImport::find()
//                ->where(['or_verified' => 1])       
//                ->where(['_id' => 'automatyka_1002-1'])
//                ->andWhere(['source_name' => 'Niementowski | Ochman - systemy zabezpieczeń'])
                ->orderBy('created_at ASC')
                ->limit(5000)
                ->all();
        if(empty($models)) {
            $this->stdout('Brak firm do zaimportowania.');
            return ExitCode::OK;
        }

        foreach($models as $key => $model) {
            $this->stdout(($key+1)."\n");
//            var_dump($model->_id);
            if(isset($this->removedCompaniesIds[$model->_id])) {
                continue;
            }
            
            $flag = $this->removeDuplicatesForCompany($model);
            if(!$flag) {
                var_dump("dupa: ".$model->_id); exit;
            }
            $flag = $flag && $this->save($model);

            if($flag === false) {
                $this->stderr('Blad przy imporcie firmy: "'.$model->source_name.'" (#'.$model->_id.')');
                exit;
            }
        }
        
//        if(!empty($this->existsCompanies)) {
//            $fp = fopen(Yii::getAlias('@runtime/temp/exists_companies_with_at_least_two_operators.csv'), 'w');
//            fputcsv($fp, ['id_company', 'company_name', 'operators', 'presentations']);
//            foreach ($this->existsCompanies as $fields) {
//                fputcsv($fp, $fields);
//            }
//            fclose($fp);
//            
//            
//            foreach ($this->existsCompanies as $operator => $companies) {
//                $fp = fopen(Yii::getAlias('@runtime/temp/'.$operator.'_exists_companies_only_with_presentations.csv'), 'w');
//                fputcsv($fp, ['operator', 'id_company', 'company_name', 'id_portal', 'package']);
//                foreach($companies as $fields) {
//                    fputcsv($fp, $fields);
//                }
//                fclose($fp);
//            }            
//        }
        
        return ExitCode::OK;        
    }
    
    protected function removeDuplicatesForCompany($modelCompany)
    {
        if(empty($modelCompany->source_tax_id)) {
            return true; //nie mamy jak wyszukać duplikatów
        }
        
        $modelsDuplicatedCompanies = CompaniesToImport::find()
                ->where(['source_tax_id' => $modelCompany->source_tax_id])
                ->andWhere(['not', '_id', ['$eq' => $modelCompany->_id]])
                ->all();
        
        if(empty($modelsDuplicatedCompanies)) {
            return true; //nie znaleziono żadnych firm o tym samym ID
        }
        
//        if(count($modelsDuplicatedCompanies) < 2) {
//            return true;
//        }
        
        $idsCategories = !empty($modelCompany->ids_categories) ? $modelCompany->ids_categories : [];
        $phrases = $modelCompany->searched_by_phrases;
        $businessSectors = !empty($modelCompany->source_business_sectors) ? $modelCompany->source_business_sectors : [];
        $tags = !empty($modelCompany->tags) ? $modelCompany->tags : [];
        
        foreach($modelsDuplicatedCompanies as $modelDuplicatedCompany) {
            if(empty($modelCompany->bir_locality) && !empty($modelDuplicatedCompany->bir_locality)) {
                //przepisujemy adres z BIR, jeśli nie ma go w rekordzie bazowym
                foreach(['bir_locality', 'bir_street', 'bir_building_number', 'bir_apartment_number', 'bir_postcode', 'bir_region'] as $field) {
                    $modelCompany->$field = $modelDuplicatedCompany->$field;
                }
            }
            
            foreach(['source_email', 'source_phone', 'source_www', 'source_fb', 'source_national_court_register_number', 'source_business_registration_number', 'image_url'] as $field) {
                if(empty($modelCompany->$field) && !empty($modelDuplicatedCompany->$field)) {
                    $modelCompany->$field = $modelDuplicatedCompany->$field;
                }
            }
            
            $idsCategories = array_merge($idsCategories, !empty($modelDuplicatedCompany->ids_categories) ? $modelDuplicatedCompany->ids_categories : []);
            $phrases = array_merge($phrases, $modelDuplicatedCompany->searched_by_phrases);
            $businessSectors = array_merge($businessSectors, !empty($modelDuplicatedCompany->source_business_sectors) ? $modelDuplicatedCompany->source_business_sectors : []);
            $tags = array_merge($tags, !empty($modelDuplicatedCompany->tags) ? $modelDuplicatedCompany->tags : []);
        }
        
        $modelCompany->ids_categories = array_values(array_unique($idsCategories));
        $modelCompany->searched_by_phrases = array_values(array_unique($phrases));
        $modelCompany->source_business_sectors = array_values(array_unique($businessSectors));
        $modelCompany->tags = array_values(array_unique($tags));
        
//        $this->stdout($modelCompany->_id."\n");
//        var_dump($modelCompany->searched_by_phrases);
//        exit;
        
        $flag = $modelCompany->save();
        
        if($flag) {
            foreach($modelsDuplicatedCompanies as $modelDuplicatedCompany) {
                $this->removedCompaniesIds[$modelDuplicatedCompany->_id] = $modelDuplicatedCompany->_id;
                $modelDuplicatedCompany->delete();
            }
        }
        
        return $flag;
    }
    
    protected function save($modelCompanyToImport)
    {
        $flag = false;
        
        //sprawdzamy, czy w naszej bazie istnieje już firma o takim NIP
//        $companiesInvoicingData = \common\models\CompaniesInvoicingData::find()->select(['tax_id', 'id_company'])->distinct()->asArray()->all();
//        $existsTaxIds = [];
//        foreach($companiesInvoicingData as $data) {
//            $taxId = preg_replace('|[^0-9]|', '', $data['tax_id']);
//            $existsTaxIds[$taxId] = $data['id_company'];
//        }
        
        $modelCompany = null;
        
        //sprawdzamy po NIPie
        $orCompanyExists = !empty($this->existsTaxIds[$modelCompanyToImport->source_tax_id]);
        if(!$orCompanyExists) {
            //jeśli dalej nie znalazło takiej firmy, to sprawdzamy jeszcze po adresie email. 
            $emails = [];
            if(!empty(trim($modelCompanyToImport->bir_email))) {
                $emails[$modelCompanyToImport->bir_email] = trim($modelCompanyToImport->bir_email);
            }
            if(!empty(trim($modelCompanyToImport->source_email))) {
                $emails[$modelCompanyToImport->source_email] = trim($modelCompanyToImport->source_email);
            }
            if(!empty($emails)) {
                $modelCompanyContactData = \common\models\CompaniesContactData::find()->where(['data_type' => \common\models\types\ContactDataType::EMAIL, 'data_value' => array_values($emails)])->one();
                if($modelCompanyContactData) {
                    $modelCompany = $modelCompanyContactData->company;
//                    var_dump('firma "'.$modelCompanyToImport->_id.'" znaleziona po adresach email: '.implode(', ', $emails));
//                    exit;
                }
            }
        } else {
            $idCompany = $this->existsTaxIds[$modelCompanyToImport->source_tax_id];
            $modelCompany = \common\models\Companies::find()->where(['id_company' => $idCompany])->one();
        }
        
//        if($modelCompany) {
//            $operators = [];
//            foreach($modelCompany->relationsWithOperators as $modelOperatorHasCompany) {     
//                if($modelOperatorHasCompany->operator->status !== \common\models\types\Status::ACTIVE) {
//                    continue;
//                }
//                $operators[] = $modelOperatorHasCompany->operator->login.':'.implode(',', array_map(function($item) { return $item['id_portal']; }, (array)$modelOperatorHasCompany->assigned_portals ));
//            }
//            
//            if(count($operators) < 2) {
//                return true;
//            }
//            
//            $presentations = [];
//            foreach($modelCompany->presentations as $modelCompanyPresentation) {
//                $presentations[] = $modelCompanyPresentation->portal->domain.':'.$modelCompanyPresentation->id_package;
//            }
//            
//            $this->existsCompanies[] = [
//                $modelCompany->id_company,
//                $modelCompany->name,
//                implode('|', $operators),
//                implode('|', $presentations)
//            ];
//            
//            $companyPresentationsPackagesByPortals = [];
//            foreach($modelCompany->presentations as $modelCompanyPresentation) {
//                $companyPresentationsPackagesByPortals[$modelCompanyPresentation->id_portal] = $modelCompanyPresentation->id_package;
//            }
//            
//            foreach($modelCompany->relationsWithOperators as $modelOperatorHasCompany) {
//                $operatorLogin = $modelOperatorHasCompany->operator->login;
//                $assignedPortals = (array)$modelOperatorHasCompany->assigned_portals;
//                foreach($assignedPortals as $assignedPortal) {
//                    if (empty($companyPresentationsPackagesByPortals[(int)$assignedPortal['id_portal']])) continue;
//                    
//                    $this->existsCompanies[$operatorLogin][] = [
//                        $operatorLogin, 
//                        $modelCompany->id_company, 
//                        $modelCompany->name, 
//                        (int)$assignedPortal['id_portal'], 
//                        !empty($companyPresentationsPackagesByPortals[(int)$assignedPortal['id_portal']]) ? $companyPresentationsPackagesByPortals[(int)$assignedPortal['id_portal']] : 'BRAK'
//                    ];
//                }
//            }
//        }
//        
//        return true;
        
        if(!$modelCompany) {
            //jeśli nie istnieje, to dodajemy
            $flag = $this->create($modelCompanyToImport);
            if(!$flag) {
                var_dump('tutaj '.$modelCompanyToImport->_id);
                exit;
            }
        } elseif(!$this->withoutPresentations) {
            //jeśli istnieje, to dodajemy wyłącznie prezentacje tam, gdzie ich nie ma            
            $flag = $this->createOnlyPresentations($modelCompanyToImport, $modelCompany);            
        } else {
            //firma już istnieje, a wywołanie nie uwzględnia tworzenia dodatkowych prezentacji
            $flag = true;
        }
        
        if($flag === true) {
            //@todo chwilowo zakomentowujemy
            $modelCompanyToImport->delete();
        }

        return $flag;
    }
    
    protected function create($modelCompanyToImport)
    {
        var_dump('save');
        $transaction = Yii::$app->db->beginTransaction();
        
        //tworzenie wpisu w tabeli users        
        $modelUser = $this->createUser();
        if($modelUser === false) {
            var_dump('tutaj 0'); exit;
            $transaction->rollBack();            
            return false;
        }
        $idUser = $modelUser->id_user;
        
        //tworzenie wpisów w tabeli users_contact_data
        list($flag, $userEmail) = $this->createUserContactData($idUser, $modelCompanyToImport);
        if($flag === false) {
            $transaction->rollBack();
            var_dump('tutaj 1'); exit;
            return false;
        }
        
        //tworzenie wpisu w tabeli companies        
        $modelCompany = $this->createCompany($idUser, $modelCompanyToImport);        
        if(!$modelCompany) {
            $transaction->rollBack();
            var_dump('tutaj 2'); exit;
            return false;
        } 
        $idCompany = $modelCompany->id_company;
        
        //tworzenie wpisu w tabeli companies_invoicing_data
        $modelCompanyInvoicingData = $this->createCompanyInvoicingData($modelCompany, $modelCompanyToImport);
        if($modelCompanyInvoicingData === false) {
            $transaction->rollBack();
            var_dump('tutaj 3'); exit;
            return false;
        }          
        
        //tworzenie wpisów w tabeli companies_contact_data
        $idsCompanyContactData = $this->createCompanyContactData($idCompany, $modelCompanyToImport);
        if($idsCompanyContactData === false) {
            $transaction->rollBack();
            var_dump('tutaj 4'); exit;
            return false;
        }
        
        //tworzenie wpisów w tabeli companies_has_business_sectors
        $flag = $this->createCompanyBusinessSectors($idCompany, $modelCompanyToImport);
        if(!$flag) {
            $transaction->rollBack();
            var_dump('tutaj 5'); exit;
            return false;
        }
        
        //tworzenie wpisu w tabeli companies_has_languages
        $flag = $this->createCompanyLanguages($modelCompany);
        if(!$flag) {
            $transaction->rollBack();
            var_dump('tutaj 6'); exit;
            return false;
        }
        
        if(!$this->withoutPresentations) {
        
            $result = $this->createCompanyPresentationsWithCategories($modelCompany, $modelCompanyToImport);
            if($result === false) {
                $transaction->rollBack();
                var_dump('tutaj 7'); exit;
                return false;
            }
            list($idsPresentations, $idsPortals, $modelsCompaniesPresentations) = $result;

            if(!empty($idsPresentations)) {
                $flag = $this->createCompaniesPresentationsHasCountries($modelCompany, $idsPresentations);
                if(!$flag) {
                    $transaction->rollBack();
                    var_dump('tutaj 8'); exit;
                    return false;
                }

                $flag = $this->createCompaniesPresentationsHasRegions($modelCompany, $idsPresentations);
                if(!$flag) {
                    $transaction->rollBack();
                    var_dump('tutaj 9'); exit;
                    return false;
                }

                $flag = $this->createCompaniesPresentationsTabs($modelsCompaniesPresentations);
                if(!$flag) {
                    $transaction->rollBack();
                    var_dump('tutaj 10'); exit;
                    return false;
                }

                $flag = $this->createCompaniesPresentationsTags($modelCompanyToImport, $idsPresentations);
                if(!$flag) {
                    $transaction->rollBack();
                    var_dump('tutaj 11'); exit;
                    return false;
                }
            }        
        
            if(!empty($idsPortals)) {
                foreach($idsPortals as $idPortal) {
                    $flag = \common\models\UsersHasPortals::setActivity($idUser, intval($idPortal));
                    if($flag === false) {
                        $transaction->rollBack();
                        var_dump('tutaj 12'); exit;
                        return false;
                    }

                    //@todo co z przypisywaniem firmy do operatorów ?
                }
            }
        }
        
        if(!empty($this->idsOperators)) {
            $flag = $this->createOperatorsHasCompanies($idCompany);
            if(!$flag) {
                $transaction->rollBack();
                var_dump('tutaj 13'); exit;
                return false;
            }
        }        
        
//        $transaction->rollBack();
        $transaction->commit();
//        var_dump('ok'); exit;
        
        //@todo odkomentować w wersji produkcyjnej
//        \frontend\models\IndexPresentations::refreshRecords($idsPresentations);
//        \common\models\Emails::refreshForUser($modelUser);
//        \common\models\Emails::refreshForCompany($modelCompany);

        if(!empty($userEmail)) {            
            $modelShipping = new \common\models\SurveysShipping([
                'id_user' => $modelUser->id_user,
                'id_company' => $modelCompany->id_company,
                'email' => $userEmail,
                'key' => \common\models\SurveysShipping::KEY_UPDATE_COMPANY_DATA,
                'sending_date' => new \MongoDB\BSON\UTCDateTime((new \DateTime())->add(new \DateInterval('P5D'))->getTimestamp()*1000)
            ]);
            $modelShipping->save();
        }
        
        return true;
    }
    
    protected function createOnlyPresentations($modelCompanyToImport, $modelCompany)
    {
        var_dump('saveOnlyPresentations');
//        exit;
        $transaction = Yii::$app->db->beginTransaction();
        
        $result = $this->createCompanyPresentationsWithCategories($modelCompany, $modelCompanyToImport, false);
        if($result === false) {
            $transaction->rollBack();
            return false;
        }
        list($idsPresentations, $idsPortals, $modelsCompaniesPresentations) = $result;
        
        if(!empty($idsPresentations)) {
            $flag = $this->createCompaniesPresentationsHasCountries($modelCompany, $idsPresentations);
            if(!$flag) {
                $transaction->rollBack();
                return false;
            }
            
            $flag = $this->createCompaniesPresentationsHasRegions($modelCompany, $idsPresentations);
            if(!$flag) {
                $transaction->rollBack();
                return false;
            }
            
            $flag = $this->createCompaniesPresentationsTabs($modelsCompaniesPresentations);
            if(!$flag) {
                $transaction->rollBack();
                return false;
            }
            
            $flag = $this->createCompaniesPresentationsTags($modelCompanyToImport, $idsPresentations);
            if(!$flag) {
                $transaction->rollBack();
                return false;
            }
        }
        
        if(!empty($idsPortals)) {
            foreach($idsPortals as $idPortal) {
                $flag = \common\models\UsersHasPortals::setActivity($modelCompany->id_user, intval($idPortal));
                if($flag === false) {
                    $transaction->rollBack();
                    return false;
                }
            }
        }
        
        if(!empty($this->idsOperators)) {
            $flag = $this->createOperatorsHasCompanies($modelCompany->id_company, true);
            if(!$flag) {
                $transaction->rollBack();
                return false;
            }
        }  

        Yii::$app->mongodb->getCollection('imported_companies_exists')->save([
            'id_company' => $modelCompany->id_company, 
            'ids_new_portals' => $idsPortals,
            'ids_operators' => $this->idsOperators,
            'datetime' => new \MongoDB\BSON\UTCDateTime(time()*1000)
        ]);
        
//        $transaction->rollBack();
        $transaction->commit();
        
        //@todo odkomentować w wersji produkcyjnej
//        \frontend\models\IndexPresentations::refreshRecords($idsPresentations);
        
        return true;
    }
    
    protected function createUser()
    {
        $model = new \common\models\Users(['scenario' => 'create']);
        
        $nextIdUser = Yii::$app->db->createCommand("SELECT nextval(pg_get_serial_sequence('users','id_user'))")->queryOne();
        if(!empty($nextIdUser)) {
            $model->id_user = intval($nextIdUser['nextval']);
        }
        $password = substr(str_shuffle('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!@#$%^&*()'),1,10);
        
        $model->login = 'user_'.$model->id_user;
        $model->generateHashPassword($password);
        $model->generateAuthKey();
        $model->forename = 'Użytkownik';
        $model->surname = 'automatyka.biz.pl';
        $model->status = \common\models\types\Status::ACTIVE;
        $model->profile = \common\models\types\UserProfile::COMPANY;
        $model->settings = ['advertisements_limit' => Yii::$app->params['limitOfFreeAdvertisementsForUser']];
        if(!$model->validate() || !$model->save(false)) {  
            return false;
        } 
        
        return $model;
        
    }
    
    protected function createUserContactData($idUser, $modelCompanyToImport)
    {       
        $labelsForContactDataTypes = \common\models\types\ContactDataType::getValuesWithLabels();
        
        $emailPurposes = [];
        foreach(\common\models\Emails::$purposesFields as $purposeField) {
            $emailPurposes[$purposeField] = 1;
        }
        $emailPurposes['or_contact_person'] = 0;
        
        $dataOrder = 1;
        
        $email = '';
        if(!empty($modelCompanyToImport->bir_email)) {
            $email = $modelCompanyToImport->bir_email;
        } elseif(!empty($modelCompanyToImport->source_email)) {
            $email = $modelCompanyToImport->source_email;
        }
        
        if(!empty($email)) {
            $modelUserContactData = new \common\models\UsersContactData(['scenario' => 'create']);
            $modelUserContactData->id_user = $idUser;
            $modelUserContactData->data_label = ucfirst($labelsForContactDataTypes[\common\models\types\ContactDataType::EMAIL]);
            $modelUserContactData->data_value = $email;
            $modelUserContactData->data_type = \common\models\types\ContactDataType::EMAIL;
            $modelUserContactData->data_order = $dataOrder;
            $modelUserContactData->required = 1;
            $modelUserContactData->settings = ['purposes' => $emailPurposes]; 
            if(!$modelUserContactData->validate() || !$modelUserContactData->save(false)) {  
                return false;
            } 
            $dataOrder++;
        }
        
        $phone = '';
        if(!empty($modelCompanyToImport->bir_phone)) {
            $phone = $modelCompanyToImport->bir_phone;
        } elseif(!empty($modelCompanyToImport->source_phone)) {
            $phone = $modelCompanyToImport->source_phone;
        }
        
        if(!empty($phone)) {        
            $modelUserContactData = new \common\models\UsersContactData(['scenario' => 'create']);
            $modelUserContactData->id_user = $idUser;
            $modelUserContactData->data_label = ucfirst($labelsForContactDataTypes[\common\models\types\ContactDataType::MOBILE_PHONE]);
            $modelUserContactData->data_value = $phone;
            $modelUserContactData->data_type = \common\models\types\ContactDataType::MOBILE_PHONE;
            $modelUserContactData->data_order = $dataOrder;
            $modelUserContactData->required = 1;
            if(!$modelUserContactData->validate() || !$modelUserContactData->save(false)) {  
                return false;
            } 
        }        
        
        return [true, $email];
    }
    
    private function extractAddressParts($fullAddress)
    {
        $street = $buildingNumber = $apartmentNumber = $addressCont = null;
        $matches = [];
        if(preg_match('@(.{0,5}[^0-9]*)\s([a-zA-Z]?[0-9]+.*)@u', $fullAddress, $matches) === 1) {
            $street = trim($matches[1]);
            $buildingNumber = trim($matches[2]);
        } else {
            $street = $fullAddress;
            $buildingNumber = '000';
            $addressCont = $fullAddress;
        }

        if(mb_strlen($buildingNumber) > 15) {
            $buildingNumber = str_replace(" ", "", $buildingNumber);
            if(mb_strlen($buildingNumber) > 15) {
                $buildingNumber = mb_substr($buildingNumber, 0, 15);
                $apartmentNumber = mb_substr($buildingNumber, 14, 10);
                $addressCont = $fullAddress;
            }
        }
        
        return [$street, $buildingNumber, $apartmentNumber, $addressCont];
    }
    
    protected function createCompany($idUser, $modelCompanyToImport)
    {
        $modelCompany = new \common\models\Companies(['scenario' => 'create']);
        $modelCompany->id_user = $idUser;
        $modelCompany->id_country = 'PL';
        $modelCompany->name = $modelCompanyToImport->source_name;
        
        $orAddressOk = false;
        
        //sprawdzamy, czy jest komplet danych z bazy REGON
        if(!empty($modelCompanyToImport->bir_locality) && !empty($modelCompanyToImport->bir_street) && !empty($modelCompanyToImport->bir_postcode) && !empty($modelCompanyToImport->bir_region)) {
            $modelCompany->street = $modelCompanyToImport->bir_street;
            $modelCompany->building_number = !empty($modelCompanyToImport->bir_building_number) ? $modelCompanyToImport->bir_building_number : '000';
            if(!empty($modelCompanyToImport->bir_apartment_number)) {
                $modelCompany->apartment_number = $modelCompanyToImport->bir_apartment_number;
            }
            $modelCompany->postcode = $modelCompanyToImport->bir_postcode;
            $modelCompany->locality = $modelCompanyToImport->bir_locality;
            $modelCompany->region = $modelCompanyToImport->bir_region;  
            
            $orAddressOk = $modelCompany->validate(['street', 'building_number', 'apartment_number', 'postcode', 'locality', 'region']);
//            $this->stdout('Bierzemy adres z BIR.'."\n");
        } 
        
        //jeśli nie ma prawidłowego kompletu danych z REGON, to próbujemy użyć danych źródłowych
        if(!$orAddressOk) {
            list($modelCompany->street, $modelCompany->building_number, $modelCompany->apartment_number, $modelCompany->address_cont) = $this->extractAddressParts($modelCompanyToImport->source_address);
            
            $modelCompany->postcode = $modelCompanyToImport->source_postcode;
            $modelCompany->locality = $modelCompanyToImport->source_locality;
            $modelCompany->region = $modelCompanyToImport->source_region;
            
            $orAddressOk = $modelCompany->validate(['street', 'building_number', 'apartment_number', 'postcode', 'locality', 'region']);
            $this->stdout('Bierzemy adres ze zrodla.'."\n");
        } 
        
        //jeśli nie ma prawidłowego kompletu danych ani z REGON ani ze źródła , to próbujemy złożyć dane z obu wymienionych
        if(!$orAddressOk) {
            $modelCompany->region = !empty($modelCompanyToImport->bir_region) ? $modelCompanyToImport->bir_region : (!empty($modelCompanyToImport->source_region) ? $modelCompanyToImport->source_region : null);
            $modelCompany->locality = !empty($modelCompanyToImport->bir_locality) ? $modelCompanyToImport->bir_locality : (!empty($modelCompanyToImport->source_locality) ? $modelCompanyToImport->source_locality : null);
            $modelCompany->postcode = !empty($modelCompanyToImport->bir_postcode) ? $modelCompanyToImport->bir_postcode : (!empty($modelCompanyToImport->source_postcode) ? $modelCompanyToImport->source_postcode : null);
                        
            if(!empty($modelCompanyToImport->bir_street) && !empty($modelCompanyToImport->bir_building_number)) { //opieramy się na ulicy i nr budynku z REGON
                $modelCompany->street = $modelCompanyToImport->bir_street;
                $modelCompany->building_number = $modelCompanyToImport->bir_building_number;
                $modelCompany->apartment_number = null;
                $modelCompany->address_cont = null;
            } elseif(!empty($modelCompanyToImport->source_address)) { //jeśli nie ma ulicy i nr budynku z REGON, to sprawdzamy czy jest adres ze źródła i rozbijamy go na części
                list($modelCompany->street, $modelCompany->building_number, $modelCompany->apartment_number, $modelCompany->address_cont) = $this->extractAddressParts($modelCompanyToImport->source_address);
            } elseif(!empty($modelCompanyToImport->bir_street)) { //jeśli nie ma adresu źródła, a jest ulica z REGON, to używamy jej i dopisujemy "domyślny" nr budynku (000)
                $modelCompany->street = $modelCompanyToImport->bir_street;
                $modelCompany->building_number = '000';
                $modelCompany->apartment_number = !empty($modelCompanyToImport->bir_apartment_number) ? $modelCompanyToImport->bir_apartment_number : null;
                $modelCompany->address_cont = null;
            }
            
            $this->stdout('Bierzemy adres z obu.'."\n");
        }
        
        //tymczasowo komentujemy starą wersję logiki
//        if(!empty($modelCompanyToImport->bir_locality)) {
//            $modelCompany->street = $modelCompanyToImport->bir_street;
//            $modelCompany->building_number = $modelCompanyToImport->bir_building_number;
//            if(!empty($modelCompanyToImport->bir_apartment_number)) {
//                $modelCompany->apartment_number = $modelCompanyToImport->bir_apartment_number;
//            }
//            $modelCompany->postcode = $modelCompanyToImport->bir_postcode;
//            $modelCompany->locality = $modelCompanyToImport->bir_locality;
//            $modelCompany->region = $modelCompanyToImport->bir_region;            
//        } else {            
//            $matches = [];
//            if(preg_match('@(.{0,5}[^0-9]*)\s([a-zA-Z]?[0-9]+.*)@u', $modelCompanyToImport->source_address, $matches) === 1) {
//                $modelCompany->street = trim($matches[1]);
//                $modelCompany->building_number = trim($matches[2]);
//            } else {
//                $modelCompany->street = $modelCompanyToImport->source_address;
//                $modelCompany->building_number = '000';
//                $modelCompany->address_cont = $modelCompanyToImport->source_address;
//            }
//            
//            if(mb_strlen($modelCompany->building_number) > 15) {
//                $modelCompany->building_number = str_replace(" ", "", $modelCompany->building_number);
//                if(mb_strlen($modelCompany->building_number) > 15) {
//                    $modelCompany->building_number = mb_substr($modelCompany->building_number, 0, 15);
//                    if(empty($modelCompany->apartment_number)) {
//                        $modelCompany->apartment_number = mb_substr($modelCompany->building_number, 14, 10);
//                    }
//                    $modelCompany->address_cont = $modelCompanyToImport->source_address;
//                }
//            }
//            
//            $modelCompany->postcode = $modelCompanyToImport->source_postcode;
//            $modelCompany->locality = $modelCompanyToImport->source_locality;
//            $modelCompany->region = $modelCompanyToImport->source_region;
//        }

        if(!empty($modelCompanyToImport->bir_business_registration_number)) {
            $modelCompany->business_registration_number = $modelCompanyToImport->bir_business_registration_number;
        } elseif(!empty($modelCompanyToImport->source_business_registration_number)) {
            $modelCompany->business_registration_number = $modelCompanyToImport->source_business_registration_number;
        }
        
        if(!empty($modelCompanyToImport->source_national_court_register_number)) {
            $modelCompany->national_court_register_number = $modelCompanyToImport->source_national_court_register_number;
        }
        
        $modelCompany->status = \common\models\types\Status::ACTIVE;
        $modelCompany->usage_status = \common\models\types\CompanyUsageStatus::UNUSED;
        $modelCompany->import_key = mb_substr(implode(', ', $modelCompanyToImport->searched_by_phrases), 0, 255);

        if(!empty($modelCompanyToImport->lat) && !empty($modelCompanyToImport->lng)) {
            $modelCompany->lat = $modelCompanyToImport->lat;
            $modelCompany->lng = $modelCompanyToImport->lng;
        }
        $modelCompany->settings = ['advertisements_limit' => Yii::$app->params['limitOfFreeAdvertisementsForCompany']];
        
        $annotations = '';
        if(!empty($modelCompanyToImport->searched_by_phrases)) {
            $annotations .= 'Wyszukano za pomocą fraz: '.(implode(', ', (array) $modelCompanyToImport->searched_by_phrases)).".\n\n";
        }
        if(!empty($modelCompanyToImport->source_business_sectors)) {
            $annotations .= 'Branże: '.(implode(', ', (array) $modelCompanyToImport->source_business_sectors)).".\n\n";
        }
        if(!empty($modelCompanyToImport->tags)) {
            $annotations .= 'Słowa kluczowe: '.(implode(', ', (array) $modelCompanyToImport->tags)).".\n\n";
        }
        
        if(!empty($annotations)) {
            $modelCompany->annotations = $annotations;
        }
        
        if(!$modelCompany->validate() || !$modelCompany->save(false)) { 
            var_dump($modelCompanyToImport->_id);
            return false;
        }  
        
        return $modelCompany;
    }
    
    protected function createCompanyInvoicingData($modelCompany, $modelCompanyToImport)
    {
        if(empty($modelCompanyToImport->source_tax_id)) {
            return true;
        }
        
        $modelCompanyInvoicingData = new \common\models\CompaniesInvoicingData(['scenario' => 'create']);
        $modelCompanyInvoicingData->id_company = $modelCompany->id_company;
        
        $modelCompanyInvoicingData->name = $modelCompany->name;
        $modelCompanyInvoicingData->id_country = $modelCompany->id_country;
        $modelCompanyInvoicingData->street = $modelCompany->street;
        $modelCompanyInvoicingData->building_number = $modelCompany->building_number;
        if(!empty($modelCompany->apartment_number)) {
            $modelCompanyInvoicingData->apartment_number = $modelCompany->apartment_number;
        }
        $modelCompanyInvoicingData->postcode = $modelCompany->postcode;
        $modelCompanyInvoicingData->locality = $modelCompany->locality;
        $modelCompanyInvoicingData->tax_id = $modelCompanyToImport->source_tax_id;
        $modelCompanyInvoicingData->or_main = 1;
        
        if(!$modelCompanyInvoicingData->validate() || !$modelCompanyInvoicingData->save(false)) {
            return false;
        } 
        
        $taxId = preg_replace('|[^0-9]|', '', $modelCompanyInvoicingData->tax_id);
        $this->existsTaxIds[$taxId] = $modelCompanyInvoicingData->id_company;
        
        return $modelCompanyInvoicingData;
    }
    
    protected function createCompanyContactData($idCompany, $modelCompanyToImport)
    {
        $contactDataTypesLabels = \common\models\types\ContactDataType::getValuesWithLabels();
        $idsCompanyContactData = [];        
        
        $emails = [];
        if(!empty($modelCompanyToImport->bir_email)) {
            $emails[$modelCompanyToImport->bir_email] = $modelCompanyToImport->bir_email;
        }
        if(!empty($modelCompanyToImport->source_email)) {
            $emails[$modelCompanyToImport->source_email] = $modelCompanyToImport->source_email;
        }
        
        $phones = [];
        if(!empty($modelCompanyToImport->bir_phone)) {
            $phones[$modelCompanyToImport->bir_phone] = $modelCompanyToImport->bir_phone;
        }
        if(!empty($modelCompanyToImport->source_phone)) {
            $phones[$modelCompanyToImport->source_phone] = $modelCompanyToImport->source_phone;
        }
        
        $websites = [];
        if(!empty($modelCompanyToImport->bir_www)) {
            $websites[$modelCompanyToImport->bir_www] = $modelCompanyToImport->bir_www;
        }
        if(!empty($modelCompanyToImport->source_www)) {
            $websites[$modelCompanyToImport->source_www] = $modelCompanyToImport->source_www;
        }
        
        $dataOrder = 1;
        
        if(!empty($emails)) {
            foreach($emails as $email) {
                $emailPurposes = [];
                foreach(\common\models\Emails::$purposesFields as $purposeField) {
                    $emailPurposes[$purposeField] = 1;
                }
                $emailPurposes['or_contact_person'] = 0;
                
                $modelCompanyContactData = new \common\models\CompaniesContactData(['scenario' => 'create']);
                $modelCompanyContactData->id_company = $idCompany;
                $modelCompanyContactData->data_label = $contactDataTypesLabels[\common\models\types\ContactDataType::EMAIL];
                $modelCompanyContactData->data_value = $email;
                $modelCompanyContactData->data_order = $dataOrder;
                $modelCompanyContactData->data_type = \common\models\types\ContactDataType::EMAIL;
                $modelCompanyContactData->required = 0;
                $modelCompanyContactData->settings = ['purposes' => $emailPurposes]; 
                if(!$modelCompanyContactData->validate() || !$modelCompanyContactData->save(false)) {
//                    var_dump($modelCompanyContactData->data_value, $modelCompanyContactData->getErrors());
                    return false;
                } 
                $dataOrder++;
                $idsCompanyContactData[] = $modelCompanyContactData->id_contact_data;
            }
        }
        
        if(!empty($phones)) {
            foreach($phones as $phone) {
                $modelCompanyContactData = new \common\models\CompaniesContactData(['scenario' => 'create']);
                $modelCompanyContactData->id_company = $idCompany;
                $modelCompanyContactData->data_label = $contactDataTypesLabels[\common\models\types\ContactDataType::MOBILE_PHONE];
                $modelCompanyContactData->data_value = $phone;
                $modelCompanyContactData->data_order = $dataOrder;
                $modelCompanyContactData->data_type = \common\models\types\ContactDataType::MOBILE_PHONE;
                $modelCompanyContactData->required = 0;
                $modelCompanyContactData->settings = new \stdClass();
                if(!$modelCompanyContactData->validate() || !$modelCompanyContactData->save(false)) {
//                    var_dump($modelCompanyContactData->data_value, $modelCompanyContactData->getErrors());
                    return false;
                } 
                $dataOrder++;
                $idsCompanyContactData[] = $modelCompanyContactData->id_contact_data;
            }
        }
        
        if(!empty($websites)) {
            foreach($websites as $website) {
                $modelCompanyContactData = new \common\models\CompaniesContactData(['scenario' => 'create']);
                $modelCompanyContactData->id_company = $idCompany;
                $modelCompanyContactData->data_label = $contactDataTypesLabels[\common\models\types\ContactDataType::WWW];
                $modelCompanyContactData->data_value = $this->truncateUrlIfTooLong($website);
                $modelCompanyContactData->data_order = $dataOrder;
                $modelCompanyContactData->data_type = \common\models\types\ContactDataType::WWW;
                $modelCompanyContactData->required = 0;
                $modelCompanyContactData->settings = new \stdClass();
                if(!$modelCompanyContactData->validate() || !$modelCompanyContactData->save(false)) {
//                    var_dump($modelCompanyContactData->data_value, $modelCompanyContactData->getErrors());
                    return false;
                } 
                $dataOrder++;
                $idsCompanyContactData[] = $modelCompanyContactData->id_contact_data;
            }
        }
        
        if(!empty($modelCompanyToImport->source_fb)) {                
            $modelCompanyContactData = new \common\models\CompaniesContactData(['scenario' => 'create']);
            $modelCompanyContactData->id_company = $idCompany;
            $modelCompanyContactData->data_label = $contactDataTypesLabels[\common\models\types\ContactDataType::FACEBOOK];
            $modelCompanyContactData->data_value = $this->truncateUrlIfTooLong($modelCompanyToImport->source_fb);
            $modelCompanyContactData->data_order = $dataOrder;
            $modelCompanyContactData->data_type = \common\models\types\ContactDataType::FACEBOOK;
            $modelCompanyContactData->required = 0;
            $modelCompanyContactData->settings = new \stdClass();
            if(!$modelCompanyContactData->validate() || !$modelCompanyContactData->save(false)) {
//                var_dump($modelCompanyContactData->data_value, $modelCompanyContactData->getErrors());
                return false;
            } 
            $dataOrder++;
            $idsCompanyContactData[] = $modelCompanyContactData->id_contact_data;
        }
        
        return $idsCompanyContactData;
    }
    
    private function truncateUrlIfTooLong($url)
    {
        if(mb_strlen($url) < 120) {
            return $url;
        }
        
        $positionOfQuestionMark = mb_strpos($url, '?');
        if($positionOfQuestionMark !== false) {
            return mb_substr($url, 0, $positionOfQuestionMark < 119 ? $positionOfQuestionMark : 119);
        }
    }
    
    protected function createCompanyBusinessSectors($idCompany, $modelCompanyToImport)
    {             
        if(empty($modelCompanyToImport->source_business_sectors)) {
            return true;
        }
        
        $idsBusinessSectors = \common\models\BusinessSectors::find()
                ->select(['id_sector'])
                ->where(['name' => $modelCompanyToImport->source_business_sectors])
                ->column();
        
        if(empty($idsBusinessSectors)) {
            return true;
        }
        
        foreach($idsBusinessSectors as $idBusinessSector) {
            $modelCompanyHasBusinessSector = new \common\models\CompaniesHasBusinessSectors();
            $modelCompanyHasBusinessSector->id_company = $idCompany;
            $modelCompanyHasBusinessSector->id_sector = $idBusinessSector;
            if(!$modelCompanyHasBusinessSector->validate() || !$modelCompanyHasBusinessSector->save(false)) {
                return false;
            }
        } 
        
        return true;
    }
    
    protected function createCompanyLanguages($modelCompany)
    {
        $modelCompanyHasLanguage = new \common\models\CompaniesHasLanguages(['scenario' => 'create']);
        $modelCompanyHasLanguage->id_company = $modelCompany->id_company;
        $modelCompanyHasLanguage->id_language = $modelCompany->id_country === 'PL' ? 'pl' : 'en';
        
        if(!$modelCompanyHasLanguage->validate() || !$modelCompanyHasLanguage->save(false)) { 
            return false;
        } 
        
        return true;
    }
    
    protected function getPresentationsPackage()
    {
        if(!empty($this->presentationsPackage)) {
            switch($this->presentationsPackage) {
                case \common\models\PresentationsPackages::PACKAGE_STARTER:
                case \common\models\PresentationsPackages::PACKAGE_BASIC:
                case \common\models\PresentationsPackages::PACKAGE_STANDARD:
                case \common\models\PresentationsPackages::PACKAGE_STANDARD_PLUS:
                case \common\models\PresentationsPackages::PACKAGE_PREMIUM:
                case \common\models\PresentationsPackages::PACKAGE_EXCLUSIVE:
//                case \common\models\PresentationsPackages::PACKAGE_CUSTOM;
                    return $this->presentationsPackage;
            }
        } 
        
        return \common\models\PresentationsPackages::PACKAGE_STARTER;
    }
    
    protected function createCompanyPresentationsWithCategories($modelCompany, $modelCompanyToImport, $orNewCompany = true)
    {
        $presentationsStatus = !empty($this->presentationsStatus) && intval($this->presentationsStatus) === 1 ? \common\models\types\Status::ACTIVE : \common\models\types\Status::INACTIVE;
        $presentationsPackage = $this->getPresentationsPackage();
        
        $modelService = \common\models\Services::findOne('COMPANY_PRESENTATION_STARTER');
        if(empty($modelService)) {
            return false;
        }
        
        $relatedPortals = [];
        $modelsCategoriesByPortals = [];
        $idsPortals = [];
        
        $modelsCategories = \common\models\CompaniesCategories::find()
                ->with('portal.childrenPortals')
                ->where(['id_category' => $modelCompanyToImport->ids_categories])
                ->orderBy('id_portal ASC, left ASC')
                ->all();
        if(!empty($modelsCategories)) {
            foreach($modelsCategories as $modelCategory) {
                if(empty($modelCategory->portal->childrenPortals)) {
                    $modelsCategoriesByPortals[$modelCategory->id_portal][$modelCategory->id_category] = $modelCategory;
                } else {
                    foreach($modelCategory->portal->childrenPortals as $modelChildrenPortal) {
                        $relatedPortals[$modelCategory->id_portal][$modelChildrenPortal->id_portal] = $modelChildrenPortal->id_portal;
                        $modelsCategoriesByPortals[$modelChildrenPortal->id_portal][$modelCategory->id_category] = $modelCategory;
                    }
                }
            }
            $idsPortals = array_keys($modelsCategoriesByPortals);
        }
        
        $modelsPortals = \common\models\Portals::find()
                ->with(['childrenPortals'])
                ->where(['id_portal' => $modelCompanyToImport->ids_portals])
                ->all();
        if(!empty($modelsPortals)) {
            foreach($modelsPortals as $modelPortal) {
                if(empty($modelPortal->childrenPortals)) {
                    $idsPortals[] = $modelPortal->id_portal;
                } else {
                    foreach($modelPortal->childrenPortals as $modelChildrenPortal) {
                        $relatedPortals[$modelPortal->id_portal][$modelChildrenPortal->id_portal] = $modelChildrenPortal->id_portal;
                        $idsPortals[] = $modelChildrenPortal->id_portal;
                    }
                }
            }
            $idsPortals = array_unique($idsPortals);
        }
        
        
        
        $existsPortals = !$orNewCompany ? $modelCompany->getPresentations()->select(['id_portal'])->distinct()->column() : [];
        
        $idsPresentationsByPortals = [];
        $modelsCompaniesPresentations = [];
        
        foreach($idsPortals as $idPortal) {
            if(in_array($idPortal, $existsPortals)) {
                continue;
            }
            
            $modelCompanyPresentation = new \common\models\CompaniesPresentations(['scenario' => 'create']);
            $modelCompanyPresentation->id_company = $modelCompany->id_company;
            $modelCompanyPresentation->id_portal = $idPortal;
            $modelCompanyPresentation->id_package = $presentationsPackage;
            $modelCompanyPresentation->status = $presentationsStatus;   
            $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' => $presentationsPackage !== \common\models\PresentationsPackages::PACKAGE_STARTER ? $modelCompany->getContactData()->select(['id_contact_data'])->column() : []
            ];            
            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;
            } 
            
            $idsPresentationsByPortals[$idPortal] = $modelCompanyPresentation->id_presentation;            
            
            $idsAssignedCategories = [];
            if(!empty($modelsCategoriesByPortals[$idPortal])) {
                foreach($modelsCategoriesByPortals[$idPortal] as $modelCategory) {
                    if($modelCategory->name === 'Inne' || $modelCategory->name === 'Pozostałe') { 
                        continue; //w pierwszym obiegu pomijamy tego typu kategorie, aby sprawdzić później, czy jest potrzeba przypisywania do nich (nie będzie, jeśli firma zostanie przypisana do innych kategori w danej gałęzi)
                    }

                    if($modelCategory->right - $modelCategory->left !== 1) {
                        continue;
                    }

                    $modelCompanyPresentationHasCompanyCategory = new \common\models\CompaniesPresentationsHasCompaniesCategories();
                    $modelCompanyPresentationHasCompanyCategory->id_category = $modelCategory->id_category;
                    $modelCompanyPresentationHasCompanyCategory->id_presentation = $modelCompanyPresentation->id_presentation;
                    if(!$modelCompanyPresentationHasCompanyCategory->validate() || !$modelCompanyPresentationHasCompanyCategory->save(false)) {
                        return false;
                    }

                    $idsAssignedCategories[$modelCategory->id_category] = $modelCategory->id_category;
                }

                foreach($modelsCategoriesByPortals[$idPortal] as $modelCategory) {
                    if($modelCategory->name !== 'Inne' && $modelCategory->name !== 'Pozostałe') {
                        continue; //takie kategorie już przypisaliśmy
                    }

                    if($modelCategory->right - $modelCategory->left !== 1) {
                        continue;
                    }

                    $modelParentCategory = \common\models\CompaniesCategories::getParentCategory($modelCategory);
                    $idsSiblingsCategories = \common\models\CompaniesCategories::getIdsSelectedBranch($modelParentCategory);

                    $orAssignToCategory = true;
                    foreach($idsSiblingsCategories as $idSiblingCategory) {
                        if(in_array($idSiblingCategory, array_values($idsAssignedCategories))) {
                            $orAssignToCategory = false;
                            break;
                        }
                    }                

                    if($orAssignToCategory) { //przypisujemy do kategorii typu "Inne" tylko wtedy, jeśli dana prezentacja nie została przypisanej do żadnej innej kategorii w danej gałęzi
                        $modelCompanyPresentationHasCompanyCategory = new \common\models\CompaniesPresentationsHasCompaniesCategories();
                        $modelCompanyPresentationHasCompanyCategory->id_category = $modelCategory->id_category;
                        $modelCompanyPresentationHasCompanyCategory->id_presentation = $modelCompanyPresentation->id_presentation;
                        if(!$modelCompanyPresentationHasCompanyCategory->validate() || !$modelCompanyPresentationHasCompanyCategory->save(false)) {
                            return false;
                        }
                    }

                    $idsAssignedCategories[$modelCategory->id_category] = $modelCategory->id_category;
                }
            }
            
            $modelsCompaniesPresentations[] = $modelCompanyPresentation;
        }
        
        if(!empty($relatedPortals)) {
            foreach($relatedPortals as $idParentPortal => $idsRelatedPortals) {
                $idsPresentationsForMirroring = [];
                foreach($idsRelatedPortals as $idRelatedPortal) {
                    if(!isset($idsPresentationsByPortals[$idRelatedPortal])) {
                        continue;
                    }
                    $idsPresentationsForMirroring[] = $idsPresentationsByPortals[$idRelatedPortal];
                }
            
                if(empty($idsPresentationsForMirroring)) {
                    continue;
                }
                
                foreach($idsPresentationsForMirroring as $idPresentation1) {
                    foreach($idsPresentationsForMirroring as $idPresentation2) {
                        if($idPresentation1 !== $idPresentation2) {
                            $modelCompanyPresentationMirroring = new \common\models\CompaniesPresentationsMirroring();
                            $modelCompanyPresentationMirroring->id_presentation = $idPresentation1;
                            $modelCompanyPresentationMirroring->id_related_presentation = $idPresentation2;
                            if(!$modelCompanyPresentationMirroring->validate() || !$modelCompanyPresentationMirroring->save(false)) {
                                return false;
                            }
                        }
                    }
                }
            }
        }
        
        return [array_values($idsPresentationsByPortals), array_keys($idsPresentationsByPortals), $modelsCompaniesPresentations];
    }
    
    protected function createCompaniesPresentationsHasCountries($modelCompany, $idsPresentations)
    {
        foreach($idsPresentations as $idPresentation) {
            $modelCompanyPresentationHasCountry = new \common\models\CompaniesPresentationsHasCountries();
            $modelCompanyPresentationHasCountry->id_country = $modelCompany->id_country;
            $modelCompanyPresentationHasCountry->id_presentation = $idPresentation;
            if(!$modelCompanyPresentationHasCountry->validate() || !$modelCompanyPresentationHasCountry->save(false)) {
                return false;
            }
        }
        
        return true;
    }
    
    protected function createCompaniesPresentationsHasRegions($modelCompany, $idsPresentations)
    {
        $idsRegions = \common\models\Regions::find()
                ->select(['id_region'])
                ->where(['id_country' => $modelCompany->id_country])
                ->orderBy('id_region ASC')
                ->column();
        
        if(empty($idsRegions)) {
            return true;
        }
        
        foreach($idsPresentations as $idPresentation) {
            foreach($idsRegions as $idRegion) {
                $modelCompanyPresentationHasRegion = new \common\models\CompaniesPresentationsHasRegions();
                $modelCompanyPresentationHasRegion->id_region = $idRegion;
                $modelCompanyPresentationHasRegion->id_presentation = $idPresentation;
                if(!$modelCompanyPresentationHasRegion->validate() || !$modelCompanyPresentationHasRegion->save(false)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    protected function createCompaniesPresentationsTabs($modelsCompaniesPresentations)
    {
        $presentationsPackage = $this->getPresentationsPackage();
        
        foreach($modelsCompaniesPresentations as $modelCompanyPresentation) {
            $presentationTabs = \common\models\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' => $modelCompanyPresentation->id_portal,
                    'presentations_packages_has_presentations_tabs.id_package' => $presentationsPackage
                ])
                ->orderBy('presentations_tabs.tab_order')
                ->asArray()
                ->all();
            
            $orExistAboutCompany = false;
            foreach($presentationTabs as $presentationTab) {
                if($presentationTab['id_tab'] === \common\models\PresentationsTabs::TAB_ABOUT_COMPANY) {
                    $orExistAboutCompany = true;
                }

                $modelCompanyPresentationTab = new \common\models\CompaniesPresentationsTabs(['scenario' => 'create']);
                $modelCompanyPresentationTab->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationTab->id_tab = $presentationTab['id_tab'];
                $modelCompanyPresentationTab->tab_order = $presentationTab['tab_order'];
                $modelCompanyPresentationTab->status = \common\models\types\Status::ACTIVE;
                if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
                    return false;
                } 
            }

            if(!$orExistAboutCompany) {
                $modelPresenationTab = \common\models\PresentationsTabs::findOne(\common\models\PresentationsTabs::TAB_ABOUT_COMPANY);

                $modelCompanyPresentationTab = new \common\models\CompaniesPresentationsTabs(['scenario' => 'create']);
                $modelCompanyPresentationTab->id_presentation = $modelCompanyPresentation->id_presentation;
                $modelCompanyPresentationTab->id_tab = $modelPresenationTab->id_tab;
                $modelCompanyPresentationTab->tab_order = $modelPresenationTab->tab_order;
                $modelCompanyPresentationTab->status = \common\models\types\Status::INACTIVE;
                if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
                    return false;
                } 

                $modelCompanyPresentationTabPage = new \common\models\CompaniesPresentationsPages(['scenario' => 'create']);
                $modelCompanyPresentationTabPage->id_company_tab = $modelCompanyPresentationTab->id_company_tab;
                $modelCompanyPresentationTabPage->lead = 'Uzupełnij';
                $modelCompanyPresentationTabPage->content = 'Uzupełnij';
                if(!$modelCompanyPresentationTabPage->validate() || !$modelCompanyPresentationTabPage->save(false)) {
                    return false;
                } 
            }
        }
        
        return true;
    }
   
    //@todo chyba to można usunąć
    //
//    protected function createCompanyPresentationTabs($idCompanyPresentation)
//    {        
//        
//
//        $orExistAboutCompany = false;
//        foreach($presentationTabs as $presentationTab) {
//            if($presentationTab['id_tab'] === PresentationsTabs::TAB_ABOUT_COMPANY) {
//                $orExistAboutCompany = true;
//            }
//            
//            $modelCompanyPresentationTab = new CompaniesPresentationsTabs(['scenario' => 'create']);
//            $modelCompanyPresentationTab->id_presentation = $idCompanyPresentation;
//            $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(!$orExistAboutCompany) {
//            $modelPresenationTab = PresentationsTabs::findOne(PresentationsTabs::TAB_ABOUT_COMPANY);
//            
//            $modelCompanyPresentationTab = new CompaniesPresentationsTabs(['scenario' => 'create']);
//            $modelCompanyPresentationTab->id_presentation = $idCompanyPresentation;
//            $modelCompanyPresentationTab->id_tab = $modelPresenationTab->id_tab;
//            $modelCompanyPresentationTab->tab_order = $modelPresenationTab->tab_order;
//            $modelCompanyPresentationTab->status = Status::INACTIVE;
//            if(!$modelCompanyPresentationTab->validate() || !$modelCompanyPresentationTab->save(false)) {
//                return false;
//            } 
//            
//            $modelCompanyPresentationTabPage = new \common\models\CompaniesPresentationsPages(['scenario' => 'create']);
//            $modelCompanyPresentationTabPage->id_company_tab = $modelCompanyPresentationTab->id_company_tab;
//            $modelCompanyPresentationTabPage->lead = 'Uzupełnij';
//            $modelCompanyPresentationTabPage->content = 'Uzupełnij';
//            if(!$modelCompanyPresentationTabPage->validate() || !$modelCompanyPresentationTabPage->save(false)) {
//                return false;
//            } 
//        }
//        
//        return true;
//    }
    
    protected function createCompaniesPresentationsTags($modelCompanyToImport, $idsPresentations)
    {
        $modelsPresentationsTags = \common\models\PresentationsTags::find()->where(['name' => $modelCompanyToImport->tags])->indexBy('name')->all(); 
        
        foreach($idsPresentations as $idPresentation) {
            foreach($modelCompanyToImport->tags as $tag) {
                if(mb_strlen($tag) > 60) {
                    continue;
                }
                
                if(isset($modelsPresentationsTags[$tag])) {
                    $modelPresentationsTag = $modelsPresentationsTags[$tag];                                         
                    $modelPresentationsTag->quantity += 1;
                    if(!$modelPresentationsTag->save(false)) {                        
                        return false;
                    }
                }
                else {
                    //dodajemy tag oraz powiązanie
                    $modelPresentationsTag = new \common\models\PresentationsTags(['scenario' => 'create']);
                    $modelPresentationsTag->name = $tag;
                    $modelPresentationsTag->quantity = 1;
                    if(!$modelPresentationsTag->validate() || !$modelPresentationsTag->save(false)) {
                        return false;
                    } 
                    $modelsPresentationsTags[$modelPresentationsTag->name] = $modelPresentationsTag;
                }  
                $modelCompanyPresentationHasTag = new \common\models\CompaniesPresentationsHasPresentationsTags();
                $modelCompanyPresentationHasTag->id_presentation = $idPresentation;
                $modelCompanyPresentationHasTag->id_tag = $modelPresentationsTag->id_tag;
                if(!$modelCompanyPresentationHasTag->validate() || !$modelCompanyPresentationHasTag->save(false)) {
                    return false;
                }
            } 
        }
        
        return true;
    }
    
    protected function createOperatorsHasCompanies($idCompany, $orExistsCompany = false)
    {
        if(empty($this->idsOperators)) {
            return true;
        }
        
        $orAddNewEntries = false;
        
        if($orExistsCompany) {
            if(!empty($this->idsPortals)) {
                foreach($this->idsPortals as $idPortal) {
                    $newAssignedPortals[] = [
                        'id_portal' => (int)$idPortal,
                        'created_at' => date("Y-m-d H:i:s")
                    ];
                } 
            }   
            
            $modelsOperatorsHasCompany = \common\models\OperatorsHasCompanies::find()
                    ->join('INNER JOIN', 'users', 'users.id_user = operators_has_companies.id_user')
                    ->where([
                        'operators_has_companies.id_company' => $idCompany,
                    ])
                    ->andWhere(['or', ['users.status' => \common\models\types\Status::ACTIVE], ['users.id_user' => $this->idsOperators]])
                    ->all();
            
            if(count($modelsOperatorsHasCompany) === 1) {
                if(!empty($newAssignedPortals)) {
                    $modelOperatorHasCompany = $modelsOperatorsHasCompany[0];
                    $modelOperatorHasCompany->setScenario('update');
                    $existsAssignedPortals = $modelOperatorHasCompany->assigned_portals;
                    foreach($newAssignedPortals as $newAssignedPortalData) {
                        $orExists = false;
                        foreach($existsAssignedPortals as $existsAssignedPortalData) {
                            if(intval($newAssignedPortalData['id_portal']) === intval($existsAssignedPortalData['id_portal'])) {
                                $orExists = true;
                                break;
                            }
                        }

                        if(!$orExists) {
                            $existsAssignedPortals[] = $newAssignedPortalData;
                        }
                    }
                    $modelOperatorHasCompany->assigned_portals = $existsAssignedPortals;

                    if(!$modelOperatorHasCompany->validate() || !$modelOperatorHasCompany->save(false)) {
                        return false;
                    }
                }                
            } elseif(count($modelsOperatorsHasCompany) > 1) {
                //@todo na ten moment przyjmujemy założenie, że gdy jest więcej niż 1 operator, to tworzymy nowe powiązanie do nowego operatora
                $orAddNewEntries = true;
            } else {
                $orAddNewEntries = true;
            }            
        } else {
            foreach($this->idsActivePortals as $idActivePortal) {
                $newAssignedPortals[] = [
                    'id_portal' => (int)$idActivePortal,
                    'created_at' => date("Y-m-d H:i:s")
                ];
            }
            if(!empty($this->idsPortals)) {
                foreach($this->idsPortals as $idPortal) {
                    if(in_array($idPortal, $this->idsActivePortals)) {
                        continue;
                    }
                    $newAssignedPortals[] = [
                        'id_portal' => (int)$idPortal,
                        'created_at' => date("Y-m-d H:i:s")
                    ];
                } 
            }   
            
            $orAddNewEntries = true;
        }
        
        if($orAddNewEntries) {
            foreach($this->idsOperators as $idOperator) {
                $modelOperatorHasCompany = new \common\models\OperatorsHasCompanies(['scenario' => 'create']);
                if(!empty($newAssignedPortals)) {
                    $modelOperatorHasCompany->assigned_portals = $newAssignedPortals;
                }
                $modelOperatorHasCompany->id_user = $idOperator;
                $modelOperatorHasCompany->id_company = $idCompany;

                if(!$modelOperatorHasCompany->validate() || !$modelOperatorHasCompany->save(false)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    protected function createOperatorsHasCompanies_kopia($idCompany, $orExistsCompany = false)
    {
        if(empty($this->idsOperators)) {
            return true;
        }
        
        $newAssignedPortals = [];
        if(!empty($this->idsPortals)) {
            foreach($this->idsPortals as $idPortal) {
                $newAssignedPortals[] = [
                    'id_portal' => (int)$idPortal,
                    'created_at' => date("Y-m-d H:i:s")
                ];
            } 
        }        
        
        foreach($this->idsOperators as $idOperator) {
            if($orExistsCompany) {
                $modelOperatorHasCompany = \common\models\OperatorsHasCompanies::find()->where(['id_user' => $idOperator, 'id_company' => $idCompany])->one();
            } else {
                $modelOperatorHasCompany = null;
            }
            
            if(empty($modelOperatorHasCompany)) {
                $modelOperatorHasCompany = new \common\models\OperatorsHasCompanies(['scenario' => 'create']);
                if(!empty($newAssignedPortals)) {
                    $modelOperatorHasCompany->assigned_portals = $newAssignedPortals;
                }
                $modelOperatorHasCompany->id_user = $idOperator;
                $modelOperatorHasCompany->id_company = $idCompany;
                
                if(!$modelOperatorHasCompany->validate() || !$modelOperatorHasCompany->save(false)) {
                    return false;
                }
            } elseif(!empty($newAssignedPortals)) {
                $modelOperatorHasCompany->setScenario('update');
                $existsAssignedPortals = $modelOperatorHasCompany->assigned_portals;
                foreach($newAssignedPortals as $newAssignedPortalData) {
                    $orExists = false;
                    foreach($existsAssignedPortals as $existsAssignedPortalData) {
                        if(intval($existsAssignedPortals['id_portal']) === intval($existsAssignedPortalData['id_portal'])) {
                            $orExists = true;
                            break;
                        }
                    }

                    if(!$orExists) {
                        $existsAssignedPortalData[] = $newAssignedPortalData;
                    }
                }
                $modelOperatorHasCompany->assigned_portals = $existsAssignedPortalData;
                
                if(!$modelOperatorHasCompany->validate() || !$modelOperatorHasCompany->save(false)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    public function actionImportCategoriesTrees()
    {
        $sourcePath = Yii::getAlias('@runtime/temp/new_categories');
        
        $idSelectedPortal = null;
        $dir = new \DirectoryIterator($sourcePath);
        $flag = true;
        foreach($dir as $fileinfo) {
            if(!$fileinfo->isFile()) {
                continue;
            }
            
            $filename = $fileinfo->getFilename();
            $domain = mb_substr($filename, 0, -8);
            
            //@todo proteza 
            if($domain !== 'hydraulika.org') {
                continue;
            }
            
            $idPortal = \common\models\Portals::find()->select(['id_portal'])->where(['domain' => $domain])->limit(1)->scalar();
            if(empty($idPortal)) {
                continue;
            }
            
            $orExistCategories = \common\models\CompaniesCategories::find()->where(['id_portal' => $idPortal])->exists();
            if($orExistCategories) {
                continue;
            }
            
            include($sourcePath.'/'.$filename);
            $idSelectedPortal = $idPortal;
            break;
        }
        
        if(empty($kategorie)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }
        
        $categories = [];
        foreach($kategorie as $key => $value) {
            $orExistCategoryOther = false;
            foreach($value as $key2 => $value2) {
                $name = ucfirst(mb_strtolower($value2[0]));
                if(!isset($categories[$key]) && $key2 === 0) {
                    $categories[$key] = [
                        'name' => $name,
                        'children' => []
                    ];
                } else {
                    $categories[$key]['children'][$key2] = [
                        'name' => $name,
                        'children' => []
                    ];     
                    if($name === 'Inne' || $name === 'Pozostałe') {
                        $orExistCategories = true;
                    }
                }
            }
            if(count($value) > 1 && !$orExistCategoryOther) {
                $categories[$key]['children'][] = [
                    'name' => 'Inne',
                    'children' => []
                ];     
            }
        }
        
        if(empty($categories)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }

        $this->tree = [];
        
        $categories = [
            [
                'name' => 'root',
                'children' => $categories
            ]
        ];
        $this->convertArrayToNestedSetV1($categories[0], -1);
        
        usort($this->tree, function($a, $b) {
            if ($a['left'] === $b['left']) {
                return 0;
            }
            return ($a['left'] < $b['left']) ? -1 : 1;
        }); 
        
        if(empty($this->tree)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        foreach($this->tree as $category) {  
            $model = new \common\models\CompaniesCategories(['scenario' => 'create']);
            $model->setAttributes([
                'name' => $category['name'],
                'description' => null,
                'left' => $category['left'],
                'right' => $category['right'],
                'depth' => $category['depth'],
                'id_portal' => $idSelectedPortal
            ]);

            if(!$model->save()) {
                $this->stderr('Blad podczas zapisu');
                $transaction->rollBack();
                return ExitCode::CANTCREAT;
            }
        }
//        $transaction->rollBack();
        $transaction->commit();
        return ExitCode::OK;
    }
    
    protected function convertArrayToNestedSetV1($data, $depth, $previousLeft = 0)
    {
        $depth = $depth + 1;

        $element = [];
//        $element['id_category'] = $data['id']; 
        $element['depth'] = $depth;
//        $element['description'] = (!empty($data['data']['description'])) ? $data['data']['description'] : null;
//        $element['type'] = (!empty($data['data']['type'])) ? $data['data']['type'] : null;
        $element['name'] = $data['name'];
        $element['left'] = $previousLeft + 1;

        $lastRight = $element['left'];
        $i = 1;
        if(!empty($data['children']))
        {
            foreach($data['children'] as $a_child)
            {
                $lastRight = $this->convertArrayToNestedSetV1($data['children'][$i], $depth, $lastRight);
                $i++;
            }
        }
        
        $element['right'] = $lastRight + 1; 
        array_push($this->tree, $element); 
        return $element['right'];      
    }
    
    public function actionImportCategoriesTree($domain, $filename)
    {
        ini_set('xdebug.var_display_max_depth', 10);
        
        $idPortal = \common\models\Portals::find()->select(['id_portal'])->where(['domain' => $domain])->limit(1)->scalar();
        if(empty($idPortal)) {
            $this->stdout('Brak portalu.');
            return ExitCode::DATAERR;
        }
        
        $sourcePath = Yii::getAlias('@runtime/temp/new_categories');
        
        if(empty($filename) || !file_exists($sourcePath.'/'.$filename)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::IOERR;
        }
        
        if(\common\models\CompaniesCategories::find()->where(['id_portal' => $idPortal])->exists()) {
            $this->stdout('Wybrany portal posiada juz kategorie firm.');
            return ExitCode::IOERR;
        }
        
        $categories = [];
        
        $data = file($sourcePath.'/'.$filename, FILE_SKIP_EMPTY_LINES); 
        foreach($data as $row) {
            $row = trim($row);
            $positionOfFirstSpace = mb_strpos($row, ' ');
            $numeration = mb_substr($row, 0, $positionOfFirstSpace);
            $categoryName = trim(mb_substr($row, $positionOfFirstSpace));
            
            $n = explode('.', $numeration);
            
            if(isset($n[4])) {
                $categories[$n[0]-1]['children'][$n[1]-1]['children'][$n[2]-1]['children'][$n[3]-1]['children'][$n[4]-1] = [
                    'name' => $categoryName, 
                    'children' => []
                ];
            } elseif(isset($n[3])) {
                $categories[$n[0]-1]['children'][$n[1]-1]['children'][$n[2]-1]['children'][$n[3]-1] = [
                    'name' => $categoryName, 
                    'children' => []
                ];
            } elseif(isset($n[2])) {
                $categories[$n[0]-1]['children'][$n[1]-1]['children'][$n[2]-1] = [
                    'name' => $categoryName, 
                    'children' => []
                ];
            } elseif(isset($n[1])) {
                $categories[$n[0]-1]['children'][$n[1]-1] = [
                    'name' => $categoryName, 
                    'children' => []
                ];
            } elseif(isset($n[0])) {
                $categories[$n[0]-1] = [
                    'name' => $categoryName, 
                    'children' => []
                ];
            }
            
        }        
        
        $this->tree = [];
        
        $categories = [
            [
                'name' => 'root',
                'children' => $categories
            ]
        ];
        $this->convertArrayToNestedSetV2($categories[0], -1);
        
        if(empty($this->tree)) {
            $this->stdout('Brak kategorii do przetworzenia.');
            return ExitCode::OK;
        }
        
        usort($this->tree, function($a, $b) {
            if ($a['left'] === $b['left']) {
                return 0;
            }
            return ($a['left'] < $b['left']) ? -1 : 1;
        }); 
        
        $transaction = Yii::$app->db->beginTransaction();
        foreach($this->tree as $category) {  
            $model = new \common\models\CompaniesCategories(['scenario' => 'create']);
            $model->setAttributes([
                'name' => $category['name'],
                'description' => null,
                'left' => $category['left'],
                'right' => $category['right'],
                'depth' => $category['depth'],
                'id_portal' => $idPortal
            ]);

            if(!$model->save()) {
                $this->stderr('Blad podczas zapisu');
                $transaction->rollBack();
                return ExitCode::CANTCREAT;
            }
        }
        
//        $transaction->rollBack();
        $transaction->commit();
        return ExitCode::OK;
    }
    
    protected function convertArrayToNestedSetV2($data, $depth, $previousLeft = 0)
    {
        $depth = $depth + 1;

        $element = []; 
        $element['depth'] = $depth;
        $element['name'] = $data['name'];
        $element['left'] = $previousLeft + 1;

        $lastRight = $element['left'];
        $i = 0;
        if(!empty($data['children']))
        {
            foreach($data['children'] as $a_child)
            {
                $lastRight = $this->convertArrayToNestedSetV2($data['children'][$i], $depth, $lastRight);
                $i++;
            }
        }
        
        $element['right'] = $lastRight + 1; 
        array_push($this->tree, $element); 
        return $element['right'];      
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com