Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/common/models/
Linux 9dbcd5f6333d 5.15.0-124-generic #134-Ubuntu SMP Fri Sep 27 20:20:17 UTC 2024 x86_64
Current File : /home/vmanager/www/common/models/Books.php
<?php

namespace common\models;

use Yii;
use yii\db\Expression;
use yii\behaviors\TimestampBehavior;
use common\components\behaviors\DeleteRelatedModelsBehavior;
use common\models\types\BookType;
use common\models\types\BookStatus;
use common\models\types\BookImportSource;

/**
 * This is the model class for table "books".
 *
 * @property integer $id_book
 * @property integer $id_company
 * @property integer $id_publishing_house
 * @property integer $id_delivery_price_list
 * @property string $book_type
 * @property string $isbn
 * @property string $image_filename
 * @property string $title
 * @property string $author
 * @property string $lead
 * @property string $description
 * @property string $table_of_contents
 * @property string $release_date
 * @property string $release_date_paper_version
 * @property string $release_date_electronic_version
 * @property string $price
 * @property string $price_paper_version
 * @property string $price_electronic_version
 * @property double $average_rating
 * @property string $release_cycle
 * @property integer $number_of_pages
 * @property string $status
 * @property string $dimensions_paper_version
 * @property double $weight_paper_version
 * @property string $formats_electronic_version
 * @property double $filesize_electronic_version
 * @property integer $or_paper_version
 * @property integer $or_electronic_version
 * @property integer $or_color_paper_version
 * @property integer $or_color_electronic_version
 * @property integer $or_chalk_paper
 * @property integer $or_hardcover
 * @property integer $or_sale_only_in_subscription;
 * @property string $url_order
 * @property string $external_source
 * @property string $external_id
 * @property string $created_at
 * @property string $updated_at
 *
 * @property Companies $company
 * @property PublishingHouses $publishingHouse
 * @property CompaniesDeliveryPriceLists $deliveryPriceList
 * @property CompaniesDeliveryPriceListsItems[] $deliveryPriceListItems
 * @property BooksAttachments[] $attachments
 * @property BooksHasBooksTags[] $relationsWithTags
 * @property BooksTags[] $tags
 * @property BooksHasBookstoreCategories[] $relationsWithCategories
 * @property BookstoreCategories[] $categories
 * @property BooksHasBooksSubscriptions[] $relationsWithSubscriptions
 * @property BooksSubscriptions[] $subscriptions
 * @property BooksPhotos[] $photos
 * @property BooksReviews[] $reviews
 * @property BooksPromoted[] $relationsWithPortalsWhereIsPromoted
 * @property BookstoreOrdersItems[] $ordersItems
 * @property BookstoreOrders[] $orders
 */
class Books extends \yii\db\ActiveRecord
{
    use \common\components\traits\ImagesVariants;
    use \common\components\traits\DirectoriesFunctions;
    
    public $file;
    public $orDeleteCurrentFile = 0;
    
