Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/backend/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/backend/controllers/OrdersController.php
<?php

namespace backend\controllers;

use Yii;
use common\models\Companies;
use common\models\CompaniesEmployees;
use common\models\Users;
use backend\models\CompaniesOrders;
use backend\models\CompaniesOrdersItems;
use common\models\Services;
use common\models\ServicesTypes;
use common\models\CurrencyRates;
use backend\models\CompaniesOrdersSearch;
use backend\models\CompaniesOrdersItemsSearch;
use backend\models\OrderItemFactory;
use backend\models\SendCumulativeInfoAboutCompaniesPaymentsForm;
use common\models\types\ContactDataType;
use common\models\types\UserProfile;
use common\models\types\Status;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;
use yii\filters\VerbFilter;
use yii\web\Response;
use yii\bootstrap\ActiveForm;

/**
 * OrdersController implements the CRUD actions for CompaniesOrders model.
 */
class OrdersController extends Controller
{
    use \backend\components\traits\ControllerFunctions;

    /**
     * Lists all CompaniesOrders models.
     * @return mixed
     */
    public function actionIndex()
    {        
        $queryParams = Yii::$app->request->queryParams;        
        
        if(Yii::$app->user->can('indexCompaniesOrders')) {
            
        } elseif(Yii::$app->user->can('indexAssignedCompaniesOrders')) {
            $queryParams['CompaniesOrdersSearch']['id_user'] = Yii::$app->user->id;           
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new CompaniesOrdersSearch();
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider            
        ]);
    }

    /**
     * Displays a single CompaniesOrders model.
     * @param integer $id
     * @return mixed
     */
    //@todo chyba do usunięcia
