Devil Killer Is Here MiNi Shell
MiNi SheLL

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

namespace backend\models;

use Yii;
use yii\helpers\ArrayHelper;
use common\components\validators\CountValidator;
use common\models\ArticlesTags;
use common\models\ArticlesHasArticlesTags;
use common\models\ArticlesHasPortals;
use common\models\ArticlesHasArticlesCategories;
use common\models\ArticlesCategories;
use common\models\Fairs;
use common\models\FairsHasArticles;
use common\models\Portals;
use backend\components\db\WysiwygInterface;

/**
 * ArticlesSearch represents the model behind the search form about `\common\models\Articles`.
 */
class Articles extends \common\models\Articles implements WysiwygInterface
{
    use \backend\components\traits\WysiwygFunctions;
    
    public $listTags;
    public $listPortals;
    public $listCategories;
    public $listFairs;
    
    public $listEmails;
    
    /**
     * @inheritdoc
     */
    public function rules()
    {
        $rules = parent::rules();
        return ArrayHelper::merge($rules, [
            ['listTags', 'required'],
            ['listTags', 'each', 'rule' => ['string', 'min' => 2, 'max' => 80, 'tooShort' => Yii::t('backend', 'Tag musi zawierać przynajmniej {min} znaków.'), 'tooLong' => Yii::t('backend', 'Tag może zawierać maksymalnie {max} znaków.')]],
            ['listTags', CountValidator::className(), 'min' => 1],
            
            ['listPortals', 'required'],
            ['listPortals', 'each', 'rule' => ['number', 'integerOnly' => true, 'min' => 1]],
            ['listPortals', 'each', 'rule' => ['exist', 'targetClass' => Portals::className(), 'targetAttribute' => 'id_portal']],
            ['listPortals', CountValidator::className(), 'min' => 1],
            
            ['listEmails', 'required'],
            ['listEmails', 'each', 'rule' => ['email']],
            
            ['listCategories', 'required'],
            ['listCategories', 'validateRequireForCategories'],
            ['listCategories', 'each', 'rule' => ['number', 'integerOnly' => true, 'min' => 1]],
            ['listCategories', 'each', 'rule' => ['exist', 'targetClass' => ArticlesCategories::className(), 'targetAttribute' => 'id_category']],
            
            ['listFairs', 'each', 'rule' => ['number', 'integerOnly' => true, 'min' => 1]],
            ['listFairs', 'each', 'rule' => ['exist', 'targetClass' => Fairs::className(), 'targetAttribute' => 'id_fair']],
        ]);
    }