    protected static $acceptedImageSizes = ['80x60', '100x120', '140x175', '180x180', '200x250', '300x350', '360x360', '540x540'];
    
    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return 'books';
    }
    
    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            [
                'class' => TimestampBehavior::className(),
                'value' => new Expression('LOCALTIMESTAMP'),
            ],
            [
                'class' => DeleteRelatedModelsBehavior::className(),
            ]
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function scenarios()
    {
        $scenarios = parent::scenarios();
        $scenarios['create'] = ['!id_company', 'id_publishing_house', 'book_type', 'isbn', 'image_filename', 'title', 'author', 'lead', 'description', 'table_of_contents', 
            'release_date', 'release_date_paper_version', 'release_date_electronic_version', 'price', 'price_paper_version', 'price_electronic_version', 'average_rating', 
            'release_cycle', 'number_of_pages', 'status', 'dimensions_paper_version', 'weight_paper_version', 'formats_electronic_version', 'filesize_electronic_version', 
            'or_paper_version', 'or_electronic_version', 'or_color_paper_version', 'or_color_electronic_version', 'or_chalk_paper', 'or_hardcover', 'orDeleteCurrentFile', 
            'url_order', 'or_sale_only_in_subscription', 'file', 'id_delivery_price_list', 'external_source', 'external_id'
        ];
        $scenarios['update'] = ['!id_company', 'id_publishing_house', 'book_type', 'isbn', 'image_filename', 'title', 'author', 'lead', 'description', 'table_of_contents', 
            'release_date', 'release_date_paper_version', 'release_date_electronic_version', 'price', 'price_paper_version', 'price_electronic_version', 'average_rating', 
            'release_cycle', 'number_of_pages', 'status', 'dimensions_paper_version', 'weight_paper_version', 'formats_electronic_version', 'filesize_electronic_version', 
            'or_paper_version', 'or_electronic_version', 'or_color_paper_version', 'or_color_electronic_version', 'or_chalk_paper', 'or_hardcover', 'orDeleteCurrentFile', 
            'url_order', 'or_sale_only_in_subscription', 'file', 'id_delivery_price_list'
        ];
        return $scenarios;                
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        $idCompany = $this->id_company;
        return [
            ['id_company', 'required'],
            ['id_company', 'number', 'integerOnly' => true, 'min' => 1],
            ['id_company', 'exist', 'targetClass' => Companies::className(), 'targetAttribute' => 'id_company'],
            
            ['id_publishing_house', 'required'],
            ['id_publishing_house', 'number', 'integerOnly' => true, 'min' => 1],
            ['id_publishing_house', 'exist', 'targetClass' => PublishingHouses::className(), 'targetAttribute' => 'id_publishing_house'],
            
            ['book_type', 'default', 'value' => BookType::BOOK],
            ['book_type', 'required'],
            ['book_type', 'in', 'range' => BookType::$values],
            
            ['isbn', 'default'],
            ['isbn', 'string', 'min' => 8, 'max' => 20],
            
            ['image_filename', 'default'],
            ['image_filename', 'string', 'min' => 5, 'max' => 255],

            ['file', 'image', 'extensions' => ['jpg', 'gif', 'png', 'webp'], 'maxFiles' => 1, 'maxSize' => 3145728, 'maxWidth' => 1920, 'maxHeight' => 1080, 'checkExtensionByMimeType' => true, 'skipOnEmpty' => true],
            
            ['title', 'required'],
            ['title', 'string', 'min' => 3, 'max' => 255],
            
            ['author', 'required'],
            ['author', 'string', 'min' => 3, 'max' => 255],
            
            ['lead', 'required'],
            ['lead', 'string'],
            
            ['description', 'required'],
            ['description', 'string'],
            
            ['table_of_contents', 'default'],
            ['table_of_contents', 'string'],

            ['release_date', 'required'],
            ['release_date', 'date', 'format' => 'yyyy-MM-dd'], 
            
            ['release_date_paper_version', 'default'],
            ['release_date_paper_version', 'date', 'format' => 'yyyy-MM-dd'], 
            
            ['release_date_electronic_version', 'default'],
            ['release_date_electronic_version', 'date', 'format' => 'yyyy-MM-dd'], 
            
            ['price', 'required'],
            ['price', 'number', 'numberPattern' => '/^[0-9]{1,8}(\.[0-9]{1,2}){0,1}$/i'],
            
            ['price_paper_version', 'default'],
            ['price_paper_version', 'number', 'numberPattern' => '/^[0-9]{1,8}(\.[0-9]{1,2}){0,1}$/i'],
            [
                'price_paper_version', 
                'required', 
                'when' => function($model) {
                    return ($model->or_paper_version === 1) ? true : false;
                },
                'whenClient' => "function (attribute, value) {
                    var fieldId = attribute.input.slice(1, attribute.input.lastIndexOf('-'));
                    var selectedValue = $('#'+fieldId+'-or_paper_version').val();
                    if(selectedValue == '1') {                      
                        return true;
                    }
                    else {
                        return false;
                    }
                }"
            ],
            
            ['price_electronic_version', 'default'],
            ['price_electronic_version', 'number', 'numberPattern' => '/^[0-9]{1,8}(\.[0-9]{1,2}){0,1}$/i'],
            [
                'price_electronic_version', 
                'required', 
                'when' => function($model) {
                    return ($model->or_electronic_version === 1) ? true : false;
                },
                'whenClient' => "function (attribute, value) {
                    var fieldId = attribute.input.slice(1, attribute.input.lastIndexOf('-'));
                    var selectedValue = $('#'+fieldId+'-or_electronic_version').val();
                    if(selectedValue == '1') {                      
                        return true;
                    }
                    else {
                        return false;
                    }
                }"
            ],
            
            ['average_rating', 'default', 'value' => 0.0],
            ['average_rating', 'required'],            
            ['average_rating', 'number', 'min' => 0.0, 'max' => 5.0],

            ['release_cycle', 'default'],
            ['release_cycle', 'string', 'max' => 255],
            
            ['number_of_pages', 'default'],
            ['number_of_pages', 'number', 'integerOnly' => true, 'min' => 1],
            
            ['status', 'default', 'value' => BookStatus::AVAILABLE],
            ['status', 'required'],
            ['status', 'in', 'range' => BookStatus::$values],
            
            ['dimensions_paper_version', 'default'],
            ['dimensions_paper_version', 'string', 'min' => 2, 'max' => 30],
            
            ['weight_paper_version', 'default'],
            ['weight_paper_version', 'number', 'numberPattern' => '/^[0-9]{1,8}(\.[0-9]{1,2}){0,1}$/i'],
            
            ['formats_electronic_version', 'default'],
            ['formats_electronic_version', 'string', 'min' => 3, 'max' => 50],
            
            ['filesize_electronic_version', 'default'],
            ['filesize_electronic_version', 'number', 'numberPattern' => '/^[0-9]{1,8}(\.[0-9]{1,2}){0,1}$/i'],

            ['or_paper_version', 'default', 'value' => 1],
            ['or_paper_version', 'required'],
            ['or_paper_version', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_electronic_version', 'default', 'value' => 0],
            ['or_electronic_version', 'required'],
            ['or_electronic_version', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_color_paper_version', 'default', 'value' => 0],
            ['or_color_paper_version', 'required'],
            ['or_color_paper_version', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_color_electronic_version', 'default', 'value' => 0],
            ['or_color_electronic_version', 'required'],
            ['or_color_electronic_version', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_chalk_paper', 'default', 'value' => 0],
            ['or_chalk_paper', 'required'],
            ['or_chalk_paper', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_hardcover', 'default', 'value' => 0],
            ['or_hardcover', 'required'],
            ['or_hardcover', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
            
            ['or_sale_only_in_subscription', 'default', 'value' => 0],
            ['or_sale_only_in_subscription', 'required'],
            ['or_sale_only_in_subscription', 'number', 'integerOnly' => true, 'min' => 0, 'max' => 1],
                        
            ['url_order', 'default'],
            ['url_order', 'url', 'validSchemes' => ['http', 'https'], 'defaultScheme' => 'http'],
                        
            ['id_delivery_price_list', 'default'],
            ['id_delivery_price_list', 'number', 'integerOnly' => true, 'min' => 1],
            ['id_delivery_price_list', 'exist', 'targetClass' => CompaniesDeliveryPriceLists::className(), 'targetAttribute' => 'id_price_list', 'filter' => ['id_company' => $idCompany]],
                        
            ['orDeleteCurrentFile', 'safe'],
                        
            ['external_source', 'default'],
            ['external_source', 'in', 'range' => BookImportSource::$values],
                        
            ['external_id', 'default'],
            ['external_id', 'string', 'min' => 1, 'max' => 30]
        ];
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id_book' => Yii::t('common-models', 'ID książki'),
            'id_company' => Yii::t('common-models', 'ID firmy'),
            'id_publishing_house' => Yii::t('common-models', 'ID wydawnictwa'),
            'id_delivery_price_list' => Yii::t('common-models', 'ID cennika dostaw'),
            'book_type' => Yii::t('common-models', 'Typ'),
            'isbn' => Yii::t('common-models', 'ISBN'),
            'image_filename' => Yii::t('common-models', 'Zdjęcie główne'),
            'title' => Yii::t('common-models', 'Tytuł'),
            'author' => Yii::t('common-models', 'Autor'),
            'lead' => Yii::t('common-models', 'Wstęp'),
            'description' => Yii::t('common-models', 'Opis'),
            'table_of_contents' => Yii::t('common-models', 'Spis treści'),
            'release_date' => Yii::t('common-models', 'Data wydania'),
            'release_date_paper_version' => Yii::t('common-models', 'Data wydania').' '.Yii::t('common-models', 'wersji papierowej'),
            'release_date_electronic_version' => Yii::t('common-models', 'Data wydania').' '.Yii::t('common-models', 'wersji elektronicznej'),
            'price' => Yii::t('common-models', 'Cena'),
            'price_paper_version' => Yii::t('common-models', 'Cena').' '.Yii::t('common-models', 'wersji papierowej'),
            'price_electronic_version' => Yii::t('common-models', 'Cena').' '.Yii::t('common-models', 'wersji elektronicznej'),
            'average_rating' => Yii::t('common-models', 'Ocena'),
            'release_cycle' => Yii::t('common-models', 'Cykl wydawniczy - informacje'),
            'number_of_pages' => Yii::t('common-models', 'Ilość stron'),
            'status' => Yii::t('common-models', 'Status'),
            'dimensions_paper_version' => Yii::t('common-models', 'Wymiary').' '.Yii::t('common-models', 'wersji papierowej'),
            'weight_paper_version' => Yii::t('common-models', 'Waga').' '.Yii::t('common-models', 'wersji papierowej'),
            'formats_electronic_version' => Yii::t('common-models', 'Formaty').' '.Yii::t('common-models', 'wersji elektronicznej'),
            'filesize_electronic_version' => Yii::t('common-models', 'Rozmiar').' '.Yii::t('common-models', 'wersji elektronicznej'),
            'or_paper_version' => Yii::t('common-models', 'Wersja papierowa'),
            'or_electronic_version' => Yii::t('common-models', 'Wersja elektroniczna'),
            'or_color_paper_version' => Yii::t('common-models', 'Druk kolorowy').' '.Yii::t('common-models', 'wersji papierowej'),
            'or_color_electronic_version' => Yii::t('common-models', 'Druk kolorowy').' '.Yii::t('common-models', 'wersji elektronicznej'),
            'or_chalk_paper' => Yii::t('common-models', 'Papier kredowy'),
            'or_hardcover' => Yii::t('common-models', 'Oprawa twarda'),
            'or_sale_only_in_subscription' => Yii::t('common-models', 'Tylko w prenumeracie'),
            'url_order' => Yii::t('common-models', 'Url zamówienia'),
            'external_source' => Yii::t('common-models', 'Źródło'),
            'external_id' => Yii::t('common-models', 'ID zewnętrzne'),
            'created_at' => Yii::t('common-models', 'Data utworzenia'),
            'updated_at' => Yii::t('common-models', 'Data aktualizacji'),
            
            'file' => Yii::t('common-models', 'Zdjęcie główne'),
        ];
    }
    
    public static function getDependentModels() 
    {
        return [
//            'relationsWithTags',
//            'relationsWithCategories',
//            'relationsWithSubscriptions',
            'attachments',
            'photos',
            'reviews'
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function beforeDelete() 
    {
        $flag = true;  
        
        $modelsRelationsWithPortalsWhereIsPromoted = $this->relationsWithPortalsWhereIsPromoted;
        if(!empty($modelsRelationsWithPortalsWhereIsPromoted)) {
            $pairsPortalAndType = [];
            foreach($modelsRelationsWithPortalsWhereIsPromoted as $modelRelationWithPortalWhereIsPromoted) {
                $pairsPortalAndType[$modelRelationWithPortalWhereIsPromoted->id_portal.'|'.$modelRelationWithPortalWhereIsPromoted->promotion_type] = true;
            }
            
            foreach($pairsPortalAndType as $pairPortalAndType => $flagValue) {
                list($idPortal, $promotionType) = explode("|", $pairPortalAndType);
                $modelsBooksPromoted = \common\models\BooksPromoted::find()
                    ->andWhere(['id_portal' => $idPortal, 'promotion_type' => $promotionType])
                    ->andWhere(['!=', 'id_book', $this->id_book])
                    ->orderBy('book_order ASC')
                    ->all();
                if(!empty($modelsBooksPromoted)) {    
                    $counter = 1;
                    foreach($modelsBooksPromoted as $modelBookPromoted) {
                        $modelBookPromoted->book_order = $counter;
                        if(!$modelBookPromoted->save(false)) {
                            return false;
                        }
                        $counter++;
                    }
                }
            }
        }        
        
        $modelsBooksTags = $this->tags;
        if($flag && !empty($modelsBooksTags)) {
            foreach($modelsBooksTags as $modelBooksTag) {
                $modelBooksTag->quantity -= 1;
                if($modelBooksTag->quantity > 0) {
                    if($modelBooksTag->save(false) === false) {
                        $flag = false;
                        break;
                    }
                } else {
                    if($modelBooksTag->delete() === false) {
                        $flag = false;
                        break;
                    }
                }
            }
        }

        if($flag) {
            return parent::beforeDelete();
        } else {
            return false;
        }
    }
    
    /**
     * @inheritdoc
     */
    public function afterDelete() 
    {
        parent::afterDelete();
        
        if(file_exists(Yii::getAlias('@booksImagesRealPath').'/'.$this->id_book.'/')) {
            $this->removeDir(Yii::getAlias('@booksImagesRealPath').'/'.$this->id_book.'/');
        }
        
        if(file_exists(Yii::getAlias('@sourcesRealPath').'/'.Yii::getAlias('@booksContentsImagesDirName').'/'.$this->id_book.'/')) {
            $this->removeDir(Yii::getAlias('@sourcesRealPath').'/'.Yii::getAlias('@booksContentsImagesDirName').'/'.$this->id_book.'/');
            $this->removeDir(Yii::getAlias('@sourcesThumbsRealPath').'/'.Yii::getAlias('@booksContentsImagesDirName').'/'.$this->id_book.'/', true);
        }
        
        if(file_exists(Yii::getAlias('@booksAttachmentsRealPath').'/'.$this->id_book.'/')) {
            $this->removeDir(Yii::getAlias('@booksAttachmentsRealPath').'/'.$this->id_book.'/');
        }
        
        \frontend\models\IndexBooks::deleteRecord($this->id_book);
    }
    
    public static function createImageFileName($baseName, $extension) 
    {
        $baseName = strtolower(iconv('UTF-8', 'ASCII//TRANSLIT', $baseName));
        $baseName = preg_replace('/\s+/i', '-', $baseName);
        $baseName = preg_replace('/[^a-zA-Z0-9_\-]/i', '', $baseName); 
        
        return $baseName.'-'.str_replace(' ', '', substr(microtime(), 2)).'.'.  strtolower($extension);
    }
    
    public function getImageUrl($absolute = false)
    {
        $path = ($absolute === true) ? Yii::getAlias('@booksImagesUrl') : Yii::getAlias('@booksImagesRealPath');
        return (!empty($this->image_filename)) ? $path.'/'.$this->id_book.'/'.$this->image_filename : null;        
    }
    
    public static function getImageUrlForBook($filename, $idBook, $absolute = false)
    {
        if(empty($filename)) {
            return null;
        }
        $path = ($absolute === true) ? Yii::getAlias('@booksImagesUrl') : Yii::getAlias('@booksImagesRealPath');
        return $path.'/'.$idBook.'/'.$filename;
    }
    
    public function loadImageFile()
    {
        $oldImagePath = null;  
        if($this->isNewRecord) {
            $this->file = \yii\web\UploadedFile::getInstance($this, 'file');
            if($this->file) {
                $this->image_filename = self::createImageFileName($this->file->baseName, $this->file->extension);
            }
        } else {
            $oldImageFilename = $this->getOldAttribute('image_filename');
            $orDeleteCurrentFile = intval($this->orDeleteCurrentFile);            
            if($orDeleteCurrentFile !== 1) {                
                $this->file = \yii\web\UploadedFile::getInstance($this, 'file');
                if($this->file) {        
                    $oldImagePath = Yii::getAlias('@booksImagesRealPath').'/'.$this->id_book.'/'.$oldImageFilename;
                    $this->image_filename = self::createImageFileName($this->file->baseName, $this->file->extension);
                }
                else {
                    $this->image_filename = (!empty($oldImageFilename)) ? $oldImageFilename : null;
                }
            }
            elseif(!empty($oldImageFilename)) {
                $oldImagePath = Yii::getAlias('@booksImagesRealPath').'/'.$this->id_book.'/'.$oldImageFilename;
                $this->image_filename = null;
            }
            else {
                $this->image_filename = null;
            }
        }
        
        return $oldImagePath;
    }
    
    public function saveImageFile()
    {
        $newImagePath = null;
        if($this->file) {
            $dir = Yii::getAlias('@booksImagesRealPath').'/'.$this->id_book.'/';
            if(!file_exists($dir)) {
                mkdir($dir, 0777, true);
            }
            $newImagePath = $dir.$this->image_filename;

            if(!$this->file->saveAs($newImagePath)) {
                return false;
            } 
        }
        
        return $newImagePath;
    }

    public static function calculateAvarageRating($id)
    {
        $model = Books::findOne($id);
        if($model === null) {
            return false;
        }
        $reviewsRatings = BooksReviews::find()->select(['rating'])->where(['id_book' => $id, 'or_accepted' => 1])->column();
        if(empty($reviewsRatings)) {
            $model->average_rating = 0.0;
        } else {
            $model->average_rating = array_sum($reviewsRatings) / count($reviewsRatings);
        }
        
        if(!$model->validate() || !$model->save(false)) {
            return false;
        }
        
        return true;
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCompany()
    {
        return $this->hasOne(Companies::className(), ['id_company' => 'id_company']);
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getPublishingHouse()
    {
        return $this->hasOne(PublishingHouses::className(), ['id_publishing_house' => 'id_publishing_house']);
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getDeliveryPriceList()
    {
        return $this->hasOne(CompaniesDeliveryPriceLists::className(), ['id_price_list' => 'id_delivery_price_list']);
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getDeliveryPriceListItems()
    {
        return $this->hasMany(CompaniesDeliveryPriceListsItems::className(), ['id_price_list' => 'id_delivery_price_list']);
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getAttachments()
    {
        return $this->hasMany(BooksAttachments::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithTags()
    {
        return $this->hasMany(BooksHasBooksTags::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getTags()
    {
        return $this->hasMany(BooksTags::className(), ['id_tag' => 'id_tag'])->via('relationsWithTags');
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getPhotos()
    {
        return $this->hasMany(BooksPhotos::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getReviews()
    {
        return $this->hasMany(BooksReviews::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithCategories()
    {
        return $this->hasMany(BooksHasBookstoreCategories::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getCategories()
    {
        return $this->hasMany(BookstoreCategories::className(), ['id_category' => 'id_category'])->via('relationsWithCategories');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithSubscriptions()
    {
        return $this->hasMany(BooksHasBooksSubscriptions::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getSubscriptions()
    {
        return $this->hasMany(BooksSubscriptions::className(), ['id_subscription' => 'id_subscription'])->via('relationsWithSubscriptions');
    }
    
        /**
     * @return \yii\db\ActiveQuery
     */
    public function getRelationsWithPortalsWhereIsPromoted()
    {
        return $this->hasMany(BooksPromoted::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getOrdersItems()
    {
        return $this->hasMany(BookstoreOrdersItems::className(), ['id_book' => 'id_book'])->inverseOf('book');
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getOrders()
    {
        return $this->hasMany(BookstoreOrders::className(), ['id_order' => 'id_order'])->via('orderItems');
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com