Devil Killer Is Here MiNi Shell
MiNi SheLL

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

use Yii;
use yii\web\Controller;
use yii\helpers\ArrayHelper;
use yii\data\ActiveDataProvider;
use common\components\helpers\Image2;
use common\models\BookstoreShippingCarts;
use common\models\Books;
use common\models\BooksSubscriptions;
use common\models\types\BookStatus;
use frontend\models\BookstoreOrderForm;

/**
 * Koszyk księgarni controller
 */
class KsiegarniakoszykController extends Controller
{
    use \frontend\components\traits\SeoFunctions;
    use \frontend\components\traits\UsersDataFunctions;
    
    protected $modelBookstoreShippingCart;
    protected $outputData;
    
    /**
     * @inheritdoc
     */
    public function actions()
    {
        return [
            'error' => [
                'class' => 'yii\web\ErrorAction',
            ],
            'captcha' => [
                'class' => 'yii\captcha\CaptchaAction',
//                'fixedVerifyCode' => 'dupa123'
            ],
            'pobierz-lokalizacje-punktow-odbioru' => [
                'class' => '\common\components\controllers\actions\GetPickupPointsLocationsAction'
            ],
            'wybierz-punkt-odbioru' => [
                'class' => '\common\components\controllers\actions\SelectPickupPointAction',
                'urlForGettingLocations' => \yii\helpers\Url::to(['ksiegarniakoszyk/pobierz-lokalizacje-punktow-odbioru'])
            ]
        ];
    }

    public function actionIndex()
    {
//        $modelOrder = \common\models\BookstoreOrders::findOne(2);
//        $this->sendMailsAboutOrder($modelOrder);
//        exit;
        
        /*
         * ###TODO:MARCIN###
         * Odblokuj to sobie lokalnie, a przed commitem zablokuj.
         */
//        exit;
        
//        $this->readBookstoreShippingCart();
//        $this->deleteItem(6, false);
//        $this->modelBookstoreShippingCart->save();
        
        $modelPortal = Yii::$app->params['modelPortal'];
        
        return $this->render('index', [
            
        ]);
    }   
    
    public function actionZawartosc()
    {
        /*
         * ###TODO:MARCIN###
         * Odblokuj to sobie lokalnie, a przed commitem zablokuj.
         */
//        exit;
        
//        $unpaidBookstoreOrders[date('Y-m-d H:i:s')] = [2];      
//        Yii::$app->session->set('unpaid_bookstore_orders', $unpaidBookstoreOrders);
//        exit;
        
        $this->readBookstoreShippingCart();
        $this->outputData['status'] = true;
        
        $modelPortal = Yii::$app->params['modelPortal'];
        
        if(Yii::$app->request->get('ids_orders_for_set_as_paid')) {
            $idsOrdersForSetAsPaid = array_map('intval', explode('|', Yii::$app->request->get('ids_orders_for_set_as_paid')));
            if(Yii::$app->session->has('unpaid_bookstore_orders')) {
                $unpaidBookstoreOrdersBatches = Yii::$app->session->get('unpaid_bookstore_orders');
                foreach($unpaidBookstoreOrdersBatches as $key1 => $unpaidBookstoreOrdersBatch) {
                    foreach($unpaidBookstoreOrdersBatch as $key2 => $idUnpaidBookstoreOrder) {
                        if(in_array(intval($idUnpaidBookstoreOrder), $idsOrdersForSetAsPaid)) {
                            unset($unpaidBookstoreOrdersBatches[$key1][$key2]);
                        }
                    }
                    if(empty($unpaidBookstoreOrdersBatches[$key1])) {
                        unset($unpaidBookstoreOrdersBatches[$key1]);
                    }
                }
                Yii::$app->session->set('unpaid_bookstore_orders', $unpaidBookstoreOrdersBatches);
            }
            return $this->redirect(['zawartosc']);
        }
        
        $results = $this->getPriceListsAndItemsData();
        $modelsCompanies = !empty($results['idsCompanies']) ? \common\models\Companies::find()->where(['id_company' => $results['idsCompanies']])->indexBy('id_company')->all() : [];
//        var_dump($results);        
//        exit;
        
        return $this->render('cart', [
            'data' => $this->outputData,
            
            'modelsCompanies' => $modelsCompanies,
            'itemsByCompanies' => $results['itemsByCompanies'],
            'itemsSubscriptionsByCompanies' => $results['itemsSubscriptionsByCompanies'],
            'priceListsForCompanies' => $results['priceListsForCompanies']
        ]);
    }  
    
    public function actionZamowBezRejestracji()
    {
        if(!Yii::$app->user->isGuest) {
            $this->redirect('zamow');
        }        
        
        $this->readBookstoreShippingCart();
        
        if(empty($this->outputData['items']) && empty($this->outputData['items_subscriptions'])) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Brak danych niezbędnych do wykonania akcji.'));
            return $this->redirect(['zawartosc']);
        }
        
        $this->outputData['status'] = true;
        
        $modelPortal = Yii::$app->params['modelPortal']; 
                
        $modelForm = new BookstoreOrderForm(['scenario' => 'createWithoutRegistration', 'id_user' => null, 'id_portal' => $modelPortal->id_portal]);
//        $modelForm->captcha = 'dupa123';
        $modelForm->shipping_id_country = 'PL';
        $modelForm->invoicing_id_country = 'PL';     
        $modelForm->or_company = 0;
        
        $results = $this->getPriceListsAndItemsData();
        
        $modelsCompanies = !empty($results['idsCompanies']) ? \common\models\Companies::find()->where(['id_company' => $results['idsCompanies']])->all() : [];

        $modelsOrdersDeliveries = [];
        foreach($modelsCompanies as $modelCompany) {
            if(empty($results['priceListsForCompanies'][$modelCompany->id_company])) {
                continue;
            }
            $modelsOrdersDeliveries[$modelCompany->id_company] = new \common\models\BookstoreOrderDeliveryForm(['deliveryOptions' => $results['priceListsForCompanies'][$modelCompany->id_company]]);
        }
        
        $outputParams = [
            'cartData' => $this->outputData,
            'modelForm' => $modelForm,
            'modelsCompanies' => $modelsCompanies,
            'priceListsForCompanies' => !empty($results['priceListsForCompanies']) ? $results['priceListsForCompanies'] : [],
            'itemsByCompanies' => !empty($results['itemsByCompanies']) ? $results['itemsByCompanies'] : [],
            'itemsSubscriptionsByCompanies' => !empty($results['itemsSubscriptionsByCompanies']) ? $results['itemsSubscriptionsByCompanies'] : [],
            'modelsOrdersDeliveries' => $modelsOrdersDeliveries
        ];
        