//    public function actionView($id)
//    {
//        $model = $this->findModel($id);
//        
//        if(!Yii::$app->user->can('viewCompaniesOrders', ['model' => $model])) {
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
//        
//        $dataProviderItems = new \yii\data\ActiveDataProvider([
//            'query' => $model->getItems()->with('user')->orderBy('id_item'),
//            'pagination' => false,
//            'sort' => false
//        ]);
//        
//        return $this->render('view', [
//            'model' => $model,
//            'dataProviderItems' => $dataProviderItems
//        ]);
//    }
    
    /**
     * Assigning operator user to existing CompaniesOrdersItems model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionAssigningItem($id)
    {
        if(!Yii::$app->user->can('assigningCompaniesOrdersItemsRealizations')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = $this->findModelItem($id);
        $model->setScenario('assigningOperator');
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = Response::FORMAT_JSON;
            return ActiveForm::validate($model, ['id_user']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('assigning_item', ['model' => $model]);
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('assigning_item', ['model' => $model]);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);            
            if($flag) {  
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view', 'id' => $model->id_order]);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }

        return $this->conditionalRender('assigning_item', [
            'model' => $model,
        ]);
    }
    
    /**
     * Assigning logged operator user to existing CompaniesOrdersItems model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionAssigningYourselfItem($id)
    {
        $model = $this->findModelItem($id);
        
        if(!Yii::$app->user->can('assigningYourselfCompaniesOrdersItemsRealizations', ['model' => $model])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model->id_user = Yii::$app->user->id;
        if($model->save(false)) {  
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));            
        } else {
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
        }
        
        return $this->redirect(['view', 'id' => $model->id_order]);
    }
    
    /**
     * Lists all CompaniesOrdersItems models.
     * @return mixed
     */
    public function actionIndexRealizations()
    {        
        $queryParams = Yii::$app->request->queryParams;
        
        if(Yii::$app->user->can('indexCompaniesOrdersItemsRealizations')) {
            
        } elseif(Yii::$app->user->can('indexOwnCompaniesOrdersItemsRealizations')) {
            $queryParams['CompaniesOrdersItemsSearch']['id_user'] = Yii::$app->user->id;           
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new CompaniesOrdersItemsSearch();        
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index_realizations', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider            
        ]);
    }
    
    /**
     * Displays a single CompaniesOrdersItems model.
     * @param integer $id
     * @return mixed
     */
    public function actionViewRealization($id)
    {
        $idServiceType = \common\models\CompaniesOrdersItems::find()
                ->select('services.id_type')
                ->join('INNER JOIN', 'services', 'companies_orders_items.id_service = services.id_service')
                ->where([
                    'companies_orders_items.id_item' => $id
                ])
                ->scalar();
        if(empty($idServiceType)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }

        $model = OrderItemFactory::getItemModel($idServiceType, $id);

        if(!Yii::$app->user->can('viewCompaniesOrdersItemsRealizations', ['model' => $model])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        return $this->render('view_realization', [
            'model' => $model,
        ]);
    }
    
    /**
     * Changes status an existing CompaniesOrdersItems child model.
     * If update is successful, the browser will be redirected to the 'view-relization' page.
     * @param integer $id
     * @return mixed
     */
    public function actionChangeItemStatus($id)
    {
//        $model = $this->findModelItem($id);
//        $model->setScenario('changeStatus');
        
        $idServiceType = \common\models\CompaniesOrdersItems::find()
                ->select('services.id_type')
                ->join('INNER JOIN', 'services', 'companies_orders_items.id_service = services.id_service')
                ->where([
                    'companies_orders_items.id_item' => $id
                ])
                ->scalar();
        if(empty($idServiceType)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $model = OrderItemFactory::getItemModel($idServiceType, $id, ['scenario' => 'changeStatus']);        
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['status', 'target_id']);
        }
        
        if(Yii::$app->request->getIsPost()) {             
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('change_item_status', ['model' => $model]);
            }
                        
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('change_item_status', ['model' => $model]);
            }
                        
            $transaction = Yii::$app->db->beginTransaction();
            
            if($model->save(false)) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['view-realization', 'id' => $model->id_item]);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('change_item_status', [
            'model' => $model
        ]);
    }
    
    /**
     * Realize CompaniesOrdersItems model.
     * @param integer $id
     * @return mixed
     */
    public function actionRealize($id)
    {        
        $idServiceType = \common\models\CompaniesOrdersItems::find()
                ->select('services.id_type')
                ->join('INNER JOIN', 'services', 'companies_orders_items.id_service = services.id_service')
                ->where([
                    'companies_orders_items.id_item' => $id
                ])
                ->scalar();
        if(empty($idServiceType)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }

        $model = OrderItemFactory::getItemModel($idServiceType, $id);
        
        if(!Yii::$app->user->can('executeCompaniesOrdersItemsRealizations', ['model' => $model])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!in_array($model->status, [\common\models\types\CompanyOrderItemStatus::WAITING, \common\models\types\CompanyOrderItemStatus::IN_PROGRESS])) {
            return $this->redirect(['view-realization', 'id' => $model->id_item]);
        }
        
        if($model->status === \common\models\types\CompanyOrderItemStatus::WAITING) {
            $model->status = \common\models\types\CompanyOrderItemStatus::IN_PROGRESS;
            $model->save(false);
        }
        
        $model->setScenario('realization');
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, $model->realizationFieldsForAjaxValidation);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('realize', ['model' => $model]);
            }
            
            $model->afterLoadActions();
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('realize', ['model' => $model]);
            }
                        
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = $model->save(false);
            
            if($flag) {
                //aktualizujemy tutaj datę aktualizacji rekordu zamówienia
                $modelOrder = $model->order;
                if(!$modelOrder->save(false)) {
                    $flag = false;
                }
            }
            
            $flag = $flag && $model->createTargetItem();      
            if ($flag) {                
                $model->afterSaveActions();
                $transaction->commit();                
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                $redirectParams = $model->getTargetUrlParams();
                if(!empty($redirectParams)) {
                    return $this->redirect($redirectParams);
                }                
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->render('realize', [
            'model' => $model,
        ]);
    }
    
    public function actionProductsList()
    {
        $idCompany = Yii::$app->request->get('id_company');
        $idPortal = Yii::$app->request->get('id_portal');
        $idItem = Yii::$app->request->get('id_item');
        
        $queryParams = Yii::$app->request->queryParams;
        
        if(empty($idCompany) || empty($idPortal) || empty($idItem)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $modelCompanyOrderItem = $this->findModelItem($idItem);
        
        if(!Yii::$app->user->can('executeCompaniesOrdersItemsRealizations', ['model' => $modelCompanyOrderItem])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $queryParams['PortalsPromotedProductsSearch']['id_company'] = $idCompany;
        
        $searchModel = new \backend\models\PortalsPromotedProductsSearch();
        $dataProvider = $searchModel->search($queryParams, $idPortal);

        return $this->renderAjax('products_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionArticlesList()
    {
        $idPortal = Yii::$app->request->get('id_portal');
        $idItem = Yii::$app->request->get('id_item');
        $queryParams = Yii::$app->request->queryParams;

        if(empty($idItem)) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelCompanyOrderItem = $this->findModelItem($idItem);
        
        if(!Yii::$app->user->can('executeCompaniesOrdersItemsRealizations', ['model' => $modelCompanyOrderItem])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!empty($idPortal)) {
            $idPortal = intval($idPortal);
            $queryParams['ArticlesSearch']['idPortal'] = $idPortal;
        }

        $searchModel = new \backend\models\ArticlesSearch();        
        $dataProvider = $searchModel->search($queryParams);
        
        return $this->renderAjax('articles_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionBannersList()
    {
        $idCompany = Yii::$app->request->get('id_company');
        $idPortal = Yii::$app->request->get('id_portal');
        $idItem = Yii::$app->request->get('id_item');
        $queryParams = Yii::$app->request->queryParams;

        if(empty($idItem)) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelCompanyOrderItem = $this->findModelItem($idItem);
        
        if(!Yii::$app->user->can('executeCompaniesOrdersItemsRealizations', ['model' => $modelCompanyOrderItem])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!empty($idCompany)) {
            $idCompany = intval($idCompany);
            $queryParams['BannersSearch']['id_company'] = $idCompany;
        }
//        if(!empty($idPortal)) {
//            $idPortal = intval($idPortal);
//            $queryParams['BannersSearch']['id_portal'] = $idPortal;
//        }

        $searchModel = new \backend\models\BannersSearch();        
        $dataProvider = $searchModel->search($queryParams);
        
        return $this->renderAjax('banners_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionCompaniesPresentationsList()
    {
        $idCompany = Yii::$app->request->get('id_company');
        $idPortal = Yii::$app->request->get('id_portal');
        $idItem = Yii::$app->request->get('id_item');
        $queryParams = Yii::$app->request->queryParams;

        if(empty($idItem)) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelCompanyOrderItem = $this->findModelItem($idItem);
        
        if(!Yii::$app->user->can('executeCompaniesOrdersItemsRealizations', ['model' => $modelCompanyOrderItem])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!empty($idCompany)) {
            $idCompany = intval($idCompany);
            $queryParams['CompaniesPresentationsSearch']['id_company'] = $idCompany;
        }
        if(!empty($idPortal)) {
            $idPortal = intval($idPortal);
            $queryParams['CompaniesPresentationsSearch']['id_portal'] = $idPortal;
        }

        $searchModel = new \backend\models\CompaniesPresentationsSearch();        
        $dataProvider = $searchModel->search($queryParams);
        
        return $this->renderAjax('companies_presentations_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionMonthlySummary()
    {        
        if(!Yii::$app->user->can('monthlySummaryCompaniesOrders')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $month = (int)Yii::$app->request->get('month');
        $month = $month < 10 ? '0'.$month : (string)$month;
        $year = (string)(int)Yii::$app->request->get('year');
        
        if(empty($month) || empty($year)) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Brak danych niezbędnych do wykonania akcji.'));
            return $this->redirect(['index/index']);
        }
        
        $dateStart = $year.'-'.$month.'-01';
        $numberOfLastDayInMonth = date("t", strtotime($dateStart));
        $dateEnd = $year.'-'.$month.'-'.($numberOfLastDayInMonth < 10 ? '0' : '').$numberOfLastDayInMonth;
        $amountsByDays = [];
        $salesSummariesByOperators = [];
        $invoicesAmountsByDays = [];
        $invoicesSalesSummariesByOperators = [];
        
        $operatorsList = \yii\helpers\ArrayHelper::map(
            \common\models\Users::find()
                ->select(['id_user', 'forename', 'surname'])
                ->where([
                    'status' => \common\models\types\Status::ACTIVE, 
                    'profile' => [\common\models\types\UserProfile::MARKETER],
//                    'id_user' => [94, 108, 136, 133]
                ])
                ->andWhere(new \yii\db\Expression('NOT settings @> \'{"or_hidden_in_orders_monthly_summary":1}\''))
                ->orderBy('surname ASC, forename ASC')
                ->indexBy('id_user')
                ->asArray()
                ->all(),
            'id_user', 
            function($item) { return $item['surname'].' '.$item['forename']; }
        );
        
        $modelsOrdersByIds = [];
        $modelsOrders = \common\models\CompaniesOrders::find()
                    ->with(['salesDistributions', 'company'])
                    ->where([
                        'id_user' => array_keys($operatorsList)
                    ])
                    ->andWhere(['>=', 'companies_orders.order_date', $dateStart])
                    ->andWhere(['<=', 'companies_orders.order_date', $dateEnd])
                    ->all();
        
        for($i = 1; $i <= $numberOfLastDayInMonth; $i++) {
            $d = $year.'-'.$month.'-'.($i < 10 ? '0' : '').$i;
            $amountsByDays[$d]['total'] = 0.00;
            $amountsByDays[$d]['timestamp'] = strtotime($d);
            $invoicesAmountsByDays[$d]['total'] = 0.00;
            $invoicesAmountsByDays[$d]['timestamp'] = strtotime($d);
            
            foreach($operatorsList as $idOperator => $operatorName) {
                $amountsByDays[$d][$idOperator] = ['total' => 0.00, 'orders' => []];
                $invoicesAmountsByDays[$d][$idOperator] = ['total' => 0.00, 'orders' => []];
                
                $salesSummariesByOperators[$idOperator] = 0.00;
                $invoicesSalesSummariesByOperators[$idOperator] = 0.00;
            }
        }
        
        if(!empty($modelsOrders)) {
            foreach($modelsOrders as $modelOrder) {
                $modelsOrdersByIds[$modelOrder->id_order] = $modelOrder;
                
                if($modelOrder->currency !== 'PLN' && !empty(CurrencyRates::getAmountInPLN($modelOrder->currency, (float)$modelOrder->amount_net_to_pay, $modelOrder->order_date))) {
                    $orderAmountNet = CurrencyRates::getAmountInPLN($modelOrder->currency, (float)$modelOrder->amount_net_to_pay, $modelOrder->order_date);
                } else {
                    $orderAmountNet = (float)$modelOrder->amount_net_to_pay; 
                }
                
                $amountsByDays[$modelOrder->order_date]['total'] += $orderAmountNet;
                
                if(!empty($modelOrder->salesDistributions)) {
                    foreach($modelOrder->salesDistributions as $modelCompanyOrderSalesDistribution) {
                        if($modelOrder->currency !== 'PLN' && !empty(CurrencyRates::getAmountInPLN($modelOrder->currency, (float)$modelCompanyOrderSalesDistribution->amount, $modelOrder->order_date))) {
                            $salesDistributionAmount = CurrencyRates::getAmountInPLN($modelOrder->currency, (float)$modelCompanyOrderSalesDistribution->amount, $modelOrder->order_date);
                        } else {
                            $salesDistributionAmount = (float)$modelCompanyOrderSalesDistribution->amount; 
                        }                         
                        
                        $amountsByDays[$modelOrder->order_date][$modelCompanyOrderSalesDistribution->id_user]['total'] += $salesDistributionAmount;
                        $amountsByDays[$modelOrder->order_date][$modelCompanyOrderSalesDistribution->id_user]['details'][] = [
                            'id_order' => $modelCompanyOrderSalesDistribution->id_order,
                            'amount' => $salesDistributionAmount
                        ];
                        
                        $salesSummariesByOperators[$modelCompanyOrderSalesDistribution->id_user] += $salesDistributionAmount;
                    }                    
                } else {
                    $amountsByDays[$modelOrder->order_date][$modelOrder->id_user]['total'] += $orderAmountNet;
                    $amountsByDays[$modelOrder->order_date][$modelOrder->id_user]['details'][] = [
                        'id_order' => $modelOrder->id_order,
                        'amount' => $orderAmountNet
                    ];
                    
                    $salesSummariesByOperators[$modelOrder->id_user] += $orderAmountNet;
                }
            }
            unset($modelsOrders);
        }

        $modelsInvoices = \common\models\Invoices::find()
                ->with(['company', 'items'])
                ->where([
                    'or', 
                    [
                        'and', 
                        ['>=', 'receipt_amount_date', $dateStart], 
                        ['<=', 'receipt_amount_date', $dateEnd]
                    ], 
                    [
                        'and', 
                        ['>=', 'payment_date_executed', $dateStart], 
                        ['<=', 'payment_date_executed', $dateEnd],
                        ['receipt_amount_date' => null],
                    ]
                ])
//                ->where(['>=', 'receipt_amount_date', $dateStart])
//                ->andWhere(['<=', 'receipt_amount_date', $dateEnd])
                ->andWhere(['not', ['id_company' => null]])
//                ->orderBy('receipt_amount_date ASC')
                ->orderBy('id_invoice ASC')
                ->indexBy('id_invoice')
                ->all();        
        if(!empty($modelsInvoices)) {            
            $modelsOrdersForInvoices = \common\models\CompaniesOrders::find()
                    ->with(['salesDistributions', 'company'])
                    ->where([
                        'id_invoice' => array_keys($modelsInvoices)
                    ])
                    ->indexBy('id_invoice')
                    ->all();
            
            $idsOrdersRelatedWithInvoices = [];
            foreach($modelsInvoices as $idInvoice => $modelInvoice) { 
                if(!empty($modelInvoice->id_order)) {
                    $idsOrdersRelatedWithInvoices[$modelInvoice->id_order] = $modelInvoice->id_order;
                }
            }
            $modelsOrdersRelatedWithInvoices = \common\models\CompaniesOrders::find()
                    ->with(['salesDistributions', 'company'])
                    ->where([
                        'id_order' => array_values($idsOrdersRelatedWithInvoices)
                    ])
                    ->indexBy('id_order')
                    ->all();
            
            foreach($modelsInvoices as $idInvoice => $modelInvoice) {     
                if(!empty($modelsOrdersForInvoices[$idInvoice])) {
                    $modelOrder = $modelsOrdersForInvoices[$idInvoice];                    
                } elseif(!empty($modelsOrdersRelatedWithInvoices[$modelInvoice->id_order])) {
                    $modelOrder = $modelsOrdersRelatedWithInvoices[$modelInvoice->id_order];
                } else {
                    unset($modelsInvoices[$idInvoice]);
                    continue;
                }
                
                $invoiceDate = !empty($modelInvoice->receipt_amount_date) ? $modelInvoice->receipt_amount_date : $modelInvoice->payment_date_executed;
                $invoiceAmount = !empty($modelInvoice->receipt_amount_value) ? $modelInvoice->receipt_amount_value : $modelInvoice->amount_gross;
                if($modelInvoice->currency !== 'PLN' && !empty(CurrencyRates::getAmountInPLN($modelInvoice->currency, $invoiceAmount, $modelInvoice->payment_date_executed))) {
                    $invoiceAmount = CurrencyRates::getAmountInPLN($modelInvoice->currency, $invoiceAmount, $modelInvoice->payment_date_executed);
                }
                
//                $invoicesAmountsByDays[$invoiceDate]['total'] += $modelInvoice->invoice_type !== \common\models\types\InvoiceType::EUROPEAN ? (float)$invoiceAmount / 1.23 : (float)$invoiceAmount; 
                $invoicesAmountsByDays[$invoiceDate]['total'] += $modelInvoice->invoice_type === \common\models\types\InvoiceType::NATIONAL ? (float)$invoiceAmount / 1.23 : (float)$invoiceAmount; 
                
                if(!empty($modelOrder->salesDistributions)) {
                    foreach($modelOrder->salesDistributions as $modelCompanyOrderSalesDistribution) {
                        $partialAmount = $invoiceAmount * ($modelCompanyOrderSalesDistribution->amount / $modelOrder->amount_net_to_pay);
                        
//                        if($modelInvoice->invoice_type !== \common\models\types\InvoiceType::EUROPEAN) {
                        if($modelInvoice->invoice_type === \common\models\types\InvoiceType::NATIONAL) {
                            $partialAmount = $partialAmount / 1.23;
                        }
                        
                        $invoicesAmountsByDays[$invoiceDate][$modelCompanyOrderSalesDistribution->id_user]['total'] += (float)$partialAmount;
                        $invoicesAmountsByDays[$invoiceDate][$modelCompanyOrderSalesDistribution->id_user]['details'][] = [
                            'id_order' => $modelCompanyOrderSalesDistribution->id_order,
                            'id_invoice' => $modelInvoice->id_invoice,
                            'invoice_number' => $modelInvoice->invoice_number,
                            'proforma_invoice_number' => $modelInvoice->proforma_invoice_number,
                            'amount' => (float)$partialAmount
                        ];
                        
                        $invoicesSalesSummariesByOperators[$modelCompanyOrderSalesDistribution->id_user] += (float)$partialAmount;
                    }                    
                } else {    
//                    $amount = (float)($modelInvoice->invoice_type !== \common\models\types\InvoiceType::EUROPEAN ? (float)$invoiceAmount / 1.23 : (float)$invoiceAmount);
                    $amount = (float)($modelInvoice->invoice_type === \common\models\types\InvoiceType::NATIONAL ? (float)$invoiceAmount / 1.23 : (float)$invoiceAmount);
                    $invoicesAmountsByDays[$invoiceDate][$modelOrder->id_user]['total'] += $amount;
                    $invoicesAmountsByDays[$invoiceDate][$modelOrder->id_user]['details'][] = [
                        'id_order' => $modelOrder->id_order,
                        'id_invoice' => $modelInvoice->id_invoice,
                        'invoice_number' => $modelInvoice->invoice_number,
                        'proforma_invoice_number' => $modelInvoice->proforma_invoice_number,
                        'amount' => $amount
                    ];
                    
                    $invoicesSalesSummariesByOperators[$modelOrder->id_user] += $amount;
                }
            }
            
            foreach($modelsOrdersForInvoices as $modelOrderForInvoice) {
                $modelsOrdersByIds[$modelOrderForInvoice->id_order] = $modelOrderForInvoice;
            }
            foreach($modelsOrdersRelatedWithInvoices as $modelOrderRelatedWithInvoices) {
                $modelsOrdersByIds[$modelOrderRelatedWithInvoices->id_order] = $modelOrderRelatedWithInvoices;
            }
            
            unset($modelsOrdersForInvoices);
            unset($modelsOrdersRelatedWithInvoices);
            unset($modelsInvoices);
        }
        
        foreach($amountsByDays as $date => $amountsByDay) {
            $dayOfWeek = date("D", strtotime($date));
            if(($dayOfWeek === 'Sat' || $dayOfWeek === 'Sun') && empty($amountsByDay['total'])) {
                unset($amountsByDays[$date]);
            }
        }
        foreach($invoicesAmountsByDays as $date => $amountsByDay) {
            $dayOfWeek = date("D", strtotime($date));
            if(($dayOfWeek === 'Sat' || $dayOfWeek === 'Sun') && empty($amountsByDay['total'])) {
                unset($invoicesAmountsByDays[$date]);
            }
        }
        
        return $this->render('monthly_summary', [
            'operatorsList' => $operatorsList,
            'amountsByDays' => $amountsByDays,
            'salesSummariesByOperators' => $salesSummariesByOperators,
            'invoicesAmountsByDays' => $invoicesAmountsByDays,
            'invoicesSalesSummariesByOperators' => $invoicesSalesSummariesByOperators,
            'modelsOrdersByIds' => $modelsOrdersByIds
        ]);
    }
    
    public function actionSendCumulativeInfoAboutCompaniesPayments()
    {
        if(!Yii::$app->user->can('sendCumulativeInfoAboutCompaniesPayments')) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new SendCumulativeInfoAboutCompaniesPaymentsForm();
        
        if(Yii::$app->applicationCache->exists('cumulative_info_about_payments_'.Yii::$app->user->id)) {
            $modelForm->message = Yii::$app->applicationCache->get('cumulative_info_about_payments_'.Yii::$app->user->id);
        }
        
        $outputParams = [
            'modelForm' => $modelForm
        ];
        
        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->conditionalRender('send_cumulative_info_about_companies_payments', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->conditionalRender('send_cumulative_info_about_companies_payments', $outputParams);
            }
            
            $modelsOperators = Users::find()
                    ->select(['id_user', 'forename', 'surname'])
                    ->with([
                        'contactData' => function($q) {
                            $q->where([
                                'required' => 1,
                                'data_type' => ContactDataType::EMAIL
                            ]);
                        }
                    ])
                    ->where([
                        'profile' => [UserProfile::MARKETER],
                        'status' => Status::ACTIVE
                    ])
                    ->orWhere([
                        'login' => ['vm_lukasz']
                    ])
                    ->orderBy('forename ASC, surname ASC')
                    ->indexBy('id_user')
                    ->all();
            $recipientsEmails = [];
            foreach($modelsOperators as $modelOperator) {
                if(!empty($modelOperator->contactData[0]->data_value)) {
                    $recipientsEmails[] = $modelOperator->contactData[0]->data_value;
                }
            } 

            //wysyłamy emaile z fakturą (###MAIL_57###) 
            $mailer = Yii::$app->mailer;
            $mailer->htmlLayout = 'layouts/main-html';      
            $mailer->textLayout = 'layouts/main-text';           
            $flag = $mailer->compose(
                    [
                        'html' => 'send_cumulative_info_about_companies_payments_html', 
                        'text' => 'send_cumulative_info_about_companies_payments_text'
                    ],
                    [
                        'messageContent' => $modelForm->message,
                        'orNoPayments' => (int)$modelForm->orNoPayments === 1 ? true : false
                    ]
                )
                ->setFrom([Yii::$app->params['noReplyEmail'] => 'System vManager'])
                ->setTo($recipientsEmails)
                ->setSubject(Yii::t('common-mails', 'Płatności zbiorcze'))
                ->send();
            
            if($flag) {    
                if((int)$modelForm->orNoPayments === 0) {
                    Yii::$app->applicationCache->set('cumulative_info_about_payments_'.Yii::$app->user->id, $modelForm->message);
                }
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Wiadomość została wysłana.')); 
            } else {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas wysyłania wiadomości.'));                
            }
        }
       
        return $this->conditionalRender('send_cumulative_info_about_companies_payments', $outputParams);
    }

    /**
     * Finds the CompaniesOrders model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return CompaniesOrders the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = CompaniesOrders::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the CompaniesOrdersItems model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return CompaniesOrdersItems the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelItem($id)
    {
        if (($model = CompaniesOrdersItems::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com