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

namespace backend\controllers;

use Yii;
use common\models\Books;
use common\models\Companies;
use common\models\BookstoreCategories;
use common\models\PortalsHasBookstoreCategories;
use common\models\BooksTags;
use common\models\BooksAttachments;
use common\models\BooksPhotos;
use backend\models\BooksSearch;
use backend\models\PublishingHousesSearch;
use backend\models\CompaniesSearch;
use backend\models\BookstoreBatchChangePricesForm;
use common\models\types\UserChangeType;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\ForbiddenHttpException;
use yii\web\BadRequestHttpException;
use yii\caching\TagDependency;
use yii\web\Response;
use yii\bootstrap\ActiveForm;
use yii\data\ActiveDataProvider;
use frontend\models\IndexBooks;

/**
 * BooksController implements the CRUD actions for Books model.
 */
class BooksController extends Controller
{
    use \backend\components\traits\ControllerFunctions;
    
    public function actionImportFromAllegro()
    {
        $id = Yii::$app->request->get('id_company', null);
//        exit;
        $modelCompany = $this->findModelCompany($id);
        
        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.'));
        }
        
        if(\common\models\BooksImportsFromAllegro::find()->where(['id_company' => $modelCompany->id_company])->exists()) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Import jest już wykonywany - zostaniesz poinformowany mailowo o jego zakończeniu.'));
            return $this->redirect(['index', 'id' => $modelCompany->id_company]);
        }
        
        $clientId = Yii::$app->params['allegroAPI']['clientId'];
        $clientSecret = Yii::$app->params['allegroAPI']['clientSecret'];
        $redirectUrl = Yii::$app->params['backendBaseUrl'].'/books/import-from-allegro?id_company='.$modelCompany->id_company; //1589
        
        if(!Yii::$app->request->get('code')) {
            $length = random_int(43, 128);
            $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
            $max = mb_strlen($keyspace, '8bit') - 1;
            $codeVerifier = '';
            for($i = 0; $i < $length; ++$i) {
                $codeVerifier .= $keyspace[random_int(0, $max)];
            }      
            Yii::$app->session->set('booksImportFromAllegroCodeVerifier', $codeVerifier);
            
            $codeChallenge = rtrim(strtr(base64_encode(hash('sha256', $codeVerifier, true)), '+/', '-_'), '=');
            $urlForAuth = Yii::$app->params['allegroAPI']['authBaseUrl'].'/auth/oauth/authorize?response_type=code&client_id='.$clientId.'&redirect_uri='.$redirectUrl.'&code_challenge_method=S256&code_challenge='.$codeChallenge.'&prompt=confirm';

            return $this->render('import_from_allegro', [
                'modelCompany' => $modelCompany,
                'urlForAuth' => $urlForAuth,
            ]);
        } else {
            $code = Yii::$app->request->get('code');
            
            $postData = [
                "grant_type" => "authorization_code",
                "code" => $code,
                "redirect_uri" => $redirectUrl,
                "code_verifier" => Yii::$app->session->get('booksImportFromAllegroCodeVerifier'),
            ];
            $headers = array(
                'Authorization: Basic '.base64_encode($clientId.':'.$clientSecret),
                'Accept: application/json'
            );
            
            $ch = curl_init();
            curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
            curl_setopt($ch, CURLOPT_USERNAME, $clientId);
            curl_setopt($ch, CURLOPT_PASSWORD, $clientSecret);
            curl_setopt($ch, CURLOPT_URL, Yii::$app->params['allegroAPI']['authBaseUrl'].'/auth/oauth/token');
            curl_setopt($ch, CURLOPT_POST, 1);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
            curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
            curl_setopt($ch, CURLOPT_HEADER, 0);
            //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
            //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);

            $tokenResult = curl_exec($ch);
            $resultCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
            curl_close($ch);

            if($tokenResult === false || $resultCode !== 200) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas pobierania danych z zewnętrznej usługi.')); 
                return $this->redirect(['index', 'id' => $modelCompany->id_company]);
            }

            $tokenObject = json_decode($tokenResult);