        if (Yii::$app->request->isAjax) {
            $postData = Yii::$app->request->post();
            unset($postData['BookstoreOrderForm']['captcha']);
            if($modelForm->load($postData) && (empty($modelsOrdersDeliveries) || \yii\base\Model::loadMultiple($modelsOrdersDeliveries, $postData))) {
                Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
                return array_merge(\yii\bootstrap\ActiveForm::validate($modelForm, ['shipping_id_country', 'invoicing_id_country']), !empty($modelsOrdersDeliveries) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsOrdersDeliveries, ['deliveryOption', 'deliveryMethod', 'pickupPointCode', 'pickupPointAddress', 'messageForDealer']) : []);
            }
        }
        
        if(Yii::$app->request->getIsPost()) {
//            var_dump($_POST);
//            exit;
            
            if(!$modelForm->load(Yii::$app->request->post()) || (!empty($modelsOrdersDeliveries) && !\yii\base\Model::loadMultiple($modelsOrdersDeliveries, Yii::$app->request->post()))) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->redirect(['zamow-bez-rejestracji']);
            }            
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Formularz zawiera błędy.'));
                return $this->render('order_without_registration', $outputParams);
            }
            
            if(!empty($modelsOrdersDeliveries) && !\yii\base\Model::validateMultiple($modelsOrdersDeliveries)) {
                $errorsFromModelsOrdersDeliveries = [];
                if(!empty($modelsOrdersDeliveries)) {
                    foreach($modelsOrdersDeliveries as $modelOrderDelivery) {
                        if($modelOrderDelivery->hasErrors()) {
                            foreach($modelOrderDelivery->getErrors() as $error) {
                                $errorsFromModelsOrdersDeliveries[] = $error;
                            }
                        }
                    }
                }
                Yii::$app->session->addFlash('error', $errorsFromModelsOrdersDeliveries);
                return $this->render('order_without_registration', $outputParams);
            }
            
            $modelForm->setItems($outputParams['itemsByCompanies'], $outputParams['itemsSubscriptionsByCompanies']);
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $modelsOrders = $modelForm->save();
            
            $flag = $modelsOrders === false ? false : true;
            
            $ordersForOnlinePayment = [];
            if($flag) {
                foreach($modelsOrders as $idCompany => $modelOrder) {
                    if(!isset($modelsOrdersDeliveries[$idCompany])) {
                        continue;
                    }
                    $modelsOrdersDeliveries[$idCompany]->setModelOrder($modelOrder);
                    if($modelsOrdersDeliveries[$idCompany]->save() !== true) {
                        $flag = false;
                        break;
                    }
                    if(!empty($modelOrder->delivery_method) && intval($modelOrder->or_cash_on_delivery) === 0 && !empty($modelOrder->dealerCompany->getSettingsKey('przelewy24_id'))) {
                        $ordersForOnlinePayment[] = $modelOrder->id_order;
                    } 
                }
            }
            
            //@todo proteza
            if($flag) {
                $this->modelBookstoreShippingCart->clearAll();
                $flag = $this->modelBookstoreShippingCart->save();
            }
            
            if($flag && !empty($ordersForOnlinePayment) && Yii::$app->user->isGuest) {
                $unpaidBookstoreOrders = Yii::$app->session->has('unpaid_bookstore_orders') ? Yii::$app->session->get('unpaid_bookstore_orders') : [];
                $unpaidBookstoreOrders[date('Y-m-d H:i:s')] = $ordersForOnlinePayment;      
                Yii::$app->session->set('unpaid_bookstore_orders', $unpaidBookstoreOrders);
            }
            
            if($flag) { 
                $transaction->commit();
                foreach($modelsOrders as $modelOrder) {
                    $model = \common\models\BookstoreOrders::findOne($modelOrder->id_order);
                    $this->sendMailsAboutOrder($model);
                }
//                $transaction->rollBack();
//                exit;
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Zamówienie zostało wysłane.'));                 
                return $this->redirect([!empty($ordersForOnlinePayment) ? 'zaplac' : 'wyslane']);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
            }
        }        
        
        return $this->render('order_without_registration', $outputParams);
    }
    
    public function actionZamowKopia()
    {
        
        return $this->render('order_kopia', [
            
        ]);
    } 
    
    public function actionZaplacone()
    {
        
        return $this->render('pay_info', [
            
        ]);
    } 
    
    public function actionWyslane()
    {
        
        return $this->render('nopay_info', [
            
        ]);
    } 
    
    public function actionZamow()
    {
        if(Yii::$app->user->isGuest) {
            $this->layout = 'vmanager';
            return $this->render('//shared/do_you_have_account', [
                'header' => 'Zamówienie w księgarni - '.Yii::t('frontend', 'Zaloguj się'),
                'content' => 'Tutaj trzeba machnąć tekst odnośnie składania zamówień w księgarni systemu vManager.',
                'title' => 'vManager - księgarnia',
                'withoutRegistrationUrl' => \yii\helpers\Url::to(['ksiegarniakoszyk/zamow-bez-rejestracji']),
                'breadcrumbs' => [
                    ['label' => Yii::t('frontend', 'Księgarnia'), 'url' => ['ksiegarnia/index']],
                    ['label' => Yii::t('frontend', 'Koszyk'), 'url' => ['ksiegarniakoszyk/zawartosc']],
                    Yii::t('frontend', 'Zamówienie')
                ]
            ]);
        }
        
        $this->readBookstoreShippingCart();
        
        if(empty($this->outputData['items']) && empty($this->outputData['items_subscriptions'])) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Brak danych niezbędnych do wykonania akcji.'));
            return $this->redirect(['zawartosc']);
        }
        
        $this->outputData['status'] = true;
        
        $modelPortal = Yii::$app->params['modelPortal'];
                
        $modelUser = Yii::$app->user->getIdentity(); 
        $userCompanies = ArrayHelper::map($modelUser->getCompanies()->select(['id_company', 'name'])->where(['status' => \common\models\types\Status::ACTIVE])->asArray()->all(), 'id_company', 'name');
        
        $dataForShipping = $modelUser->getShoppingAddressBook()->orderBy('or_main DESC, locality ASC')->all();
        $dataToAccount = $modelUser->getShoppingDataToAccount()->orderBy('or_main DESC, name ASC')->all();
        
        if(empty($dataForShipping) || empty($dataToAccount)) {
            //jeśli nie mamy żadnych danych na potrzeby zakupów, to próbujemy je wygenerować
            if(empty($dataForShipping)) {
                //tutaj pobrać dane jakie mamy i wpisać do książki adresowej
                $result = $this->tryCreateShoppingAddressBookFromExistData($modelUser);
                if(!empty($result)) {
                    $dataForShipping = $modelUser->getShoppingAddressBook()->orderBy('or_main DESC, locality ASC')->all();
                }                
            }
            if(empty($dataToAccount)) {
                //tutaj pobrać dane jakie mamy i wpisać do zestawu danych do rozliczeń
                $result = $this->tryCreateShoppingDataToAccountFromExistData($modelUser);
                if(!empty($result)) {
                    $dataToAccount = $modelUser->getShoppingDataToAccount()->orderBy('or_main DESC, name ASC')->all();
                }
            }
        }
                
        $modelForm = new BookstoreOrderForm(['scenario' => 'create', 'id_user' => !empty($modelUser) ? $modelUser->id_user : null, 'id_portal' => $modelPortal->id_portal]);        
