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

namespace backend\controllers;

use Yii;
use backend\models\BooksSubscriptions;
use common\models\Companies;
use common\models\BooksSubscriptionsAttachments;
use backend\models\BooksSubscriptionsSearch;
use backend\models\BooksSearch;
use backend\models\BookstoreBatchChangePricesForm;
use common\models\types\UserChangeType;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;

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

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

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
            'modelCompany' => $modelCompany
        ]);
    }
    
    /**
     * Lists all BooksSubscriptions models.
     * @param integer $id
     * @return mixed
     */
    public function actionIndexPrices($id)
    {
        $modelCompany = $this->findModelCompany($id);
        
        if (!Yii::$app->user->can('viewCompaniesData', ['model' => $modelCompany]) && !Yii::$app->user->can('viewOwnCompaniesData', ['model' => $modelCompany])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new BooksSubscriptionsSearch();
        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['BooksSubscriptionsSearch']['id_company'] = $modelCompany->id_company;
        
        $dataProvider = $searchModel->search($queryParams);
        
        $modelForm = new BookstoreBatchChangePricesForm();
        $modelForm->setScenario('booksSubscriptions');
        $modelForm->operation_type = BookstoreBatchChangePricesForm::OPERATION_TYPE_SET_VALUE;

        return $this->render('index_prices', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
            'modelCompany' => $modelCompany,
            'modelForm' => $modelForm
        ]);
    }
    
    public function actionChangePrice()
    {
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $this->layout = false;  
        
        if(!Yii::$app->request->getIsPost()) { 
            return false;
        }
        
        $fieldName = Yii::$app->request->post('fieldName');
        if(empty($fieldName) || !in_array($fieldName, ['price', 'price_paper_version', 'price_electronic_version'])) {
            throw new BadRequestHttpException(Yii::t('backend', 'Brak danych niezbędnych do wykonania akcji.'));
        }
        
        $idSubscription = Yii::$app->request->post('idItem');
        if(empty($idSubscription)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $model = $this->findModel($idSubscription);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $price = Yii::$app->request->post('value');
        
        $model->$fieldName = $price;
        
        if(!$model->validate([$fieldName])) {
            return ['returnCode' => 1, 'errorMessage' => !empty($model->getErrors($fieldName)) ? $model->getErrors($fieldName)[0] : Yii::t('backend', 'Formularz zawiera błędy.')];
        } 
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $flag = $model->save(false);
        $flag = $flag && $model->savePricesForBooksAvailableOnlyBySubscription();
        
        if($flag) {
            $transaction->commit(); 
            //@todo odkomentować na testach
            $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_MODIFIED, $model->id_subscription, $model->id_company);
            //usuwanie cache znajduje się już w metodzie \backend\models\BooksSubscriptions::savePricesForBooksAvailableOnlyBySubscription();
            return ['returnCode' => 0, 'errorMessage' => null];            
        } else {
            $transaction->rollBack();
            return ['returnCode' => 1, 'errorMessage' => Yii::t('backend', 'Błąd podczas zapisu.')];
        }
    }
    
    public function actionBatchChangePrices()
    {
        $modelForm = new BookstoreBatchChangePricesForm();
        $modelForm->setScenario('booksSubscriptions');
        
        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, ['operation_type', 'ids_items']);
        }
        
        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->redirect(Yii::$app->request->getReferrer() ? Yii::$app->request->getReferrer() : ['index/index']);
            } 
            
            $modelCompany = $modelForm->getModelCompany();
            
            if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $modelCompany]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $modelCompany])) {
                throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
            }
            
            $transaction = Yii::$app->db->beginTransaction();
                      
            if(!$modelForm->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $modelForm->getErrors());
                return $this->redirect(Yii::$app->request->getReferrer() ? Yii::$app->request->getReferrer() : ['index/index']);
            } 
            
            $idsModifiedBooks = [];
            
            $flag = $modelForm->save(false);
            if($flag) {
                $modelsBooks = \common\models\Books::find()
                        ->join('INNER JOIN', 'books_has_books_subscriptions', 'books_has_books_subscriptions.id_book = books.id_book')
                        ->where([
                            'books.or_sale_only_in_subscription' => 1,
                            'books_has_books_subscriptions.id_subscription' => $modelForm->ids_items
                        ])
                        ->all();

                foreach ($modelsBooks as $modelBook) {      
                    $minPrice = (float)$modelBook->getSubscriptions()->min('price');
                    if (floatval($modelBook->price) !== $minPrice) {
                        $modelBook->price = $minPrice;
                        $flag = $modelBook->save(false);
                        if(!$modelBook->save(false)) {
                            $flag = false;
                            break;
                        }
                        $idsModifiedBooks[] = $modelBook->id_book;
                    }
                }
            }
            
            if($flag && !empty($idsModifiedBooks)) {
                foreach($idsModifiedBooks as $idModifiedBook) {
                    if(!\frontend\models\IndexBooks::refreshRecord($idBook)) {
                        $flag = false;
                        break;
                    }
                }
            }
            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                foreach($modelForm->ids_items as $idSubscription) {
                    $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_MODIFIED, $idSubscription, $modelCompany);
                }
                
                if(!empty($idsModifiedBooks)) {
                    $cacheTags = [];
                    foreach($idsModifiedBooks as $idModifiedBook) {
                        $cacheTags = ['book_'.$idModifiedBook];
                    }
                    $modifiedPortals = \common\models\PortalsHasBookstoreCategories::find()
                            ->select(['portals_has_bookstore_categories.id_portal'])
                            ->join('INNER JOIN', 'books_has_bookstore_categories', 'books_has_bookstore_categories.id_category = portals_has_bookstore_categories.id_category')
                            ->where(['books_has_bookstore_categories.id_book' => $idsModifiedBooks])
                            ->distinct()
                            ->column();                
                    if(!empty($modifiedPortals)) {                    
                        foreach($modifiedPortals as $idPortal) {
                            $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                        }
                    }
                    TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
                }                
            } else {
                $transaction->rollBack();
                if(!empty($idsModifiedBooks)) {
                    \frontend\models\IndexBooks::refreshRecords($idsModifiedBooks);
                }                
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
            }
            
            return $this->redirect(Yii::$app->request->getReferrer() ? Yii::$app->request->getReferrer() : ['index/index']);
        }
    }

    /**
     * Displays a single BooksSubscriptions model.
     * @param integer $id
     * @return mixed
     */
    public function actionView($id)
    {   
        $model = BooksSubscriptions::findOne($id);
        if($model === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        if (!Yii::$app->user->can('viewCompaniesData', ['model' => $model->company]) && !Yii::$app->user->can('viewOwnCompaniesData', ['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 BooksSubscriptions model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreate()
    {
        $modelCompany = $this->findModelCompany(intval(Yii::$app->request->get('id_company'))); 
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $modelCompany]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $modelCompany])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = new BooksSubscriptions(['scenario' => 'create', 'idCompany' => $modelCompany->id_company]);               
        $model->id_company = $modelCompany->id_company;
        
        $booksSearchModel = new BooksSearch();
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['BooksSearch']['id_company'] = $modelCompany->id_company;
        $dataProviderBooks = $booksSearchModel->search($queryParams);
        
        $outputParams = [
            'model' => $model,
            'modelCompany' => $modelCompany,
            'dataProviderBooks' => $dataProviderBooks,
            'booksSearchModel' => $booksSearchModel
        ];
        
        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, ['items', 'id_delivery_price_list']);
        }
        
        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->render('create', $outputParams);
            }            
            $model->id_company = $modelCompany->id_company;
                      
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('create', $outputParams);
            }   
            
            $transaction = Yii::$app->db->beginTransaction(); 
            
            $flag = $model->save(false);
            $flag = $flag && $model->saveRelationsWithBooks(); 
            $flag = $flag && $model->savePricesForBooksAvailableOnlyBySubscription();
            $flag = $flag && $model->repairWysiwygContents(['description']);
            if($flag) {
                $transaction->commit();
                $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_ADDED, $model->id_subscription, $model->id_company);
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['update', 'id' => $model->id_subscription]);
            } else {
                $transaction->rollBack();
                $model->rollBackWysiwygContentsChanges();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
            }
        }

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

    /**
     * Updates an existing BooksSubscriptions model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdate($id)
    {
        $model = $this->findModel($id);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model->setScenario('update');        
//        var_dump($model); exit;
        $idCompany = $model->id_company;
        $model->idCompany = $idCompany;
        
        $dataProviderAttachments = new \yii\data\ActiveDataProvider([
            'query' => $model->getAttachments()->orderBy('attachment_order'),
            'pagination' => false,
            'sort' => false
        ]);
        
        $booksSearchModel = new BooksSearch();
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['BooksSearch']['id_company'] = $model->id_company;
        $dataProviderBooks = $booksSearchModel->search($queryParams);
                
        $outputParams = [
            'model' => $model,
            'dataProviderAttachments' => $dataProviderAttachments,
            'dataProviderBooks' => $dataProviderBooks,
            'booksSearchModel' => $booksSearchModel
        ];
        
        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, ['items', 'id_delivery_price_list']);
        }
        
        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->render('update', $outputParams);
            }            
            $model->id_company = $idCompany;
            
            $transaction = Yii::$app->db->beginTransaction();
                      
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('update', $outputParams);
            }   
            
            $flag = $model->save(false);
            $flag = $flag && $model->saveRelationsWithBooks(); 
            $flag = $flag && $model->savePricesForBooksAvailableOnlyBySubscription();
            if($flag) {
                $transaction->commit();
                $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_MODIFIED, $model->id_subscription, $model->id_company);
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['update', 'id' => $model->id_subscription]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
            }
        }

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

    /**
     * Deletes an existing BooksSubscriptions model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDelete($id)
    {
        $model = \backend\models\BooksSubscriptions::findOne($id);        
        if($model === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        } 
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();  
        
        $flag = $model->savePricesForBooksAvailableOnlyBySubscription(true);        
        $flag = $flag && $model->delete();        
        if ($flag) {
            $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(['index', 'id' => $model->id_company]);
    }
    
    /**
     * Creates a new BooksSubscriptionsAttachments model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreateAttachment()
    {        
        if(($modelSubscription = \common\models\BooksSubscriptions::findOne(intval(Yii::$app->request->get('id_subscription', null)))) === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $modelSubscription->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $modelSubscription->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = new BooksSubscriptionsAttachments(['scenario' => 'create']);
        $model->id_subscription = $modelSubscription->id_subscription;
        
        $outputParams = [
            'model' => $model,
            'modelSubscription' => $modelSubscription
        ];
        
        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('create_attachment', $outputParams);
            }
                                  
            $model->loadFile();
            
            if(!empty($model->file)) {
                $model->url = null;
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create_attachment', $outputParams);
            }

            $newFilePath = (!empty($model->file)) ? $model->saveFile() : null;
            if($newFilePath === false) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                return $this->conditionalRender('create_attachment', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $modelsAttachments = BooksSubscriptionsAttachments::find()->where(['>=', 'attachment_order', $model->attachment_order])->andWhere(['id_subscription' => $model->id_subscription])->all();
            if(!empty($modelsAttachments)) {                
                array_walk($modelsAttachments, function($modelAttachment, $key) use (&$flag) {
                    $modelAttachment->attachment_order += 1;
                    if(!$flag || !$modelAttachment->save(false)) {
                        $flag = false;
                    }
                });
            }
            
            if ($flag && $model->save(false)) {
                $transaction->commit();
                $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_MODIFIED, $modelSubscription->id_subscription, $modelSubscription->id_company, 'Dodano załącznik.');
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_subscription]);
                } 
                else {
                    $model = new BooksSubscriptionsAttachments(['scenario' => 'create']);
                    $model->id_subscription = $modelSubscription->id_subscription;
                    $outputParams['model'] = $model;
                }
            } else {
                $transaction->rollBack();
                @unlink($newFilePath);
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_attachment', $outputParams);
    }
    
    /**
     * Updates an existing BooksSubscriptionsAttachments model.
     * If update is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdateAttachment($id)
    {
        $model = $this->findModelAttachment($id);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->subscription->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->subscription->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        if(!empty($model->url)) {
            $model->setScenario('update-url-version');
            $isUrlAttachment = true;
        } else {
            $model->setScenario('update-file-version');
            $isUrlAttachment = false;
        }
        
        $outputParams = [
            'model' => $model,
            'isUrlAttachment' => $isUrlAttachment
        ];
        
        if(Yii::$app->request->getIsPost()) {  
            $oldOrder = intval($model->getOldAttribute('attachment_order'));
            
            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('update_attachment', $outputParams);
            }
            
            if(!$isUrlAttachment) {
                $oldFilePath = $model->loadFile();
                $model->url = null;
            } else {
                $oldFilePath = null;
                $model->filename = null;
            }
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('update_attachment', $outputParams);
            }
            
            if(!$isUrlAttachment) {
                $newFilePath = $model->saveFile();
                if($newFilePath === false) {
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->conditionalRender('update_attachment', $outputParams);
                }
            } else {
                $newFilePath = null;
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $newOrder = intval($model->attachment_order);
            if($newOrder !== $oldOrder) {
                if($newOrder > $oldOrder) {
                    $newOrderComparisonSign = '<=';
                    $oldOrderComparisonSign = '>';
                    $differenceValue = 1;
                } else {
                    $newOrderComparisonSign = '<';
                    $oldOrderComparisonSign = '>=';
                    $differenceValue = -1;
                }
                
                $modelsAttachments = BooksSubscriptionsAttachments::find()
                    ->where([$newOrderComparisonSign, 'attachment_order', $newOrder])
                    ->andWhere([$oldOrderComparisonSign, 'attachment_order', $oldOrder])
                    ->andWhere(['id_subscription' => $model->id_subscription])
                    ->andWhere(['!=', 'id_attachment', $model->id_attachment])
                    ->all();
                if(!empty($modelsAttachments)) {   
                    foreach($modelsAttachments as $modelAttachment) {
                        $modelAttachment->attachment_order += $differenceValue;
                        $flag = $flag && $modelAttachment->save(false);
                        if(!$flag) {
                            break;
                        }
                    }
                }
            }
            
            if ($flag && $model->save(false)) {
                @unlink($oldFilePath);
                $transaction->commit();
                $this->createEntryForUserChange(UserChangeType::BOOK_SUBSCRIPTION_MODIFIED, $model->subscription->id_subscription, $model->subscription->id_company, 'Zmodyfikowano załącznik.');
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_subscription]);
                }
            } else {
                @unlink($newFilePath);
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('update_attachment', $outputParams);
    }

    /**
     * Deletes an existing BooksSubscriptionsAttachments model.
     * If deletion is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeleteAttachment($id)
    {
        $model = $this->findModelAttachment($id);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->subscription->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->subscription->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $flag = true;
        $modelsAttachments = BooksSubscriptionsAttachments::find()
            ->andWhere(['>', 'attachment_order', $model->attachment_order])
            ->andWhere(['id_subscription' => $model->id_subscription])
            ->andWhere(['!=', 'id_attachment', $model->id_attachment])
            ->all();
        if(!empty($modelsAttachments)) {                
            array_walk($modelsAttachments, function($modelAttachment, $key) use (&$flag) {
                $modelAttachment->attachment_order -= 1;
                if(!$flag || !$modelAttachment->save(false)) {
                    $flag = false;
                }
            });
        }
                
        if($flag && $model->delete() !== false) {
            $transaction->commit();
        } else {
            $transaction->rollBack();
        }        
        
        return Yii::$app->getResponse()->redirect(['bookssubscriptions/update', 'id' => $model->id_subscription], 302, false);
    }

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