//            echo($tokenObject->access_token);
//            echo('<br><br>');
//            echo($tokenObject->refresh_token);
//            echo('<br><br>');
//            exit;
            
            $accessToken = $tokenObject->access_token;
            $refreshToken = $tokenObject->refresh_token;

            $limit = 1000; 
            $idsOffers = [];

            $resultObject = $this->getOffersFromAllegro($accessToken, $limit);
            if(!$resultObject) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas pobierania danych z zewnętrznej usługi.')); 
                return $this->redirect(['index', 'id' => $modelCompany->id_company]);
            }

            foreach($resultObject->offers as $offer) {
                $idsOffers[$offer->id] = $offer->id;
            }

            if($resultObject->totalCount > $limit) {
                $numberOfRequests = ceil($resultObject->totalCount / $limit);

                for($i = 1; $i <= $numberOfRequests; $i++) {
                    $resultObject = $this->getOffersFromAllegro($accessToken, $limit, $limit * $i);
                    if(!$resultObject) {
                        Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas pobierania danych z zewnętrznej usługi.')); 
                        return $this->redirect(['index', 'id' => $modelCompany->id_company]);
                    }

                    foreach($resultObject->offers as $offer) {
                        $idsOffers[$offer->id] = $offer->id;
                    }
                }
            }

            $model = new \common\models\BooksImportsFromAllegro();
            $model->id_company = $modelCompany->id_company;
            $model->ids_offers = array_values($idsOffers);;
            $model->access_token = $accessToken;
            $model->refresh_token = $refreshToken;
            $model->access_token_expiry_datetime = new \MongoDB\BSON\UTCDateTime((time() + (Yii::$app->params['allegroAPI']['accessTokenExpiryTime'] * 24 * 3600)) * 1000);
            $model->refresh_token_expiry_datetime = new \MongoDB\BSON\UTCDateTime((time() + (Yii::$app->params['allegroAPI']['refreshTokenExpiryTime'] * 24 * 3600)) * 1000);

            if($model->save()) {
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Zlecenie importu zostało zarejestrowane - zostaniesz poinformowany mailowo o jego zakończeniu.'));  
            } else {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
            }
            return $this->redirect(['index', 'id' => $modelCompany->id_company]);
        }        
    }
    
    protected function getOffersFromAllegro($token, $limit = 1000, $offset = 0)
    {
        $headers = array(
            'Authorization: Bearer '.$token,
            'Accept: application/vnd.allegro.public.v1+json'
        );
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, Yii::$app->params['allegroAPI']['apiBaseUrl'].'/sale/offers?limit='.$limit.'&offset='.$offset);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_HEADER, 0);
        //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);

        $result = curl_exec($ch);
        $resultCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if($result === false || $resultCode !== 200) {
            return false;
        }

        return json_decode($result);
    }
    
    /**
     * Lists all company Books 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 BooksSearch();
        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['BooksSearch']['id_company'] = $modelCompany->id_company;
        
        $dataProvider = $searchModel->search($queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
            'modelCompany' => $modelCompany
        ]);
    }
    
     /**
     * Lists all Books models.
     * @return mixed
     */
    public function actionIndexAll()
    {
        if (!Yii::$app->user->can('indexAllBooks')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new BooksSearch();        
        $queryParams = Yii::$app->request->queryParams;
        $dataProvider = $searchModel->search($queryParams);

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

    /**
     * Lists all company Books 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 BooksSearch();
        
        $queryParams = Yii::$app->request->queryParams;
        $queryParams['BooksSearch']['id_company'] = $modelCompany->id_company;
        
        $dataProvider = $searchModel->search($queryParams);
        
        $modelForm = new BookstoreBatchChangePricesForm();
        $modelForm->setScenario('books');
        $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.'));
        }
        
        $idBook = Yii::$app->request->post('idItem');
        if(empty($idBook)) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $model = $this->findModel($idBook);
        
        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);
        
        if($fieldName === 'price') {
            //@todo odkomentować na testach
            $flag = $flag && IndexBooks::refreshRecord($model->id_book);
        }
        
        if($flag) {
            $transaction->commit(); 
            //@todo odkomentować na testach
            $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $model->id_book, $model->id_company);
            if($fieldName === 'price') {
                $cacheTags = ['book_'.$model->id_book];
                $modifiedPortals = PortalsHasBookstoreCategories::find()
                        ->select(['id_portal'])
                        ->where(['id_category' => $model->getRelationsWithCategories()->select(['id_category'])->column()])
                        ->groupBy('id_portal')
                        ->column();                
                if(!empty($modifiedPortals)) {                    
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                    }
                }
                TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
            }
            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('books');
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $modelForm->load(Yii::$app->request->post())) {
            Yii::$app->response->format = Response::FORMAT_JSON;
            return ActiveForm::validate($modelForm, ['operation_type', 'ids_items']);
        }
        
        if(Yii::$app->request->getIsPost()) {
//            var_dump($_POST, Yii::$app->request->getReferrer()); exit;
            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']);
            } 
            
            $flag = $modelForm->save(false);
            foreach($modelForm->ids_items as $idBook) {
                //@todo odkomentować na testach
                $flag = $flag && IndexBooks::refreshRecord($idBook);
            }
            
            if($flag) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                $cacheTags = [];
                foreach($modelForm->ids_items as $idBook) {
                    //@todo odkomentować na testach
                    $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $idBook, $modelCompany->id_company);
                    $cacheTags = ['book_'.$idBook];
                }
                $modifiedPortals = PortalsHasBookstoreCategories::find()->select(['id_portal'])->where(['id_category' => $modelForm->getIdsCategoriesFromBooks()])->groupBy('id_portal')->column();                
                if(!empty($modifiedPortals)) {                    
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                    }
                }
                TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
            } else {
                $transaction->rollBack();
                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 Books model.
     * @param integer $id
     * @return mixed
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
        
        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.'));
        }
        
        $categories = BookstoreCategories::find()->select(['id_category', 'name', 'id_parent_category'])->indexBy('id_category')->asArray()->all();
        $selectedCategories = $model->getRelationsWithCategories()->select(['id_category'])->column();        
        $categoriesPathes = [];
        foreach($selectedCategories as $idSelectedCategory) {
            $path = '';
            $idParentCategory = $categories[$idSelectedCategory]['id_parent_category'];
            while(!empty($idParentCategory)) {
                $path .= $path.' -> '.$categories[$idParentCategory]['name'];
                $idParentCategory = $categories[$idParentCategory]['id_parent_category'];
            }            
            $path .= ' -> '.$categories[$idSelectedCategory]['name'];            
            $categoriesPathes[] = ltrim($path, ' -> ');
        }
        
        return $this->render('view', [
            'model' => $model,
            'categoriesPathes' => $categoriesPathes
        ]);
    }

    /**
     * Creates a new Books 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 \backend\models\Books(['scenario' => 'create', 'id_company' => $modelCompany->id_company]); 
        
        $model->listTags = [];
        $model->listCategories = [];

        $categoriesTree = BookstoreCategories::getJSONCategoryTree();
        
        $outputParams = [
            'model' => $model,
            'modelCompany' => $modelCompany,
            'categoriesTree' => $categoriesTree
        ];
        
        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_publishing_house', 'id_delivery_price_list', 'release_date', 'release_date_paper_version', 'release_date_electronic_version', 'listTags', 'listCategories', 'listSubscriptions']);
        }
        
        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;
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $model->loadImageFile();
                      
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('create', $outputParams);
            }   
            
            $listCategories = $model->listCategories;
            
            $flag = $model->save(false);
            $flag = $flag && $model->saveTags(); 
            $flag = $flag && $model->saveCategories();
            $flag = $flag && $model->saveSubscriptions();
            $flag = $flag && $model->saveGoogleIndexingUrls($listCategories);
            $flag = $flag && $model->repairWysiwygContents(['description', 'table_of_contents']);
            $flag = $flag && IndexBooks::refreshRecord($model->id_book);
            if($flag) {
                $newImagePath = $model->saveImageFile();
                if($newImagePath === false) {
                    $transaction->rollBack();
                    IndexBooks::deleteRecord($model->id_book);
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->render('create', $outputParams);
                } 
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));                 
                $modifiedPortals = PortalsHasBookstoreCategories::find()->select(['id_portal'])->where(['id_category' => $model->listCategories])->groupBy('id_portal')->column();
                if(!empty($modifiedPortals)) {
                    $cacheTags = [];
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                    }
                    TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
                }
                $this->createEntryForUserChange(UserChangeType::BOOK_ADDED, $model->id_book, $model->id_company);
                return $this->redirect(['update', 'id' => $model->id_book]);
            } 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 Books 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');        
        
//        $idCompany = $model->id_company;
//        $model->idCompany = $idCompany;
        
        $dataProviderAttachments = new ActiveDataProvider([
            'query' => $model->getAttachments()->orderBy('attachment_order'),
            'pagination' => false,
            'sort' => false
        ]);
        
        $dataProviderPhotos = new ActiveDataProvider([
            'query' => $model->getPhotos()->orderBy('photo_order'),
            'pagination' => false,
            'sort' => false
        ]);
        
        $checkedCategories = $model->getRelationsWithCategories()->select(['id_category'])->column();        
        $categoriesTree = BookstoreCategories::getJSONCategoryTree($checkedCategories);
        
        $outputParams = [
            'model' => $model,
            'dataProviderAttachments' => $dataProviderAttachments,
            'dataProviderPhotos' => $dataProviderPhotos,
            'categoriesTree' => $categoriesTree
        ];
        
        if(Yii::$app->request->isAjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = Response::FORMAT_JSON;
            return ActiveForm::validate($model, ['id_publishing_house', 'id_delivery_price_list', 'release_date', 'release_date_paper_version', 'release_date_electronic_version', 'listTags', 'listCategories', 'listSubscriptions']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            $oldCategories = $model->listCategories;
            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();
            
            $oldImagePath = $model->loadImageFile();
                      
            if(!$model->validate()) {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('update', $outputParams);
            }  
            
            $listCategories = $model->listCategories;
            
            $flag = $model->save(false);
            $flag = $flag && $model->saveTags();             
            $flag = $flag && $model->saveCategories(); 
            $flag = $flag && $model->saveSubscriptions();
            $flag = $flag && $model->saveGoogleIndexingUrls($listCategories, $oldCategories);
            $flag = $flag && IndexBooks::refreshRecord($model->id_book);
            if($flag) {                
                $newImagePath = $model->saveImageFile();
                if($newImagePath === false) {
                    $transaction->rollBack();
                    IndexBooks::deleteRecord($model->id_book);
                    Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                    return $this->render('update', $outputParams);
                }  
                if(!empty($oldImagePath)) {
                    Books::deleteImage($oldImagePath);
                }
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                $modifiedPortals = PortalsHasBookstoreCategories::find()->select(['id_portal'])->where(['id_category' => array_unique(array_merge($checkedCategories, $model->listCategories))])->groupBy('id_portal')->column();
                $cacheTags = ['book_'.$model->id_book];
                if(!empty($modifiedPortals)) {                    
                    foreach($modifiedPortals as $idPortal) {
                        $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                    }
                }
                TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
                $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $model->id_book, $model->id_company);
                return $this->redirect(['update', 'id' => $model->id_book]);
            } else {
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.')); 
                if(!empty($newImagePath)) {
                    @unlink($newImagePath);
                }
            }
        }

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

    /**
     * Deletes an existing Books model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDelete($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.'));
        }
        
        $categories = $model->getCategories()->select(['bookstore_categories.id_category', 'bookstore_categories.id_parent_category'])->indexBy('id_category')->asArray()->all();
        
        $idsCategories = [];
        if(!empty($categories)) {
            foreach($categories as $category) {
                $idCategory = intval($category['id_category']);
                $idsCategories[$idCategory] = $idCategory;
            }
            foreach($categories as $category) {
                $idParentCategory = intval($category['id_parent_category']);
                if(empty($idParentCategory) || isset($idsCategories[$idParentCategory])) {
                    continue;
                }
                
                $cat = $category;                
                do {
                    $cat = BookstoreCategories::find()->select(['id_category', 'id_parent_category'])->where(['id_category' => intval($cat['id_parent_category'])])->asArray()->one();
                    $idsCategories[intval($cat['id_category'])] = intval($cat['id_category']); 
                } while(!empty($cat['id_parent_category']));
            }
            unset($categories);
        }        
        $modifiedPortals = \common\models\PortalsHasBookstoreCategories::find()->select(['id_portal'])->where(['id_category' => $idsCategories])->distinct()->column();

        $transaction = Yii::$app->db->beginTransaction();     
        
        if ($model->delete() !== false) {
            $transaction->commit();
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.')); 
            $cacheTags = ['book_'.$model->id_book];
            if(!empty($modifiedPortals)) {
                $modifiedPortals = array_unique($modifiedPortals);
                foreach($modifiedPortals as $idPortal) {
                    $cacheTags[] = 'mainpage_box_bookstore_portal_'.$idPortal;                    
                }                
            }
            TagDependency::invalidate(Yii::$app->frontendCache, $cacheTags);
        } 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 BooksAttachments model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreateAttachment()
    {        
        if(($modelBook = Books::findOne(intval(Yii::$app->request->get('id_book', null)))) === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        } 
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $modelBook->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $modelBook->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = new BooksAttachments(['scenario' => 'create']);
        $model->id_book = $modelBook->id_book;
        
        $outputParams = [
            'model' => $model,
            'modelBook' => $modelBook
        ];
        
        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;
            
            $modelsBookAttachments = BooksAttachments::find()->where(['>=', 'attachment_order', $model->attachment_order])->andWhere(['id_book' => $model->id_book])->all();
            if(!empty($modelsBookAttachments)) {                
                array_walk($modelsBookAttachments, function($modelBookAttachment, $key) use (&$flag) {
                    $modelBookAttachment->attachment_order += 1;
                    if(!$flag || !$modelBookAttachment->save(false)) {
                        $flag = false;
                    }
                });
            }
            
            if ($flag && $model->save(false)) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.'));
                TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
                $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $modelBook->id_book, $modelBook->id_company, 'Dodano załącznik.');
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_book]);
                } 
                else {
                    $model = new BooksAttachments(['scenario' => 'create']);
                    $model->id_book = $modelBook->id_book;
                    $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 BooksAttachments 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->book->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->book->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) {
                    $modelsBookAttachments = BooksAttachments::find()
                        ->where(['<=', 'attachment_order', $newOrder])
                        ->andWhere(['>', 'attachment_order', $oldOrder])
                        ->andWhere(['id_book' => $model->id_book])
                        ->andWhere(['!=', 'id_attachment', $model->id_attachment])
                        ->all();
                    if(!empty($modelsBookAttachments)) {                
                        array_walk($modelsBookAttachments, function($modelBookAttachment, $key) use (&$flag) {
                            $modelBookAttachment->attachment_order -= 1;
                            if(!$flag || !$modelBookAttachment->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                } else {
                    $modelsBookAttachments = BooksAttachments::find()
                        ->where(['<', 'attachment_order', $oldOrder])
                        ->andWhere(['>=', 'attachment_order', $newOrder])
                        ->andWhere(['id_book' => $model->id_book])
                        ->andWhere(['!=', 'id_attachment', $model->id_attachment])
                        ->all();
                    if(!empty($modelsBookAttachments)) {                
                        array_walk($modelsBookAttachments, function($modelBookAttachment, $key) use (&$flag) {
                            $modelBookAttachment->attachment_order += 1;
                            if(!$flag || !$modelBookAttachment->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                }
            }
            
            if ($flag && $model->save(false)) {
                @unlink($oldFilePath);
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
                $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $model->book->id_book, $model->book->id_company, 'Zmodyfikowano załącznik.');
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_book]);
                }
            } 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 BooksAttachments 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->book->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->book->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $flag = true;
        $modelsBookAttachments = BooksAttachments::find()
            ->andWhere(['>', 'attachment_order', $model->attachment_order])
            ->andWhere(['id_book' => $model->id_book])
            ->andWhere(['!=', 'id_attachment', $model->id_attachment])
            ->all();
        if(!empty($modelsBookAttachments)) {                
            array_walk($modelsBookAttachments, function($modelBookAttachment, $key) use (&$flag) {
                $modelBookAttachment->attachment_order -= 1;
                if(!$flag || !$modelBookAttachment->save(false)) {
                    $flag = false;
                }
            });
        }
                
        if($flag && $model->delete() !== false) {
            $transaction->commit();
            TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
        } else {
            $transaction->rollBack();
        }        
        
        return Yii::$app->getResponse()->redirect(['books/update', 'id' => $model->id_book], 302, false);
    }
    
    /**
     * Creates a new BooksPhotos model.
     * If creation is successful, the browser will be redirected to the 'update' page.
     * @return mixed
     */
    public function actionCreatePhoto()
    {
        if(($modelBook = Books::findOne(intval(Yii::$app->request->get('id_book', null)))) === null) {
            throw new NotFoundHttpException('The requested page does not exist.');
        } 
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $modelBook->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $modelBook->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model = new BooksPhotos(['scenario' => 'create']);        
        $model->id_book = $modelBook->id_book;
        
        $outputParams = [
            'model' => $model,
            'modelBook' => $modelBook
        ];
        
        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_photo', $outputParams);
            }
                                  
            $model->loadImageFile();
            
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('create_photo', $outputParams);
            }

            $newFilePath = $model->saveImageFile();
            if($newFilePath === false) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                return $this->conditionalRender('create_photo', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $modelsBookPhotos = BooksPhotos::find()->where(['>=', 'photo_order', $model->photo_order])->andWhere(['id_book' => $model->id_book])->all();
            if(!empty($modelsBookPhotos)) {                
                array_walk($modelsBookPhotos, function($modelBookPhoto, $key) use (&$flag) {
                    $modelBookPhoto->photo_order += 1;
                    if(!$flag || !$modelBookPhoto->save(false)) {
                        $flag = false;
                    }
                });
            }
            
            if ($flag && $model->save(false)) {
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
                $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $modelBook->id_book, $modelBook->id_company, 'Dodano zdjęcie.');
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_book]);
                } 
                else {
                    $model = new BooksPhotos(['scenario' => 'create']);
                    $model->id_book = $modelBook->id_book;
                    $outputParams['model'] = $model;
                }
            } else {
                $transaction->rollBack();
                @unlink($newFilePath);
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('create_photo', $outputParams);
    }
    
    /**
     * Updates an existing BooksPhotos model.
     * If update is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionUpdatePhoto($id)
    {
        $model = $this->findModelPhoto($id);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->book->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->book->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $model->setScenario('update');
        
        $outputParams = [
            'model' => $model
        ];
        
        if(Yii::$app->request->getIsPost()) {  
            $oldOrder = intval($model->getOldAttribute('photo_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_photo', $outputParams);
            }
            
            $oldFilePath = $model->loadImageFile();
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->conditionalRender('update_photo', $outputParams);
            }
            
            $newFilePath = $model->saveImageFile();
            if($newFilePath === false) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas zapisywania pliku na serwerze.'));
                return $this->conditionalRender('update_photo', $outputParams);
            }
            
            $transaction = Yii::$app->db->beginTransaction();
            
            $flag = true;
            
            $newOrder = intval($model->photo_order);
            
            if($newOrder !== $oldOrder) {
                if($newOrder > $oldOrder) {
                    $modelsBookPhotos = BooksPhotos::find()
                        ->where(['<=', 'photo_order', $newOrder])
                        ->andWhere(['>', 'photo_order', $oldOrder])
                        ->andWhere(['id_book' => $model->id_book])
                        ->andWhere(['!=', 'id_photo', $model->id_photo])
                        ->all();
                    if(!empty($modelsBookPhotos)) {                
                        array_walk($modelsBookPhotos, function($modelBookPhoto, $key) use (&$flag) {
                            $modelBookPhoto->photo_order -= 1;
                            if(!$flag || !$modelBookPhoto->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                } else {
                    $modelsBookPhotos = BooksPhotos::find()
                        ->where(['<', 'photo_order', $oldOrder])
                        ->andWhere(['>=', 'photo_order', $newOrder])
                        ->andWhere(['id_book' => $model->id_book])
                        ->andWhere(['!=', 'id_photo', $model->id_photo])
                        ->all();
                    if(!empty($modelsBookPhotos)) {                
                        array_walk($modelsBookPhotos, function($modelBookPhoto, $key) use (&$flag) {
                            $modelBookPhoto->photo_order += 1;
                            if(!$flag || !$modelBookPhoto->save(false)) {
                                $flag = false;
                            }
                        });
                    }
                }
            }
            
            if ($flag && $model->save(false)) {
                BooksPhotos::deleteImage($oldFilePath);
                $transaction->commit();
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
                $this->createEntryForUserChange(UserChangeType::BOOK_MODIFIED, $model->book->id_book, $model->book->id_company, 'Zmodyfikowano zdjęcie.');
                if(!Yii::$app->request->isPjax) {
                    return $this->redirect(['update', 'id' => $model->id_book]);
                }
            } else {
                @unlink($newFilePath);
                $transaction->rollBack();
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));                
            }
        }
        
        return $this->conditionalRender('update_photo', $outputParams);
    }
    
    /**
     * Deletes an existing BooksPhoto model.
     * If deletion is successful, the browser will be redirected to the 'update' page.
     * @param integer $id
     * @return mixed
     */
    public function actionDeletePhoto($id)
    {
        $model = $this->findModelPhoto($id);
        
        if (!Yii::$app->user->can('modifyCompaniesData', ['model' => $model->book->company]) && !Yii::$app->user->can('modifyOwnCompaniesData', ['model' => $model->book->company])) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $transaction = Yii::$app->db->beginTransaction();
        
        $flag = true; 
        $modelsBookPhotos = BooksPhotos::find()
            ->andWhere(['>', 'photo_order', $model->photo_order])
            ->andWhere(['id_book' => $model->id_book])
            ->andWhere(['!=', 'id_photo', $model->id_photo])
            ->all();
        if(!empty($modelsBookPhotos)) {                
            array_walk($modelsBookPhotos, function($modelBookPhoto, $key) use (&$flag) {
                $modelBookPhoto->photo_order -= 1;
                if(!$flag || !$modelBookPhoto->save(false)) {
                    $flag = false;
                }
            });
        }
                
        if($flag && $model->delete() !== false) {
            $transaction->commit();
            TagDependency::invalidate(Yii::$app->frontendCache, ['book_'.$model->id_book]);
        } else {
            $transaction->rollBack();
        }        
        
        return Yii::$app->getResponse()->redirect(['books/update', 'id' => $model->id_book], 302, false);
    }    
    
    public function actionAutocompleteTags()
    {
        $phrase = Yii::$app->request->get('phrase');
        $tags = [];
        if(!empty($phrase['term'])) {
            $tags = BooksTags::find()->select(['name'])->where(['ilike', 'name', $phrase['term']])->orderBy('quantity')->asArray()->column();
        }
        Yii::$app->response->format = Response::FORMAT_JSON;
        
        return $tags;
    }
    
    public function actionPublishingHousesList()
    {
        if (!Yii::$app->user->can('indexPublishingHouses')) {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }
        
        $searchModel = new PublishingHousesSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

        return $this->renderAjax('publishing_houses_list', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionCompaniesList()
    {        
        if(Yii::$app->user->can('indexCompanies')) {
            //nic nie robimy
        } elseif(Yii::$app->user->can('indexAssignedCompanies')) {
            $queryParams['CompaniesSearch']['idOperator'] = Yii::$app->user->id;
        } elseif(Yii::$app->user->can('indexOwnCompanies')) {
            $queryParams['CompaniesSearch']['id_user'] = Yii::$app->user->id;
        } else {
            throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
        }        
        
        $searchModel = new CompaniesSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

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