//        $modelForm->captcha = 'dupa123';
        $modelForm->invoicing_id_country = 'PL';
        
        if(!empty($dataForShipping)) {
            $dataForShippingForUser = [];
            $dataForShippingForCompany = [];            
            foreach($dataForShipping as $data) {
                if(empty($dataForShippingForUser) && empty($data['id_company'])) {
                    $dataForShippingForUser = $data;
                }
                if(empty($dataForShippingForCompany) && !empty($data['id_company'])) {
                    $dataForShippingForCompany = $data;
                }
            }
            
            $data = [];
            if($modelUser->profile === \common\models\types\UserProfile::COMPANY && !empty($dataForShippingForCompany)) {
                $modelForm->or_company = 1;            
                $data = $dataForShippingForCompany;
            } elseif(!empty($dataForShippingForUser)) {
                $modelForm->or_company = 0; 
                $data = $dataForShippingForUser;
            }
            
            if(!empty($data)) {
                $modelForm->forename = $data['forename'];
                $modelForm->surname = $data['surname'];
                $modelForm->email = $data['email'];
                $modelForm->phone = $data['phone'];  
                $modelForm->email = $data['email'];
                $modelForm->phone = $data['phone'];
                $modelForm->shipping_company_name = $data['company_name'];
                $modelForm->shipping_id_country = $data['id_country'];
                $modelForm->shipping_locality = $data['locality'];
                $modelForm->shipping_postcode = $data['postcode'];
                $modelForm->shipping_street = $data['street'];
                $modelForm->shipping_building_number = $data['building_number'];
                $modelForm->shipping_apartment_number = $data['apartment_number'];
                $modelForm->shipping_address_cont = $data['address_cont'];
            }
        }
        
        if(!empty($dataToAccount)) {
            $dataToAccountForUser = [];
            $dataToAccountForCompany = [];            
            foreach($dataToAccount as $data) {
                if(empty($dataToAccountForUser) && empty($data['id_company'])) {
                    $dataToAccountForUser = $data;
                }
                if(empty($dataToAccountForCompany) && !empty($data['id_company'])) {
                    $dataToAccountForCompany = $data;
                }
            }
            
            $data = [];
            if($modelForm->or_company !== 0 && $modelUser->profile === \common\models\types\UserProfile::COMPANY && !empty($dataToAccountForCompany)) {
                $modelForm->or_company = 1;            
                $data = $dataToAccountForCompany;
            } elseif(!empty($dataToAccountForUser)) {
                $modelForm->or_company = 0; 
                $data = $dataToAccountForUser;
            }
            
            if(!empty($data)) {
                $modelForm->or_invoice = 1;                
                if(empty($modelForm->id_company)) {
                    $modelForm->id_company = $data['id_company'];
                }
                $modelForm->invoicing_name = $data['name'];
                $modelForm->invoicing_tax_id = $data['tax_id'];
                $modelForm->invoicing_id_country = $data['id_country'];
                $modelForm->invoicing_locality = $data['locality'];
                $modelForm->invoicing_postcode = $data['postcode'];
                $modelForm->invoicing_street = $data['street'];
                $modelForm->invoicing_building_number = $data['building_number'];
                $modelForm->invoicing_apartment_number = $data['apartment_number'];
            }
        }    
        
        $results = $this->getPriceListsAndItemsData();
        
        $modelsCompanies = !empty($results['idsCompanies']) ? \common\models\Companies::find()->where(['id_company' => $results['idsCompanies']])->all() : [];

        $modelsOrdersDeliveries = [];
        foreach($modelsCompanies as $modelCompany) {
            if(empty($results['priceListsForCompanies'][$modelCompany->id_company])) {
                continue;
            }
            $modelsOrdersDeliveries[$modelCompany->id_company] = new \common\models\BookstoreOrderDeliveryForm(['deliveryOptions' => $results['priceListsForCompanies'][$modelCompany->id_company]]);
        }
        
        $outputParams = [
            'userCompanies' => $userCompanies,
            'cartData' => $this->outputData,
            'modelForm' => $modelForm,
            'modelsCompanies' => $modelsCompanies,
            'priceListsForCompanies' => !empty($results['priceListsForCompanies']) ? $results['priceListsForCompanies'] : [],
            'itemsByCompanies' => !empty($results['itemsByCompanies']) ? $results['itemsByCompanies'] : [],
            'itemsSubscriptionsByCompanies' => !empty($results['itemsSubscriptionsByCompanies']) ? $results['itemsSubscriptionsByCompanies'] : [],
            'modelsOrdersDeliveries' => $modelsOrdersDeliveries
        ];
        
        if(Yii::$app->request->getIsPost()) {
            $postData = Yii::$app->request->post();
            if(!isset($postData['BookstoreOrderForm']['or_invoice'])) {
                $postData['BookstoreOrderForm']['or_invoice'] = 0;
            }
        }
        
        if (Yii::$app->request->isAjax) {
            unset($postData['BookstoreOrderForm']['captcha']);
            if($modelForm->load($postData) && (empty($modelsOrdersDeliveries) || \yii\base\Model::loadMultiple($modelsOrdersDeliveries, $postData))) {
                Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
                return array_merge(\yii\bootstrap\ActiveForm::validate($modelForm, ['id_company', 'shipping_id_country', 'invoicing_id_country']), !empty($modelsOrdersDeliveries) ? \yii\bootstrap\ActiveForm::validateMultiple($modelsOrdersDeliveries, ['deliveryOption', 'deliveryMethod', 'pickupPointCode', 'pickupPointAddress', 'messageForDealer']) : []);
            }
        }
        
        if(Yii::$app->request->getIsPost()) {
//            var_dump($_POST);
//            exit;
            
            if(!$modelForm->load($postData) || (!empty($modelsOrdersDeliveries) && !\yii\base\Model::loadMultiple($modelsOrdersDeliveries, $postData))) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->redirect(['zamow']);
            }            
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', Yii::t('frontend', 'Formularz zawiera błędy.'));                
                return $this->render('order', $outputParams);
            }
            
            if(!empty($modelsOrdersDeliveries) && !\yii\base\Model::validateMultiple($modelsOrdersDeliveries)) {
                $errorsFromModelsOrdersDeliveries = [];
                if(!empty($modelsOrdersDeliveries)) {
                    foreach($modelsOrdersDeliveries as $modelOrderDelivery) {
                        if($modelOrderDelivery->hasErrors()) {
                            foreach($modelOrderDelivery->getErrors() as $error) {
                                $errorsFromModelsOrdersDeliveries[] = $error[0];
                            }
                        }
                    }
                }
                Yii::$app->session->addFlash('error', $errorsFromModelsOrdersDeliveries);
                return $this->render('order', $outputParams);
            }
            
            $modelForm->setItems($outputParams['itemsByCompanies'], $outputParams['itemsSubscriptionsByCompanies']);
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $modelsOrders = $modelForm->save();
            
            $flag = $modelsOrders === false ? false : true;
