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/CompaniesdocumentsController.php
<?php

namespace backend\controllers;

use Yii;
use common\models\Companies;
use common\models\CompaniesDocuments;
use common\models\CompaniesDocumentsTasks;
use common\models\CompaniesDocumentsFiles;
use common\models\CompaniesCases;
use common\models\CompaniesCasesEntries;
use backend\models\CompaniesDocumentsSearch;
use backend\models\CompanyDocumentFilesForm;
use backend\models\CompaniesSearch;
use backend\models\SendDocumentTaskForm;
use backend\models\NotifyAboutCompletedDocumentTaskForm;
use yii\data\ActiveDataProvider;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;

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

    /**
     * Lists all CompaniesDocuments models.
     * @param integer $id
     * @return mixed
     */
    public function actionIndex($id)
    {
        $modelCompany = $this->findModelCompany($id);
        
        $searchModel = new CompaniesDocumentsSearch();
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['CompaniesDocumentsSearch']['id_company'] = $modelCompany->id_company;
        
        if(
            !Yii::$app->user->can('indexCompaniesDocuments') 
            && !(Yii::$app->user->can('indexRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompany])) 
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
            'modelCompany' => $modelCompany,
        ]);
    }
    
    /**
     * Lists CompaniesDocuments models with status not realized.
     * @return mixed
     */
    public function actionIndexAllInProgress()
    {        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['CompaniesDocumentsSearch']['orIndexAll'] = true;
        $queryParams['CompaniesDocumentsSearch']['onlyInProgress'] = true;
        
        if(Yii::$app->user->can('indexCompaniesDocuments')) {
            //nie robimy nic
        } elseif(Yii::$app->user->can('indexRelatedCompaniesDocuments')) {
            $queryParams['CompaniesDocumentsSearch']['idOperator'] = Yii::$app->user->id;
        } else { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new CompaniesDocumentsSearch();
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index_all_in_progress', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    /**
     * Lists CompaniesDocuments models with status realized.
     * @return mixed
     */
    public function actionIndexAllRealized()
    {        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['CompaniesDocumentsSearch']['orIndexAll'] = true;
        $queryParams['CompaniesDocumentsSearch']['status'] = \common\models\types\CompanyDocumentStatus::COMPLETED;
        
        if(Yii::$app->user->can('indexCompaniesDocuments')) {
            //nie robimy nic
        } elseif(Yii::$app->user->can('indexRelatedCompaniesDocuments')) {
            $queryParams['CompaniesDocumentsSearch']['idOperator'] = Yii::$app->user->id;
        } else { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new CompaniesDocumentsSearch();
        $dataProvider = $searchModel->search($queryParams);

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

    /**
     * Displays a single CompaniesDocuments model.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
        
        if(
            !Yii::$app->user->can('viewCompaniesDocuments') 
            && !(Yii::$app->user->can('viewRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $model->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        return $this->render('view', [
            'model' => $model,
        ]);
    }

    /**
     * Creates a new CompaniesDocuments model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionCreate($id = null)
    {
        
        if(!empty($id)) {
            $modelCompany = $this->findModelCompany($id);
        } else {
            $modelCompany = null;
        }
        
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompany]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }

        if($modelCompany) {
            $modelCompanyDocument = new CompaniesDocuments(['scenario' => 'create']);
            $modelCompanyDocument->id_company = $modelCompany->id_company; 
        } else {
            $modelCompanyDocument = new CompaniesDocuments(['scenario' => 'createFull']);
        }
        
        $outputParams = [
            'modelCompanyDocument' => $modelCompanyDocument, 
            'modelCompany' => $modelCompany
        ];
        
        if (Yii::$app->request->isAjax && $modelCompanyDocument->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelCompanyDocument, ['document_date', 'date_sent_to_partner', 'date_sent_from_partner', 'id_company']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$modelCompanyDocument->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('create', $outputParams);
            }
                     
            if(!$modelCompanyDocument->validate()) {
                Yii::$app->session->addFlash('error', $modelCompanyDocument->getErrors());
                return $this->render('create', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $modelCompanyCase = new CompaniesCases(['scenario' => 'create']);
            $modelCompanyCase->id_company = $modelCompanyDocument->id_company;
            $modelCompanyCase->id_user = Yii::$app->user->getId();
            $modelCompanyCase->subject = ucfirst($modelCompanyDocument->document_type).' : '.$modelCompanyDocument->title.', dodany dnia '.date('d-m-Y'); 
            
            $flag = $modelCompanyCase->save();
            if($flag) {
                $modelCompanyDocument->id_case = $modelCompanyCase->id_case;
                
                $modelCompanyCaseEntry = new CompaniesCasesEntries(['scenario' => 'create']);
                $modelCompanyCaseEntry->id_case = $modelCompanyCase->id_case;
                $modelCompanyCaseEntry->id_user = Yii::$app->user->getId();
                $modelCompanyCaseEntry->content = 'Utworzono dokument';
                $modelCompanyCaseEntry->contact_term = date('Y-m-d H:i'); //@todo ustalić, co tutaj wpisujemy
                $flag = $modelCompanyCaseEntry->save();                
            }            
            $flag = $flag && $modelCompanyDocument->save(false);
            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['update', 'id' => $modelCompanyDocument->id_document]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
            }
            
        }

        return $this->render('create', $outputParams);
    }

    /**
     * Updates an existing CompaniesDocuments model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionUpdate($id)
    {
        $modelCompanyDocument = $this->findModel($id);
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocument->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        $modelCompanyDocument->setScenario('update');
        
        $dataProviderTasks = new \yii\data\ActiveDataProvider([
            'query' => $modelCompanyDocument->getTasks()->orderBy(new \yii\db\Expression(
                'CASE WHEN completed_datetime IS NULL THEN 0 ELSE 1 END, 
                CASE WHEN completed_datetime IS NULL THEN task_date END ASC,
                CASE WHEN completed_datetime IS NOT NULL THEN completed_datetime END DESC'
            )),
            'pagination' => false,
            'sort' => false
        ]);
        
        $dataProviderFiles = new \yii\data\ActiveDataProvider([
            'query' => $modelCompanyDocument->getFiles()->orderBy('created_at DESC'),
            'pagination' => false,
            'sort' => false
        ]);
        
        $outputParams = [
            'modelCompanyDocument' => $modelCompanyDocument, 
            'dataProviderTasks' => $dataProviderTasks,
            'dataProviderFiles' => $dataProviderFiles
        ];
        
        if (Yii::$app->request->isAjax && $modelCompanyDocument->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelCompanyDocument, ['document_date', 'date_sent_to_partner', 'date_sent_from_partner']);
        }

        if(Yii::$app->request->getIsPost()) { 
            if(!$modelCompanyDocument->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('update', $outputParams);
            }
                     
            if(!$modelCompanyDocument->validate()) {
                Yii::$app->session->addFlash('error', $modelCompanyDocument->getErrors());
                return $this->render('update', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
                  
            $flag = $modelCompanyDocument->save(false);
            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['update', 'id' => $modelCompanyDocument->id_document]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
            }
            
        }

        return $this->render('update', $outputParams);
    }

    /**
     * Deletes an existing CompaniesDocuments model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     * @throws NotFoundHttpException if the model cannot be found
     */
    public function actionDelete($id)
    {
        $model = $this->findModel($id);
        
        if(!Yii::$app->user->can('deleteCompaniesDocuments')) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $idCompany = $model->id_company;
        
        $transaction = Yii::$app->db->beginTransaction();
        if($model->delete() !== false) {
            $transaction->commit();
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.'));
        }
        else {
            $transaction->rollBack();
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));
        }
        
        return $this->redirect(['companiesdocuments/index', 'id' => $idCompany]);
    }
    
    /**
     * Creates a new CompaniesDocumentsTasks model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreateTask()
    {        
        $modelCompanyDocument = $this->findModel(intval(Yii::$app->request->get('id_document')));
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocument->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        $modelCompanyDocumentTask = new \backend\models\CompaniesDocumentsTasks(['scenario' => 'create', 'idDocument' => $modelCompanyDocument->id_document]);
        $modelCompanyDocumentTask->id_document = $modelCompanyDocument->id_document;
                
        $outputParams = [
            'modelCompanyDocument' => $modelCompanyDocument, 
            'modelCompanyDocumentTask' => $modelCompanyDocumentTask
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelCompanyDocumentTask->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelCompanyDocumentTask, ['task_date', 'completed_datetime', 'listFiles']);
        }
        
        if(Yii::$app->request->getIsPost()) {  
            if(!$modelCompanyDocumentTask->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('create_task', $outputParams);
            }
            
            if(!$modelCompanyDocumentTask->validate()) {
                Yii::$app->session->addFlash('error', $modelCompanyDocumentTask->getErrors());
                return $this->conditionalRender('create_task', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            $flag = $modelCompanyDocumentTask->save(false);
            $flag = $flag && $modelCompanyDocumentTask->saveFiles();            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $modelCompanyDocumentTask->id_document]);
                } 
                else {
                    $outputParams['modelCompanyDocumentTask'] = new CompaniesDocumentsTasks(['scenario' => 'create']);
                    $outputParams['modelCompanyDocumentTask']->id_document = $modelCompanyDocument->id_document;
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_task', $outputParams);
    }
    
    /**
     * Updates an existing CompaniesDocumentsTasks model.
     * If update is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdateTask($id)
    {
        $modelCompanyDocumentTask = \backend\models\CompaniesDocumentsTasks::findOne($id);        
        if (!$modelCompanyDocumentTask) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocumentTask->document->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        $modelCompanyDocumentTask->setScenario('update');
        
        $outputParams = [
            'modelCompanyDocumentTask' => $modelCompanyDocumentTask
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelCompanyDocumentTask->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelCompanyDocumentTask, ['task_date', 'completed_datetime', 'listFiles']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            if(!$modelCompanyDocumentTask->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->conditionalRender('update_task', $outputParams);
            }
            
            if(!$modelCompanyDocumentTask->validate()) {
                Yii::$app->session->addFlash('error', $modelCompanyDocumentTask->getErrors());
                return $this->conditionalRender('update_task', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();            
            $flag = $modelCompanyDocumentTask->save(false);
            $flag = $flag && $modelCompanyDocumentTask->saveFiles();            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(Yii::$app->request->get('return_url') ? Yii::$app->request->get('return_url') : ['update', 'id' => $modelCompanyDocumentTask->id_document]);
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('update_task', $outputParams);
    }

    /**
     * Deletes an existing CompaniesDocumentsTasks model.
     * If deletion is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeleteTask($id)
    {
        $modelCompanyDocumentTask = $this->findModelTask($id);
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocumentTask->document->company]))
            && !(Yii::$app->user->can('deleteCompaniesDocumentsUncompletedTasks') && empty($modelCompanyDocumentTask->completed_datetime))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
                
        if($modelCompanyDocumentTask->delete()) {
            $transaction->commit();
        } else {
            $transaction->rollBack();
        }
        
        return Yii::$app->getResponse()->redirect(['companiesdocuments/update', 'id' => $modelCompanyDocumentTask->id_document], 302, false);
    }
    
//    public function actionSetTaskAsCompleted_old($id)
//    {
//        $modelCompanyDocumentTask = $this->findModelTask($id);
//        if(
//            !Yii::$app->user->can('modifyCompaniesDocuments') 
//            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocumentTask->document->company]))
//        ) { 
//            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
//        }
//        $modelCompanyDocumentTask->setScenario('update');        
//        $modelCompanyDocumentTask->completed_datetime = date('Y-m-d H:i');
//        $modelCompanyDocumentTask->save();
//        
//        $modelOperatorRecipient = \common\models\Users::find()
//            ->select(['id_user', 'forename', 'surname'])
//            ->with([
//                'contactData' => function($q) {
//                    $q->where([
//                        'required' => 1,
//                        'data_type' => \common\models\types\ContactDataType::EMAIL
//                    ]);
//                }
//            ])
//            ->where(['id_user' => Yii::$app->user->id])
//            ->one();
//
//        $operatorRecipientEmail = $modelOperatorRecipient->contactData[0]->data_value;            
//
//        //wysyłamy email z danymi zakończonego zadania dokumentu (###MAIL_77###) 
//        $mailer = Yii::$app->mailer;
//        $mailer->htmlLayout = 'layouts/main-html';      
//        $mailer->textLayout = 'layouts/main-text';           
//        $flag = $mailer->compose(
//                [
//                    'html' => 'set_company_document_task_as_completed_html',
//                    'text' => 'set_company_document_task_as_completed_text'
//                ],
//                [
//                    'modelCompanyDocumentTask' => $modelCompanyDocumentTask,
//                    'operatorForename' => $modelOperatorRecipient->forename,
//                    'operatorSurname' => $modelOperatorRecipient->surname
//                ]
//            )
//            ->setFrom([Yii::$app->params['noReplyEmail'] => 'System vManager'])
//            ->setTo($operatorRecipientEmail)
//            ->setSubject(Yii::t('common-mails', 'Zadanie WYKONANE dla dokumentu firmy: {companyName}', ['companyName' => $modelCompanyDocumentTask->document->company->name]))
//            ->send();
//        
//        return Yii::$app->getResponse()->redirect(['companiesdocuments/update', 'id' => $modelCompanyDocumentTask->id_document], 302, false);        
//    }
    
    public function actionSetTaskAsCompleted($id)
    {        
        $modelCompanyDocumentTask = $this->findModelTask($id);
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocumentTask->document->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new NotifyAboutCompletedDocumentTaskForm(['id_task' => $modelCompanyDocumentTask->id_task]);
        $modelCompanyDocumentTask->setScenario('update'); 
        
        $outputParams = [
            'modelCompanyDocumentTask' => $modelCompanyDocumentTask,
            'modelForm' => $modelForm,
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['id_operator', 'id_task']);
        }
        
        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('set_task_as_completed', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->conditionalRender('set_task_as_completed', $outputParams);
            }
            
            $emails = \common\models\UsersContactData::find()
                ->select(['data_value'])
                ->where([
                    'id_user' => $modelForm->listOperators,
                    'required' => 1,
                    'data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->distinct()
                ->column();
            
            if(empty($emails)) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Brak danych niezbędnych do wykonania akcji.'));
                return $this->conditionalRender('set_task_as_completed', $outputParams);
            }
            
            $modelCompanyDocumentTask->completed_datetime = date('Y-m-d H:i');
            $flag = $modelCompanyDocumentTask->save();

            if($flag) {
                //wysyłamy email z danymi zakończonego zadania dokumentu (###MAIL_77###) 
                $mailer = Yii::$app->mailer;
                $mailer->htmlLayout = 'layouts/main-html';      
                $mailer->textLayout = 'layouts/main-text';           
                $flag = $mailer->compose(
                        [
                            'html' => 'set_company_document_task_as_completed_html',
                            'text' => 'set_company_document_task_as_completed_text'
                        ],
                        [
                            'modelCompanyDocumentTask' => $modelCompanyDocumentTask,
                            'operatorForename' => Yii::$app->user->identity->forename,
                            'operatorSurname' => Yii::$app->user->identity->surname,
                            'annotations' => $modelForm->annotations
                        ]
                    )
                    ->setFrom([Yii::$app->params['noReplyEmail'] => 'System vManager'])
                    ->setTo($emails)
                    ->setSubject(Yii::t('common-mails', 'Zadanie [{idTask}] WYKONANE dla dokumentu firmy: {companyName}', ['idTask' => $modelCompanyDocumentTask->id_task, 'companyName' => $modelCompanyDocumentTask->document->company->name]))
                    ->send();
            }
            
            if($flag) {    
                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('set_task_as_completed', $outputParams);
    }
    
    public function actionSendTask($id)
    {        
        $modelCompanyDocumentTask = $this->findModelTask($id);

        if(
            !Yii::$app->user->can('viewCompaniesDocuments') 
            && !(Yii::$app->user->can('viewRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocumentTask->document->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new SendDocumentTaskForm(['id_task' => $modelCompanyDocumentTask->id_task]);
        
        $outputParams = [
            'modelCompanyDocumentTask' => $modelCompanyDocumentTask,
            'modelForm' => $modelForm,
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['id_operator', 'id_task']);
        }
        
        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', $outputParams);
            }
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->conditionalRender('send', $outputParams);
            }        
                        
            $modelOperatorRecipient = \common\models\Users::find()
                ->select(['id_user', 'forename', 'surname'])
                ->with([
                    'contactData' => function($q) {
                        $q->where([
                            'required' => 1,
                            'data_type' => \common\models\types\ContactDataType::EMAIL
                        ]);
                    }
                ])
                ->where(['id_user' => $modelForm->id_operator])
                ->one();
                
            $operatorRecipientEmail = $modelOperatorRecipient->contactData[0]->data_value;            

            //wysyłamy email z danymi zadania dokumentu (###MAIL_76###) 
            $mailer = Yii::$app->mailer;
            $mailer->htmlLayout = 'layouts/main-html';      
            $mailer->textLayout = 'layouts/main-text';           
            $flag = $mailer->compose(
                    [
                        'html' => 'send_company_document_task_html',
                        'text' => 'send_company_document_task_text'
                    ],
                    [
                        'modelCompanyDocumentTask' => $modelCompanyDocumentTask,
                        'operatorForename' => $modelOperatorRecipient->forename,
                        'operatorSurname' => $modelOperatorRecipient->surname,
                        'annotations' => $modelForm->annotations
                    ]
                )
                ->setFrom([Yii::$app->params['noReplyEmail'] => 'System vManager'])
                ->setTo($operatorRecipientEmail)
                ->setSubject(Yii::t('common-mails', 'Informacje o zadaniu [{idTask}] dla dokumentu firmy: {companyName}', ['idTask' => $modelCompanyDocumentTask->id_task, 'companyName' => $modelCompanyDocumentTask->document->company->name]))
                ->send();
            
            if($flag) {    
                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_task', $outputParams);
    }
    
    /**
     * Create new CompaniesDocumentsFiles models.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionUploadFiles()
    {
        $modelCompanyDocument = $this->findModel(intval(Yii::$app->request->get('id_document')));
        if(
            !Yii::$app->user->can('modifyCompaniesDocuments') 
            && !(Yii::$app->user->can('modifyRelatedCompaniesDocuments') && Yii::$app->user->can('manageCompanies', ['model' => $modelCompanyDocument->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $modelForm = new CompanyDocumentFilesForm();
        $modelForm->setModelDocument($modelCompanyDocument);
        $modelForm->setIdUser((int)Yii::$app->user->getId());
                
        $outputParams = [
            'modelForm' => $modelForm, 
        ];
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($modelForm, ['contactTermDate', 'contactTermTime']);
        }
        
        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('upload_files', $outputParams);
            }
            
            $modelForm->loadFiles();
            
            if(!$modelForm->validate()) {
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->conditionalRender('upload_files', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            if($modelForm->save()) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $modelCompanyDocument->id_document]);
                } 
                else {
                    $outputParams['modelForm'] = new CompanyDocumentFilesForm(['scenario' => 'create']);
                    $outputParams['modelForm']->setModelDocument($modelCompanyDocument);
                    $outputParams['modelForm']->setIdUser((int)Yii::$app->user->getId());
                }
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('upload_files', $outputParams);
    }
    
    /**
     * Deletes an existing CompaniesDocumentsFiles model.
     * If deletion is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeleteFile($id)
    {
        $modelCompanyDocumentFile = $this->findModelFile($id);
        if(!Yii::$app->user->can('deleteCompaniesDocumentsFiles')) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
                
        if($modelCompanyDocumentFile->delete()) {
            $transaction->commit();
        } else {
            $transaction->rollBack();
        }
        
        return Yii::$app->getResponse()->redirect(['companiesdocuments/update', 'id' => $modelCompanyDocumentFile->id_document], 302, false);
    }
    
    public function actionGetFile($id)
    {
        $model = $this->findModelFile($id);
        if(
            !Yii::$app->user->can('getCompaniesDocumentsFiles') 
            && !(Yii::$app->user->can('getRelatedCompaniesDocumentsFiles') && Yii::$app->user->can('manageCompanies', ['model' => $model->document->company]))
        ) { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $this->layout = false;
        
        $filePath = $model->getFilePath();
        
        $orOpen = (int)Yii::$app->request->get('open', 0);
        
        $response = Yii::$app->getResponse();
        
        if(!$orOpen) {
            $response->setDownloadHeaders(basename($filePath), mime_content_type($filePath));
            $response->sendFile($filePath);
        } else {
            $response->headers->add('Content-Type', mime_content_type($filePath));
            $response->headers->add('Content-Length', filesize($filePath));
            $response->headers->add('Pragma', 'no-cache');
            $response->headers->add('Expires', 'January 01, 2000');
            $response->headers->add('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate');
            $response->data = file_get_contents($filePath);
            $response->format = \yii\web\Response::FORMAT_RAW;
        }
        
        $response->send();
    }
    
    /**
     * Lists all upcoming tasks.
     * @return mixed
     */
    public function actionTasksForNow()
    {
        $query = CompaniesDocumentsTasks::find()
                ->with(['document'])
                ->where(['<=', 'companies_documents_tasks.task_date', date("Y-m-d", strtotime('+ 2 days'))])
                ->andWhere(['companies_documents_tasks.completed_datetime' => null]);
        
        if(Yii::$app->user->can('indexCompaniesDocuments')) {
            //nie robimy nic
        } elseif(Yii::$app->user->can('indexRelatedCompaniesDocuments')) {
            $query->join('INNER JOIN', 'companies_documents', 'companies_documents.id_document = companies_documents_tasks.id_document')
                    ->andWhere([
                        'companies_documents.id_company' => \common\models\OperatorsHasCompanies::find()
                                                                ->select(['id_company'])
                                                                ->where(['id_user' => Yii::$app->user->getId()
                    ])]);
        } else { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $dataProvider = new ActiveDataProvider([
            'query' => $query,
            'pagination' => [
                'defaultPageSize' => Yii::$app->session->get('dps.companiesdocuments.tasks-for-now', 25),
                'pageSizeLimit' => [1, 100]
            ],
            'sort'=> [
                'defaultOrder' => ['task_date' => SORT_DESC]
            ]
        ]);
        
        if($dataProvider->pagination->defaultPageSize !== $dataProvider->pagination->pageSize) {
            Yii::$app->session->set('dps.companiesdocuments.tasks-for-now', $dataProvider->pagination->pageSize);
        }
        
        return $this->render('tasks_for_now', [
            'dataProvider' => $dataProvider,
        ]);
    }
    
    /**
     * Lists all not completed tasks.
     * @return mixed
     */
    public function actionTasksNotCompleted()
    {
        $query = CompaniesDocumentsTasks::find()
                ->with(['document'])
                ->where(['companies_documents_tasks.completed_datetime' => null]);
        
        if(Yii::$app->user->can('indexCompaniesDocuments')) {
            //nie robimy nic
        } elseif(Yii::$app->user->can('indexRelatedCompaniesDocuments')) {
            $query->join('INNER JOIN', 'companies_documents', 'companies_documents.id_document = companies_documents_tasks.id_document')
                    ->andWhere([
                        'companies_documents.id_company' => \common\models\OperatorsHasCompanies::find()
                                                                ->select(['id_company'])
                                                                ->where(['id_user' => Yii::$app->user->getId()
                    ])]);
        } else { 
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $dataProvider = new ActiveDataProvider([
            'query' => $query,
            'pagination' => [
                'defaultPageSize' => Yii::$app->session->get('dps.companiesdocuments.tasks-not-completed', 25),
                'pageSizeLimit' => [1, 100]
            ],
            'sort'=> [
                'defaultOrder' => ['task_date' => SORT_DESC]
            ]
        ]);
        
        if($dataProvider->pagination->defaultPageSize !== $dataProvider->pagination->pageSize) {
            Yii::$app->session->set('dps.companiesdocuments.tasks-not-completed', $dataProvider->pagination->pageSize);
        }
        
        return $this->render('tasks_not_completed', [
            'dataProvider' => $dataProvider,
        ]);
    }
    
    /**
     * Finds the CompaniesDocuments model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return CompaniesDocuments the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = CompaniesDocuments::findOne($id)) !== null) {
            return $model;
        }

        throw new NotFoundHttpException(Yii::t('backend', 'The requested page does not exist.'));
    }
    
    /**
     * Finds the Companies model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return Companies the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelCompany($id)
    {
        if (($model = Companies::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the CompaniesDocumentsTasks model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return CompaniesDocumentsTasks the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelTask($id)
    {
        if (($model = CompaniesDocumentsTasks::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    /**
     * Finds the CompaniesDocumentsFiles model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @return CompaniesDocumentsFiles the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModelFile($id)
    {
        if (($model = CompaniesDocumentsFiles::findOne($id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    public function actionCompaniesList()
    {
        $searchModel = new CompaniesSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

        return $this->renderAjax('companies_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com