    /**
     * @inheritdoc
     */
    public function scenarios()
    {
        $scenarios = parent::scenarios();
        $scenarios['create'] = ArrayHelper::merge($scenarios['create'], ['listTags', 'listPortals', 'listEmails', 'listCategories', 'listFairs']);
        $scenarios['update'] = ArrayHelper::merge($scenarios['update'], ['listTags', 'listPortals', 'listEmails', 'listCategories', 'listFairs']);
        return $scenarios;
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels() 
    {
        return ArrayHelper::merge(parent::attributeLabels(), [
            'listTags' => Yii::t('backend', 'Tagi'),
            'listPortals' => Yii::t('backend', 'Portale'),
            'listEmails' => Yii::t('backend', 'Poinformuj - e-maile'),
            'listCategories' => Yii::t('backend', 'Kategorie'),
            'listFairs' => Yii::t('backend', 'Powiązane targi')
        ]);
    }
    
    public function beforeValidate() 
    {
        if(parent::beforeValidate()) {
            if(!empty($this->listEmails)) {
                $this->listEmails = array_unique($this->listEmails);
            }            
//            $this->emails = json_encode($this->listEmails);
            $this->emails = $this->listEmails; //#JSON-hack#
            return true;
        } else {
            return false;
        }
        
    }
    
    public function afterFind() 
    {
        parent::afterFind();
        $this->listTags = $this->getTags()->select(['name'])->column();
        $this->listPortals = $this->getPortals()->select(['id_portal'])->column();
        $this->listCategories = $this->getCategories()->select(['id_category'])->column();
//        $this->listEmails = json_decode($this->emails, true);
        $this->listEmails = $this->emails; //#JSON-hack#
    }
    
    public function afterSave($insert, $changedAttributes)
    {
        parent::afterSave($insert, $changedAttributes);
        $this->idItem = $this->id_article;
    }
    
    public function validateRequireForCategories($attribute, $params)
    {
        if(empty($this->$attribute)) {
            $this->addError($attribute, Yii::t('backend', 'Dla każdego wybranego portalu musisz zaznaczyć minimum jedną kategorię.'));
        } elseif(!empty($this->listPortals)) {
            $idsPortalsFromCategories = \common\models\ArticlesCategories::find()->select(['id_portal'])->where(['id_category' => $this->$attribute])->distinct()->column();
            
            foreach($this->listPortals as $idSelectedPortal) {
                if(!in_array($idSelectedPortal, $idsPortalsFromCategories)) {
                    $this->addError($attribute, Yii::t('backend', 'Dla każdego wybranego portalu musisz zaznaczyć minimum jedną kategorię.'));
                    break;
                }
            }
        }
    }

    public function saveTags()
    {
        if(empty($this->listTags)) {
            return true;
        }
        
        $modelsArticlesTags = ArticlesTags::find()->where(['name' => $this->listTags])->indexBy('name')->all();
        
        if(!$this->isNewRecord) {
            $modelsArticlesHasArticlesTags = $this->getRelationsWithTags()->indexBy('id_tag')->all();
        } else {
            $modelsArticlesHasArticlesTags = [];
        }
             
        $flag = true;
        
        foreach($this->listTags as $tag) {
            if(isset($modelsArticlesTags[$tag])) {
                $modelArticleTag = $modelsArticlesTags[$tag];
                if(!isset($modelsArticlesHasArticlesTags[$modelArticleTag->id_tag])) {
                    //zwiększamy licznik taga i dodajemy powiązanie                            
                    $modelArticleTag->quantity += 1;
                    $flag = $modelArticleTag->save(false);
                    if(!$flag) {
                        break;
                    }

                    $modelArticleHasTag = new ArticlesHasArticlesTags();
                    $modelArticleHasTag->id_article = $this->id_article;
                    $modelArticleHasTag->id_tag = $modelArticleTag->id_tag;

                    $flag = $modelArticleHasTag->validate();
                    $flag = $flag && $modelArticleHasTag->save(false);
                    if(!$flag) {
                        break;
                    }
                }
                else {
                    //nic nie robimy poza "oznaczeniem", że dane obecne powiązanie uwzględniliśmy podczas przetwarzania
                    unset($modelsArticlesHasArticlesTags[$modelArticleTag->id_tag]);
                }
            }
            else {
                //dodajemy tag oraz powiązanie
                $modelArticleTag = new ArticlesTags(['scenario' => 'create']);
                $modelArticleTag->name = $tag;
                $modelArticleTag->quantity = 1;

                $flag = $modelArticleTag->validate();
                $flag = $flag && $modelArticleTag->save(false);
                if(!$flag) {
                    break;
                }

                $modelArticleHasTag = new ArticlesHasArticlesTags();
                $modelArticleHasTag->id_article = $this->id_article;
                $modelArticleHasTag->id_tag = $modelArticleTag->id_tag;

                $flag = $modelArticleHasTag->validate();
                $flag = $flag && $modelArticleHasTag->save(false);
                if(!$flag) {
                    break;
                }  
            }                   
        }

        if($flag && !empty($modelsArticlesHasArticlesTags)) {
            foreach($modelsArticlesHasArticlesTags as $modelArticlesHasArticlesTags) {
                $modelArticleTag = $modelArticlesHasArticlesTags->tag;
                $modelArticleTag->quantity -= 1;
                if($modelArticleTag->quantity > 0) {                
                    $flag = $modelArticleTag->save(false);
                    $flag = $flag && $modelArticlesHasArticlesTags->delete();
                } else {
                    $flag = $modelArticleTag->delete();
                }
                
                if($flag === false) {
                    break;
                }
            }
        }
        
        return $flag;
    }
    
    public function savePortals()
    {
        if(empty($this->listPortals)) {
            return true;
        }
        
        if(!$this->isNewRecord) {
            $modelsArticlesHasPortals = $this->getRelationsWithPortals()->indexBy('id_portal')->all();
        } else {
            $modelsArticlesHasPortals = [];
        }
                
        $flag = true;
        foreach($this->listPortals as $idPortal) {
            if(!isset($modelsArticlesHasPortals[intval($idPortal)])) {
                $modelArticleHasPortal = new ArticlesHasPortals();
                $modelArticleHasPortal->id_article = $this->id_article;
                $modelArticleHasPortal->id_portal = intval($idPortal);

                $flag = $modelArticleHasPortal->validate();
                $flag = $flag && $modelArticleHasPortal->save(false);
                if(!$flag) {
                    break;
                }  
            }
            else {
                unset($modelsArticlesHasPortals[intval($idPortal)]);
            }
        }        
        
        if($flag && !empty($modelsArticlesHasPortals)) {
            foreach($modelsArticlesHasPortals as $modelArticleHasPortal) {
                $flag = $modelArticleHasPortal->delete();
                if($flag === false) {
                    break;
                }
            }
        }
        
        return $flag;
    }
    
    public function saveCategories()
    {
        if(empty($this->listCategories)) {
            return true;
        }
        
        $articlesCategories = ArticlesCategories::find()->select(['id_category', 'left', 'right'])->where(['id_category' => $this->listCategories])->indexBy('id_category')->asArray()->all();
        
        if(!$this->isNewRecord) {
            $modelsArticlesHasArticlesCategories = $this->getRelationsWithCategories()->indexBy('id_category')->all();
        } else {
            $modelsArticlesHasArticlesCategories = [];
        }
                
        $flag = true;
        foreach($this->listCategories as $idCategory) {
            $idCategory = intval($idCategory);
            if(!isset($modelsArticlesHasArticlesCategories[$idCategory]) && ($articlesCategories[$idCategory]['right'] - $articlesCategories[$idCategory]['left'] === 1)) {
                $modelArticleHasArticleCategory = new ArticlesHasArticlesCategories();
                $modelArticleHasArticleCategory->id_article = $this->id_article;
                $modelArticleHasArticleCategory->id_category = $idCategory;

                $flag = $modelArticleHasArticleCategory->validate();
                $flag = $flag && $modelArticleHasArticleCategory->save(false);
                if(!$flag) {
                    break;
                }  
            }
            else {
                unset($modelsArticlesHasArticlesCategories[$idCategory]);
            }
        }        
        
        if($flag && !empty($modelsArticlesHasArticlesCategories)) {
            foreach($modelsArticlesHasArticlesCategories as $modelArticleHasArticleCategory) {
                $flag = $modelArticleHasArticleCategory->delete();
                if($flag === false) {
                    break;
                }
            }
        }
        
        return $flag;
    }
    
    public function saveFairs()
    {
        if(empty($this->listFairs)) {
            return true;
        }
        
        if(!$this->isNewRecord) {
            $modelsFairsHasArticles = $this->getRelationsWithFairs()->indexBy('id_fair')->all();
        } else {
            $modelsFairsHasArticles = [];
        }
                
        $flag = true;
        foreach($this->listFairs as $idFair) {
            $idFair = intval($idFair);
            if(!isset($modelsFairsHasArticles[$idFair])) {
                $modelFairHasArticle = new FairsHasArticles();
                $modelFairHasArticle->id_fair = $idFair;
                $modelFairHasArticle->id_article = $this->id_article;

                $flag = $modelFairHasArticle->validate();
                $flag = $flag && $modelFairHasArticle->save(false);
                if(!$flag) {
                    break;
                }  
            }
            else {
                unset($modelsFairsHasArticles[$idFair]);
            }
        }        
        
        if($flag && !empty($modelsFairsHasArticles)) {
            foreach($modelsFairsHasArticles as $modelFairHasArticle) {
                $flag = $modelFairHasArticle->delete();
                if($flag === false) {
                    break;
                }
            }
        }
        
        return $flag;
    }
    
    public function saveGoogleIndexingUrls($newListPortals, $oldListPortals = [])
    {
        if(empty($newListPortals) || $this->status !== \common\models\types\Status::ACTIVE) {
            return true;
        }
        
        $idsPortals = !empty($oldListPortals) ? array_unique(array_values(array_diff($newListPortals, $oldListPortals))) : $newListPortals;
            
        $modelsPortals = \common\models\Portals::find()->where(['id_portal' => $idsPortals])->indexBy('id_portal')->all();
        if(empty($modelsPortals)) {
            return true;
        }     
        
        $modelsSaved = [];        
        foreach($modelsPortals as $idPortal => $modelPortal) {
            list($flag, $lastInsertedModel) = \backend\components\helpers\GoogleIndexingHelper::createEntryForArticle($this, $modelPortal);
            if($flag) {
                if(!empty($lastInsertedModel)) {
                    $modelsSaved[] = $lastInsertedModel;
                }
            } else {
                if(!empty($modelsSaved)) {
                    foreach($modelsSaved as $modelSaved) {
                        $modelSaved->delete();
                    }
                }
                return false;
            }
        }  
        
        return true;
    }
    
    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('@articlesImagesRealPath').'/'.$this->id_article.'/'.$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('@articlesImagesRealPath').'/'.$this->id_article.'/'.$oldImageFilename;
                $this->image_filename = null;
            }
            else {
                $this->image_filename = null;
            }
        }
        
        return $oldImagePath;
    }
    