//            $transaction->rollBack();
//            var_dump($flag);
//            exit;
            
            $ordersForOnlinePayment = [];
            if($flag) {
                foreach($modelsOrders as $idCompany => $modelOrder) {
                    if(!isset($modelsOrdersDeliveries[$idCompany])) {
                        continue;
                    }
                    $modelsOrdersDeliveries[$idCompany]->setModelOrder($modelOrder);
                    if($modelsOrdersDeliveries[$idCompany]->save() !== true) {
                        $flag = false;
                        break;
                    }
                    if(!empty($modelOrder->delivery_method) && intval($modelOrder->or_cash_on_delivery) === 0 && !empty($modelOrder->dealerCompany->getSettingsKey('przelewy24_id'))) {
                        $ordersForOnlinePayment[] = $modelOrder->id_order;
                    } 
                }
            }
            
            //@todo proteza
            if($flag) {
                $this->modelBookstoreShippingCart->clearAll();
                $flag = $this->modelBookstoreShippingCart->save();
            }
            
            if($flag && !empty($ordersForOnlinePayment) && Yii::$app->user->isGuest) {
                $unpaidBookstoreOrders = Yii::$app->session->has('unpaid_bookstore_orders') ? Yii::$app->session->get('unpaid_bookstore_orders') : [];
                $unpaidBookstoreOrders[date('Y-m-d H:i:s')] = $ordersForOnlinePayment;      
                Yii::$app->session->set('unpaid_bookstore_orders', $unpaidBookstoreOrders);
            }
            
            if($flag) { 
                $transaction->commit();
                foreach($modelsOrders as $modelOrder) {
                    $model = \common\models\BookstoreOrders::findOne($modelOrder->id_order);
                    $this->sendMailsAboutOrder($model);
                }
//                $transaction->rollBack();
//                exit;
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Zamówienie zostało wysłane.'));                 
                return $this->redirect([!empty($ordersForOnlinePayment) ? 'zaplac' : 'wyslane']);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));    
            }
        }
        
        
        return $this->render('order', $outputParams);
    }
    
    protected function sendMailsAboutOrder($modelOrder)
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $smtpSettings = $modelPortal->getSettingsKey('smtp_settings');
        if(empty($smtpSettings)) {
            $flag = false;
        }
        
        $dealerPhones = [];
        $dealerEmails = [];
        $dealerMainEmail = null;
        $contactDataFromDealerCompany = $modelOrder->dealerCompany->getContactData()
                ->select(['data_value', 'data_type'])
                ->where([
                    'data_type' => [\common\models\types\ContactDataType::EMAIL, \common\models\types\ContactDataType::PHONE, \common\models\types\ContactDataType::MOBILE_PHONE]
                ])
                ->orderBy('data_order ASC')
                ->asArray()
                ->all();
        if(!empty($contactDataFromDealerCompany)) {
            foreach($contactDataFromDealerCompany as $contactData) {
                if($contactData['data_type'] === \common\models\types\ContactDataType::EMAIL) {
                    $dealerEmails[$contactData['data_value']] = $contactData['data_value'];
                } else {
                    $dealerPhones[$contactData['data_value']] = $contactData['data_value'];
                }
            }
        }
        $contactDataFromDealerUser = $modelOrder->dealerCompany->user->getContactData()
                ->select(['data_value', 'data_type'])
                ->where([
                    'data_type' => [\common\models\types\ContactDataType::EMAIL, \common\models\types\ContactDataType::PHONE, \common\models\types\ContactDataType::MOBILE_PHONE],
                    'required' => 1,
                ])
                ->orderBy('data_order ASC')
                ->asArray()
                ->all();
        if(!empty($contactDataFromDealerUser)) {
            foreach($contactDataFromDealerUser as $contactData) {
                if($contactData['data_type'] === \common\models\types\ContactDataType::EMAIL) {
                    $dealerEmails[$contactData['data_value']] = $contactData['data_value'];
                    $dealerMainEmail = $contactData['data_value'];;
                } else {
                    $dealerPhones[$contactData['data_value']] = $contactData['data_value'];
                }
            }
        }
        $dealerPhones = array_values($dealerPhones);
        $dealerEmails = array_values($dealerEmails); 
        if(empty($dealerMainEmail) && !empty($dealerEmails[0])) {
            $dealerMainEmail = $dealerEmails[0];
        }
        
        $mailer = Yii::$app->mailer;
        $mailer->htmlLayout = 'layouts/main-html';      
        $mailer->textLayout = 'layouts/main-text'; 
        $mailer->transport = (new \Swift_SmtpTransport($smtpSettings['host'], $smtpSettings['port'], $smtpSettings['encryption']))
            ->setUsername($smtpSettings['username'])
            ->setPassword($smtpSettings['password']);
        
        //wysyłamy potwierdzenie zamówienia na adres e-mail składającego //(###MAIL_58###)
        $flag = $mailer->compose(
                [
                    'html' => 'order_book_confirm_purchaser_html',
                    'text' => 'order_book_confirm_purchaser_text'
                ],
                [
                    'modelOrder' => $modelOrder,
                    'dealerPhones' => $dealerPhones,
                    'dealerEmails' => $dealerEmails
                ]
            )
            ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
            ->setTo([$modelOrder->email => $modelOrder->forename.' '.$modelOrder->surname]) 
//            ->setTo(['r.sobieszczyk86@gmail.com'])
            ->setSubject(Yii::t('common-mails', 'Kupiłeś {n,plural,=1{przedmiot} =2{# przedmioty} =3{# przedmioty} =4{# przedmioty} other{# przedmiotów}} od sprzedawcy {company}', ['n' => count($modelOrder->items), 'company' => $modelOrder->dealer_name]))
            ->send();
//        var_dump('Wysyłka do zamawiającego ('.$modelOrder->email.') - '.($flag ? 'OK' : 'FAIL'));
        
        //wysyłamy potwierdzenie zamówienia na adres e-mail sprzedawcy //(###MAIL_53###)
        $itemsString = '';
        foreach($modelOrder->items as $modelItem) {
            $itemsString .= $modelItem->id_book.' - '.\yii\helpers\Html::encode($modelItem->title).', ';
        }
        $itemsString = rtrim($itemsString, ', ');
        $flag = $mailer->compose(
                [
                    'html' => 'order_book_confirm_dealer_html',
                    'text' => 'order_book_confirm_dealer_text'
                ],
                [
                    'modelOrder' => $modelOrder
                ]
            )
            ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
            ->setTo($dealerMainEmail) 
//            ->setTo('r.sobieszczyk86@gmail.com')
            ->setSubject(Yii::t('common-mails', 'Sprzedałeś {n,plural,=1{przedmiot} other{przedmioty}}: '.$itemsString, ['n' => count($modelOrder->items)]))
            ->send();