//    public function loadImageFile()
//    {
//        $oldImagePath = null;  
//        if($this->isNewRecord) {
//            $this->file = \yii\web\UploadedFile::getInstance($this, 'image_filename');
//            if($this->file) {
//                $this->image_filename = self::createImageFileName($this->file->baseName, $this->file->extension, $this->id_article);
//            }
//        } else {
//            $oldImageFilename = $this->getOldAttribute('image_filename');  
//            if($this->image_filename !== 'DELETE') {                
//                $this->file = \yii\web\UploadedFile::getInstance($this, 'image_filename');
//                if($this->file) {        
//                    $oldImagePath = Yii::getAlias('@articlesImagesRealPath').'/'.$this->id_article.'/'.$oldImageFilename;
//                    $this->image_filename = self::createImageFileName($this->file->baseName, $this->file->extension, $this->id_article);
//                }
//                else {
//                    $this->image_filename = (!empty($oldImageFilename)) ? $oldImageFilename : null;
//                }
//            }
//            elseif(!empty($oldImageFilename)) {
//                $oldImagePath = Yii::getAlias('@articlesImagesRealPath').'/'.$this->id_article.'/'.$oldImageFilename;
//                $this->image_filename = null;
//            }
//            else {
//                $this->image_filename = null;
//            }
//        }
//        
//        return $oldImagePath;
//    }
    
    public function saveImageFile()
    {
        $newImagePath = null;
        
        if($this->file) {
            $dir = Yii::getAlias('@articlesImagesRealPath').'/'.$this->id_article.'/';
            if(!file_exists($dir)) {
                mkdir($dir, 0777, true);
            }
            $newImagePath = $dir.$this->image_filename;

            if(!$this->file->saveAs($newImagePath)) {
                return false;
            } 
        }
        
        return $newImagePath;
    }
    
    /**
     * @return \yii\db\ActiveQuery
     */
    public function getTranslations()
    {
        return $this->hasMany(ArticlesTranslations::className(), ['id_article' => 'id_article'])->inverseOf('article');
    }
    
    public function getSubfolderForWysiwyg()
    {
        return Yii::getAlias('@articlesContentsImagesDirName').'/'.($this->isNewRecord ? $this->getTempDir() : $this->id_article);
    }
    
    public function getContentsFilesPath($absolute = false)
    {
        return ($absolute ? Yii::getAlias('@sourcesUrl') : Yii::getAlias('@sourcesRealPath')).'/'.Yii::getAlias('@articlesContentsImagesDirName').'/';
    }
    
    public function getContentsFilesThumbsPath($absolute = false)
    {        
        return ($absolute ? Yii::getAlias('@sourcesThumbsUrl') : Yii::getAlias('@sourcesThumbsRealPath')).'/'.Yii::getAlias('@articlesContentsImagesDirName').'/';
    }
    
    public static function getTempDirSessionKey()
    {
        return 'newArticleTempSourceDir';
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com