//        var_dump('Wysyłka do sprzedającego ('.$dealerMainEmail.') - '.($flag ? 'OK' : 'FAIL'));
        
        //wysyłamy potwierdzenie zamówienia na adres e-mail sprzedawcy //(###MAIL_54###)
        $flag = $mailer->compose(
                [
                    'html' => 'order_book_delivery_method_confirm_html',
                    'text' => 'order_book_delivery_method_confirm_text'
                ],
                [
                    'modelOrder' => $modelOrder
                ]
            )
            ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
            ->setTo($dealerMainEmail) 
//            ->setTo('r.sobieszczyk86@gmail.com')
            ->setSubject(Yii::t('common-mails', 'Kupujący {purchaser} wybrał sposób zapłaty i dostawy za zakupy w Twojej ofercie', ['purchaser' => $modelOrder->invoicing_name]))
            ->send();
//        var_dump('Wysyłka do sprzedającego o wyborze metody dostawy ('.$dealerMainEmail.') - '.($flag ? 'OK' : 'FAIL'));
        
        $adminEmail = \common\models\UsersContactData::find()
                ->select(['users_contact_data.data_value'])
                ->join('INNER JOIN', 'users', 'users.id_user = users_contact_data.id_user')
                ->where([
                    'users.login' => 'vm_lukasz',
                    'users_contact_data.required' => 1, 
                    'users_contact_data.data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->scalar();
        //wysyłamy potwierdzenie zamówienia na adres administratora (Łukasza) //(###MAIL_56###)
        $flag = $mailer->compose(
                [
                    'html' => 'order_book_confirm_admin_html',
                    'text' => 'order_book_confirm_admin_text'
                ],
                [
                    'modelOrder' => $modelOrder
                ]
            )
            ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
            ->setTo($adminEmail) 
//            ->setTo('r.sobieszczyk86@gmail.com')
            ->setSubject(Yii::t('common-mails', 'Partner {dealer} sprzedał przedmiot przez portal {domain}', ['dealer' => $modelOrder->dealer_name, 'domain' => $modelPortal->domain]))
            ->send();
//        var_dump('Wysyłka do Łukasza ('.$adminEmail.') - '.($flag ? 'OK' : 'FAIL'));
        
        if($modelOrder->or_cash_on_delivery === 1) {
            //wysyłamy do zamawiajacego informację o konieczności przygotowania gotówki dla kuriera - zamówienie za pobraniem //(###MAIL_60###)
            $flag = $mailer->compose(
                    [
                        'html' => 'order_book_cash_on_delivery_purchaser_html',
                        'text' => 'order_book_cash_on_delivery_purchaser_text'
                    ],
                    [
                        'modelOrder' => $modelOrder
                    ]
                )
                ->setFrom([$smtpSettings['username'] => $modelPortal->domain.' - system vManager'])
                ->setTo([$modelOrder->email => $modelOrder->forename.' '.$modelOrder->surname]) 
//                ->setTo(['r.sobieszczyk86@gmail.com'])
                ->setSubject(Yii::t('common-mails', 'Kupiłeś przedmiot – opłata za pobraniem'))
                ->send();
//            var_dump('Wysyłka do zamawiającego aby przygotował pieniądze na pobranie ('.$modelOrder->email.') - '.($flag ? 'OK' : 'FAIL'));
        }
    }
    
    public function actionZaplac()
    {
        if(Yii::$app->user->isGuest) {
            if(!Yii::$app->session->has('unpaid_bookstore_orders')) {
                return $this->redirect(['zawartosc']);
            } 
            $unfinishedBookstoreOrders = Yii::$app->session->get('unpaid_bookstore_orders');
            if(empty($unfinishedBookstoreOrders)) {
                return $this->redirect(['zawartosc']);
            }
            $whereParts = ['id_order' => array_map('intval', current($unfinishedBookstoreOrders))];
        } else {
            $firstUnfinishedOrder = \common\models\BookstoreOrders::find()
                ->select(['id_user', 'id_company', 'batch_uuid'])
                ->where(['id_user' => Yii::$app->user->id])
                ->andWhere(['status' => [\common\models\types\BookstoreOrderStatus::NEW_CREATED, \common\models\types\BookstoreOrderStatus::ACCEPTED]])
                ->andWhere(['not', ['delivery_method' => null]])
                ->andWhere(['or_cash_on_delivery' => 0])
                ->orderBy('id_order DESC')
                ->asArray()
                ->one();
            if(!empty($firstUnfinishedOrder['batch_uuid'])) {
                $whereParts = [
                    'batch_uuid' => $firstUnfinishedOrder['batch_uuid']
                ];
            } else {
                $whereParts = [
                    'id_user' => $firstUnfinishedOrder['id_user'],
                    'id_company' => $firstUnfinishedOrder['id_company']
                ];
            }
        }
        
        $modelsOrders = \common\models\BookstoreOrders::find()
                ->with(['dealerCompany'])
                ->where($whereParts)
                ->andWhere(['status' => [\common\models\types\BookstoreOrderStatus::NEW_CREATED, \common\models\types\BookstoreOrderStatus::ACCEPTED]])
                ->andWhere(['not', ['delivery_method' => null]])
                ->andWhere(['or_cash_on_delivery' => 0])
                ->indexBy('id_order')
                ->all();
        
        if(empty($modelsOrders)) {
            return $this->redirect(['zawartosc']);
        } 
        foreach($modelsOrders as $idOrder => $modelOrder) {
            $merchantId = $modelOrder->dealerCompany->getSettingsKey('przelewy24_id');
            if(empty($merchantId)) {
                unset($modelsOrders[$idOrder]);
            }
        }
        if(empty($modelsOrders)) {
            return $this->redirect(['zawartosc']);
        }
        
        $modelForm = new \common\models\BookstoreOrdersPaymentForm(['modelsOrders' => $modelsOrders]);
        $modelForm->listSelectedOrders = array_keys($modelsOrders);
        
        $outputParams = [
            'modelForm' => $modelForm
        ];
        
        if (Yii::$app->request->isAjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['listSelectedOrders']);
        }
        
        if(Yii::$app->request->getIsPost()) {
            if(!$modelForm->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('pay', $outputParams);
            } 
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->render('pay', $outputParams);
            }
            
            $p24 = Yii::$app->przelewy24New;
            
            $urlReturn = \yii\helpers\Url::to(['ksiegarniakoszyk/zaplacone', 'ids_orders_for_set_as_paid' => Yii::$app->user->isGuest ? implode('|', array_map('intval', array_values($modelForm->listSelectedOrders))) : null], true);
            $flag = $modelForm->fillTransactionData($p24, $urlReturn);
            if(!$flag) {
                list($errorCode, $errorMessage) = $p24->getError(false);
                Yii::$app->session->addFlash('error', $errorMessage);
                return $this->render('pay', $outputParams);
            }
            
            $token = $p24->registerTransaction(false);
            if($token === false) {
//                var_dump($p24->getError()); exit;
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas rejestrowania płatności.'));
                return $this->render('pay', $outputParams);
            }
            //@todo proteza
//            var_dump($token);exit;
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $modelForm->savePaymentDetails($token);    
//            var_dump($flag);
//            $transaction->rollBack();
//            exit;
            if(!$flag) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
                return $this->render('pay', $outputParams);
            }
            
            $transactionUrl = $p24->getTransactionRequestUrl($token);
            
            $transaction->commit();

            if(Yii::$app->session->has('unpaid_bookstore_orders')) {
                Yii::$app->session->remove('unpaid_bookstore_orders');
            }            
            
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Dziękujemy za zlecenie płatności. Oczekujemy na potwierdzenie Twojej płatności.')); 
            return $this->redirect($transactionUrl);
        }
        
        return $this->render('pay', $outputParams);
    }
    
    protected function readBookstoreShippingCart()
    {
        $idPortal = Yii::$app->params['modelPortal']->id_portal;
        $cookieNameForAll = 'bookstore_shipping_cart_p'.$idPortal;
        $cookieNameForUser = 'bookstore_shipping_cart_u'.Yii::$app->user->id.'_p'.$idPortal;
        
        if(!Yii::$app->user->isGuest) {
            $modelCartForUser = BookstoreShippingCarts::getShippingCart(Yii::$app->request->cookies->getValue($cookieNameForUser, null));
            if(empty($modelCartForUser)) {
                $modelCartForAll = BookstoreShippingCarts::getShippingCart(Yii::$app->request->cookies->getValue($cookieNameForAll, null));
                if(!empty($modelCartForAll)) {
                    $this->modelBookstoreShippingCart = $modelCartForAll;
                    Yii::$app->response->cookies->remove($cookieNameForAll);                    
                } else {
                    $this->modelBookstoreShippingCart = BookstoreShippingCarts::getShippingCart(null, Yii::$app->params['modelPortal']->id_portal);                     
                }
                Yii::$app->response->cookies->add(new \yii\web\Cookie([
                    'name' => $cookieNameForUser,
                    'value' => (string)$this->modelBookstoreShippingCart->_id
                ]));                
            } else {
                if(empty($modelCartForUser->items) && empty($modelCartForUser->items_subscriptions)) { 
                    $modelCartForAll = BookstoreShippingCarts::getShippingCart(Yii::$app->request->cookies->getValue($cookieNameForAll, null));
                    if(!empty($modelCartForAll) && (!empty($modelCartForAll->items) || !empty($modelCartForAll->items_subscriptions))) {
                        $this->modelBookstoreShippingCart = $modelCartForAll;
                        Yii::$app->response->cookies->remove($cookieNameForAll);  
                        Yii::$app->response->cookies->add(new \yii\web\Cookie([
                            'name' => $cookieNameForUser,
                            'value' => (string)$this->modelBookstoreShippingCart->_id
                        ]));
                    } else {
                        $this->modelBookstoreShippingCart = $modelCartForUser;
                    }
                } else {
                    $this->modelBookstoreShippingCart = $modelCartForUser;
                }
            } 
        } else {
            $idShippingCart = Yii::$app->request->cookies->getValue($cookieNameForAll, null);            
            $this->modelBookstoreShippingCart = BookstoreShippingCarts::getShippingCart($idShippingCart, $idPortal);        
            if($idShippingCart !== $this->modelBookstoreShippingCart->_id) {
                Yii::$app->response->cookies->add(new \yii\web\Cookie([
                    'name' => $cookieNameForAll,
                    'value' => (string)$this->modelBookstoreShippingCart->_id
                ]));
            }
        }

        $this->outputData = [
            'status' => false,
            'items' => $this->modelBookstoreShippingCart->items,
            'items_subscriptions' => $this->modelBookstoreShippingCart->items_subscriptions
        ];
    }
    
    public function actionAktualizuj()
    {
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $this->layout = false;
        
        $this->readBookstoreShippingCart();
        
        if(Yii::$app->request->getIsPost()) { 
            $action = Yii::$app->request->post('action');
            $item = Yii::$app->request->post('item');
            $orElectronic = Yii::$app->request->post('or_electronic');
            $quantity = Yii::$app->request->post('quantity');
            
            if(!in_array($action, ['add-item', 'delete-item', 'add-subscription', 'delete-subscription', 'clear-item', 'clear-subscription', 'clear-all'])) {
                return $this->outputData;
            }
            $methodName = lcfirst(str_replace(' ', '', ucwords(str_replace('-', ' ', $action))));
            
            if($action === 'add-item' || $action === 'add-subscription') {
                $flag = call_user_func([$this, $methodName], $item, $orElectronic ? true : false, intval($quantity) > 0 ? intval($quantity) : 1);
            } elseif($action === 'clear-all') {
                $flag = call_user_func([$this, $methodName]);
            }  else {
                $flag = call_user_func([$this, $methodName], $item, $orElectronic ? true : false);
            }            
            
            if($flag === false) {
                return $this->outputData;
            }
            if($this->modelBookstoreShippingCart->save()) {
                $this->outputData['status'] = true;
                switch($action) {
                    case 'add-item':
                    case 'delete-item':                        
                        $this->outputData['items'] = $this->modelBookstoreShippingCart->items;
                        break;
                    case 'add-subscription':
                    case 'delete-subscription':
                        $this->outputData['items_subscriptions'] = $this->modelBookstoreShippingCart->items_subscriptions;
                        break;
                    case 'clear-all':
                        $this->outputData['items'] = $this->modelBookstoreShippingCart->items;
                        $this->outputData['items_subscriptions'] = $this->modelBookstoreShippingCart->items_subscriptions;
                        break;                        
                }                       
            } else {
                $this->outputData['status'] = false;
            }
        }
        
        return $this->outputData;
    }  
    
    public function actionWczytaj()
    {
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $this->layout = false;
        
        $this->readBookstoreShippingCart();
        $this->outputData['status'] = true;
        
        return $this->outputData;
    } 
    
    protected function addItem($id, $orElectronic, $quantity)
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $query = Books::find()
                ->join('INNER JOIN', 'books_has_bookstore_categories', 'books_has_bookstore_categories.id_book = books.id_book')
                ->join('INNER JOIN', 'portals_has_bookstore_categories', 'portals_has_bookstore_categories.id_category = books_has_bookstore_categories.id_category')
                ->select(['books.id_book', 'books.title', 'books.author', 'books.image_filename', 'books.price_paper_version', 'books.price_electronic_version'])
                ->where([
                    'portals_has_bookstore_categories.id_portal' => $modelPortal->id_portal,
                    'books.id_book' => $id,
                    'books.status' => BookStatus::AVAILABLE,
                ]);
        
        if($orElectronic) {
            $query->andWhere(['books.or_electronic_version' => 1]);
        } else {
            $query->andWhere(['books.or_paper_version' => 1]);
        }
        
        $model = $query->one();

        if($model === null) {
            $this->outputData['status'] = true;
            return false;
        }
        
        $bookToAdd = [
            'id_book' => $model->id_book,
            'title' => $model->title,
            'author' => $model->author,
            'image_url' => !empty($model->image_filename) ? Yii::$app->params['commonBaseUrl'].'/'.Image2::getUrl($model->getImageUrl(), '200x250', Image2::OPERATION_FRAME, Books::getAcceptedSizes()) : null,
            'pcs' => intval($quantity) > 0 ? intval($quantity) : 1
        ];  
        
        if($orElectronic) {
            $bookToAdd['or_electronic_version'] = 1;
            $bookToAdd['price'] = $model->price_electronic_version;
        } else {
            $bookToAdd['or_electronic_version'] = 0;
            $bookToAdd['price'] = $model->price_paper_version;
        }

        $this->modelBookstoreShippingCart->addItem($bookToAdd);
        
        return true;
    }
    
    protected function deleteItem($id, $orElectronic)
    {        
        $this->modelBookstoreShippingCart->deleteItem($id, $orElectronic ? true : false);
        
        return true;
    }
    
    protected function clearItem($id, $orElectronic)
    {        
        $this->modelBookstoreShippingCart->deleteItem($id, $orElectronic ? true : false, true);
        
        return true;
    }
    
    protected function addSubscription($id, $orElectronic, $quantity)
    {
        $modelPortal = Yii::$app->params['modelPortal'];
        
        $query = BooksSubscriptions::find()
                ->join('INNER JOIN', 'books_has_books_subscriptions', 'books_has_books_subscriptions.id_subscription = books_subscriptions.id_subscription')
                ->join('INNER JOIN', 'books', 'books.id_book = books_has_books_subscriptions.id_book')
                ->join('INNER JOIN', 'books_has_bookstore_categories', 'books_has_bookstore_categories.id_book = books_has_books_subscriptions.id_book')
                ->join('INNER JOIN', 'portals_has_bookstore_categories', 'portals_has_bookstore_categories.id_category = books_has_bookstore_categories.id_category')
                ->select(['books_subscriptions.id_subscription', 'books_subscriptions.title', 'books_subscriptions.price_paper_version', 'books_subscriptions.price_electronic_version', 'books.id_book', 'books.image_filename'])
                ->where([
                    'portals_has_bookstore_categories.id_portal' => $modelPortal->id_portal,
                    'books_subscriptions.id_subscription' => $id,
                    'books.status' => BookStatus::AVAILABLE,
                ])->asArray();
        
        if($orElectronic) {
            $query->andWhere(['books_subscriptions.or_electronic_version' => 1]);
        } else {
            $query->andWhere(['books_subscriptions.or_paper_version' => 1]);
        }

        $bookSubscription = $query->one();
        if($bookSubscription === null) {
            $this->outputData['status'] = true;
            return false;
        }

        $subscriptionToAdd = [
            'id_subscription' => $bookSubscription['id_subscription'],
            'title' => $bookSubscription['title'],
            'pcs' => intval($quantity) > 0 ? intval($quantity) : 1
        ];
        
        if($orElectronic) {
            $subscriptionToAdd['or_electronic_version'] = 1;
            $subscriptionToAdd['price'] = $bookSubscription['price_electronic_version'];
        } else {
            $subscriptionToAdd['or_electronic_version'] = 0;
            $subscriptionToAdd['price'] = $bookSubscription['price_paper_version'];
        }
        
        if(!empty($bookSubscription['image_filename'])) {
            $subscriptionToAdd['image_url'] = Yii::$app->params['commonBaseUrl'].'/'.Image2::getUrl(Books::getImageUrlForBook($bookSubscription['image_filename'], $bookSubscription['id_book']), '200x250', Image2::OPERATION_FRAME, Books::getAcceptedSizes());
        } else {
            $subscriptionToAdd['image_url'] = null;
        }

        $this->modelBookstoreShippingCart->addSubscription($subscriptionToAdd);
        
        return true;
    }
    
    protected function deleteSubscription($id, $orElectronic)
    {        
        $this->modelBookstoreShippingCart->deleteSubscription($id, $orElectronic ? true : false);
        
        return true;
    }
    
    protected function clearSubscription($id, $orElectronic)
    {        
        $this->modelBookstoreShippingCart->deleteSubscription($id, $orElectronic ? true : false, true);
        
        return true;
    }
    
    protected function clearAll()
    {
        $this->modelBookstoreShippingCart->clearAll();
        
        return true;
    }
    
    protected function getPriceListsAndItemsData()
    {
        $outputData = $this->outputData;
        
        if(empty($outputData['items']) && empty($outputData['items_subscriptions'])) {
//            return [];
            return [
                'idsCompanies' => [],
                'priceListsForCompanies' => [],
                'itemsByCompanies' => [],
                'itemsSubscriptionsByCompanies' => []
            ];
        }
        
        $relationsCompaniesWithPriceLists = [];
        $idsCompanies = [];
        $idsCompaniesHavingBooksWithoutPriceLists = [];
        $booksOwners = $booksSubscriptionsOwners = [];
        $itemsByCompanies = $itemsSubscriptionsByCompanies = [];
        if(!empty($outputData['items'])) {
            $books = \common\models\Books::find()
                    ->select(['id_book', 'id_company', 'id_delivery_price_list'])
                    ->where(['id_book' => array_column($outputData['items'], 'id_book')])
                    ->asArray()
                    ->all();
            if(!empty($books)) {
                foreach($books as $book) {
                    $idsCompanies[$book['id_company']] = $book['id_company'];                    
                    $booksOwners[$book['id_book']] = $book['id_company'];
                    if(!empty($book['id_delivery_price_list'])) {
                        $relationsCompaniesWithPriceLists[$book['id_company']][$book['id_delivery_price_list']] = $book['id_delivery_price_list'];
                    } else {
                        $idsCompaniesHavingBooksWithoutPriceLists[$book['id_company']] = $book['id_company']; 
                    }
                }      
            }
            foreach($outputData['items'] as $item) {
                $idCompany = $booksOwners[$item['id_book']];
                $itemsByCompanies[$idCompany][] = $item;
            }
        }
        if(!empty($outputData['items_subscriptions'])) {
            $booksSubscriptions = \common\models\BooksSubscriptions::find()
                    ->select(['id_subscription', 'id_company', 'id_delivery_price_list'])
                    ->where(['id_subscription' => array_column($outputData['items_subscriptions'], 'id_subscription')])
                    ->asArray()
                    ->all();
            if(!empty($booksSubscriptions)) {
                foreach($booksSubscriptions as $bookSubscription) {
                    $idsCompanies[$bookSubscription['id_company']] = $bookSubscription['id_company'];                    
                    $booksSubscriptionsOwners[$bookSubscription['id_subscription']] = $bookSubscription['id_company'];
                    if(!empty($bookSubscription['id_delivery_price_list'])) {
                        $relationsCompaniesWithPriceLists[$bookSubscription['id_company']][$bookSubscription['id_delivery_price_list']] = $bookSubscription['id_delivery_price_list'];
                    } else {
                        $idsCompaniesHavingBooksWithoutPriceLists[$bookSubscription['id_company']] = $bookSubscription['id_company']; 
                    }
                }                
            }
            foreach($outputData['items_subscriptions'] as $item) {
                $idCompany = $booksSubscriptionsOwners[$item['id_subscription']];
                $itemsSubscriptionsByCompanies[$idCompany][] = $item;
            }
        }

        $priceListsForCompanies = [];
        foreach($idsCompanies as $idCompany) {
            if(isset($idsCompaniesHavingBooksWithoutPriceLists[$idCompany])) {
                //któraś z wybranych pozycji danej firmy nie ma przypisanego cennika
                $priceListsForCompanies[$idCompany] = [];
                continue;
            }
            
            if(empty($relationsCompaniesWithPriceLists[$idCompany])) {
                //nie ma żadnego cennika dla wybranych pozycji danej firmy
                $priceListsForCompanies[$idCompany] = [];
                continue;
            }
            
            $orExistsAnyPaperVersion = false;        
            $quantity = 0;
            if(!empty($itemsByCompanies[$idCompany])) {
                foreach($itemsByCompanies[$idCompany] as $item) {
                    if(!$item['or_electronic_version']) {
                        $orExistsAnyPaperVersion = true;
                        $quantity += $item['pcs'];
                    }
                }
            }
            if(!empty($itemsSubscriptionsByCompanies[$idCompany])) {
                foreach($itemsSubscriptionsByCompanies[$idCompany] as $item) {
                    if(!$item['or_electronic_version']) {
                        $orExistsAnyPaperVersion = true;
                        $quantity += $item['pcs'];
                    }
                }
            }
            
            $idsPriceListsForCompany = array_unique(array_values($relationsCompaniesWithPriceLists[$idCompany]));
            $modelsPriceListsItems = \common\models\CompaniesDeliveryPriceListsItems::find()
                    ->where(['id_price_list' => $idsPriceListsForCompany])
                    ->all();
            $priceListsItems = [];
            $idsPriceListFromItems = [];
            foreach($modelsPriceListsItems as $modelPriceListItem) {
                $checksum = $modelPriceListItem->generateChecksum(); 
                $priceListsItems[$modelPriceListItem->id_price_list][$checksum] = $modelPriceListItem->toArray(); 
                $idsPriceListFromItems[$modelPriceListItem->id_price_list] = $modelPriceListItem->id_price_list;
            }
            unset($modelsPriceListsItems);
            $idsPriceListFromItems = array_values($idsPriceListFromItems);
            if(!empty(array_diff($idsPriceListsForCompany, $idsPriceListFromItems))) {
                //któryś z cenników przypisanych do jakiejś książki nie posiada żadnych elementów
                $priceListsForCompanies[$idCompany] = [];
                continue;
            }

            $finalPriceListItems = [];
            if(count($priceListsItems) === 1) {
                //wszystkie książki mają przypisany ten sam cennik dostawy (bądź któraś nie ma żadnego)
                $finalPriceListItems = reset($priceListsItems);
            } else {
                //książki mają różne cenniki dostawy, więc musimy wyłonić wspólne metody dostawy
                $finalPriceListItems = call_user_func_array('array_intersect_key', $priceListsItems);
                var_dump($priceListsItems); exit;
            }
            
            if(empty($finalPriceListItems)) {
                //nie udało się wybrać żadnej zgodnej formy dostawy dla wybranych pozycji danej firmy
                $priceListsForCompanies[$idCompany] = [];
                continue;
            }

            $orFitInOnePackage = false; 
            $electronicDeliveryItems = [];
            foreach($finalPriceListItems as $key => $item) {
                if($item['maximum_number_of_pieces'] > $quantity) {
                    $orFitInOnePackage = true;
                }
                if($item['delivery_method'] === \common\models\types\DeliveryMethod::ELECTRONIC_DELIVERY) {
                    $electronicDeliveryItems[$key] = $item;
                }
            }

            $finalPriceList = [];

            if(!$orExistsAnyPaperVersion && !empty($electronicDeliveryItems)) {
                foreach($electronicDeliveryItems as $key => $item) {
                    $finalPriceList[$key] = [
                        'method' => $item['delivery_method'],
                        'amount' => 1 * $item['first_piece_price'] + (($quantity-1) * $item['next_piece_price']),
                        'time' => $item['minimum_delivery_time'].' - '.$item['maximum_delivery_time'],
                        'or_cash_on_delivery' => $item['or_cash_on_delivery'],
                        'number_of_pieces' => 1
                    ];
                }            
            } elseif($orFitInOnePackage) {
                foreach($finalPriceListItems as $key => $item) {
                    if($item['maximum_number_of_pieces'] < $quantity) {
                        continue;
                    }
                    if($orExistsAnyPaperVersion && $item['delivery_method'] === \common\models\types\DeliveryMethod::ELECTRONIC_DELIVERY) {
                        continue;
                    }

                    $deliveryAmount = 1 * $item['first_piece_price'] + (($quantity-1) * $item['next_piece_price']);

                    $finalPriceList[$key] = [
                        'method' => $item['delivery_method'],
                        'amount' => $deliveryAmount,
                        'time' => $item['minimum_delivery_time'].' - '.$item['maximum_delivery_time'],
                        'or_cash_on_delivery' => $item['or_cash_on_delivery'],
                        'number_of_pieces' => 1
                    ];
                }
            } else {
                foreach($finalPriceListItems as $key => $item) {
                    $quantityTemp = $quantity;
                    $numberOfPieces = 0;
                    $deliveryAmount = 0;
                    while($quantityTemp > 0) {
                        $quantityPart = $quantityTemp > $item['maximum_number_of_pieces'] ? $item['maximum_number_of_pieces'] : $quantityTemp;
                        $deliveryAmount += 1 * $item['first_piece_price'] + (($quantityPart-1) * $item['next_piece_price']);
                        $quantityTemp -= $quantityPart;
                        $numberOfPieces++;
                    }

                    $finalPriceList[$key] = [
                        'method' => $item['delivery_method'],
                        'amount' => $deliveryAmount,
                        'time' => $item['minimum_delivery_time'].' - '.$item['maximum_delivery_time'],
                        'or_cash_on_delivery' => $item['or_cash_on_delivery'],
                        'number_of_pieces' => $numberOfPieces
                    ];
                }
            }
            
            $priceListsForCompanies[$idCompany] = $finalPriceList;
        }
        
        return [
            'idsCompanies' => $idsCompanies,
            'priceListsForCompanies' => $priceListsForCompanies,
            'itemsByCompanies' => $itemsByCompanies,
            'itemsSubscriptionsByCompanies' => $itemsSubscriptionsByCompanies
        ];
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com