Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/common/components/traits/
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/common/components/traits/TreesFunctions.php
<?php

namespace common\components\traits;

trait TreesFunctions
{
    public static function getJSONCategoryTree($idPortal, $checkedCategories = [], $onlyNodeActive = false)
    {
        $categories = self::getCategoryTree($idPortal, $checkedCategories, $onlyNodeActive);
        return json_encode($categories);
    }
    
    public static function getCategoryTree($idPortal, $checkedCategories = [], $onlyNodeActive = false)
    {
        $models = self::find()->where(['id_portal' => intval($idPortal)])->orderBy('left')->all();
        
        $categories = [];

        if(empty($models)) {
            return $categories;
        }
        
        $stack = [];
        $l = 0;
        foreach($models as $model) {
            $item = array(
                'id' => $model->id_category,
                'text' => $model->name,
                'depth' => $model->depth,
                'data' => ['description' => $model->description],
                'children' => []
            );

            if($model->hasAttribute('category_type')) {
                $item['data']['type'] = (string)$model->category_type;
            }

            if(!empty($checkedCategories) && in_array($model->id_category, $checkedCategories)) {
                $item['state']['checked'] = true;
            }
            if($onlyNodeActive && ($model->right - $model->left) !== 1) {
                $item['state']['disabled'] = true;
            }

            // Number of stack items
            $l = count($stack);

            // Check if we're dealing with different levels
            while($l > 0 && $stack[$l - 1]['depth'] >= $item['depth']) {
                array_pop($stack);
                $l--;
            }

            // Stack is empty (we are inspecting the root)
            if ($l == 0) {
                // Assigning the root node
                $i = count($categories);
                $categories[$i] = $item;
                $stack[] = & $categories[$i];
            } else {
                // Add node to parent
                $i = count($stack[$l - 1]['children']);
                $stack[$l - 1]['children'][$i] = $item;
                $stack[] = & $stack[$l - 1]['children'][$i];
            }
        }
        unset($stack);
        
        return $categories;
    }
    
    public static function getJSONCategoryTrees($idsPortal, $checkedCategories = [])
    {
        $categoriesOfPortals = self::getCategoryTrees($idsPortal, $checkedCategories);
        if(!empty($categoriesOfPortals)) {
            foreach($categoriesOfPortals as $idPortal => $categories) {
                $categoriesOfPortals[$idPortal] = json_encode($categories);
            }
        }
        
        return $categoriesOfPortals;
    }
    
    public static function getCategoryTrees($idsPortal, $checkedCategories = [])
    {
        $models = self::find()->where(['id_portal' => $idsPortal])->orderBy('id_portal ASC, left ASC')->all();
        
        $categoriesOfPortals = [];
        
        if(empty($models)) {
            return $categoriesOfPortals;
        }
        
        foreach($models as $model) {
            $portalsCategories[$model->id_portal][] = $model;
        }
        
        foreach($portalsCategories as $idPortal => $portalCategories) {
            $categories = [];
            $stack = [];
            $l = 0;
            foreach($portalCategories as $model) {
                $item = array(
                    'id' => $model->id_category,
                    'text' => $model->name,
                    'depth' => $model->depth,
                    'data' => ['description' => $model->description],
                    'children' => []
                );
                
                if($model->hasAttribute('category_type')) {
                    $item['data']['type'] = (string)$model->category_type;
                }
                
                if(!empty($checkedCategories) && in_array($model->id_category, $checkedCategories)) {
                    $item['state']['checked'] = true;
                }
                if(($model->right - $model->left) !== 1) {
                    $item['state']['disabled'] = true;
                }
                
                // Number of stack items
                $l = count($stack);

                // Check if we're dealing with different levels
                while($l > 0 && $stack[$l - 1]['depth'] >= $item['depth']) {
                    array_pop($stack);
                    $l--;
                }

                // Stack is empty (we are inspecting the root)
                if ($l == 0) {
                    // Assigning the root node
                    $i = count($categories);
                    $categories[$i] = $item;
                    $stack[] = & $categories[$i];
                } else {
                    // Add node to parent
                    $i = count($stack[$l - 1]['children']);
                    $stack[$l - 1]['children'][$i] = $item;
                    $stack[] = & $stack[$l - 1]['children'][$i];
                }
            }
            unset($stack);
            $categoriesOfPortals[$idPortal] = $categories;
        }

        return $categoriesOfPortals;
    }
    
    public static function initTree($idPortal)
    {
        $model = new self;
        $model->setScenario('create');
        $model->name = 'root';
        $model->description = 'root';
        $model->id_portal = intval($idPortal);
        $model->left = 1;
        $model->right = 2;
        $model->depth = 0;
        
        return $model->save();
    }
    
    public static function getCategoryPath($modelCategory)
    {
        $models = self::find()
                ->where(['<=', 'left', $modelCategory->left])
                ->andWhere(['>=', 'right', $modelCategory->right])
                ->andWhere(['id_portal' => $modelCategory->id_portal])
                ->orderBy('left')
                ->all();
        
        if(!empty($models)) {
            unset($models[0]);
            return $models;
        } else {
            return [];
        }        
    }
    
    public static function getIdsCategoryPath($modelCategory)
    {
        $idsCategories = self::find()
                ->select(['id_category'])
                ->where(['<=', 'left', $modelCategory->left])
                ->andWhere(['>=', 'right', $modelCategory->right])
                ->andWhere(['id_portal' => $modelCategory->id_portal])
                ->orderBy('left')
                ->asArray()
                ->column();
        
        if(!empty($idsCategories)) {
            unset($idsCategories[0]);            
            return $idsCategories;
        } else {
            return [];
        }        
    }
    
    public static function getIdsSelectedBranch($modelCategory)
    {
        if($modelCategory->right - $modelCategory->left === 1) {
            $ids = [$modelCategory->id_category];
        } else {
            $ids = self::find()->select(['id_category'])
                ->where(['>=', 'left', $modelCategory->left])
                ->andWhere(['<=', 'right', $modelCategory->right])
                ->andWhere(['id_portal' => $modelCategory->id_portal])
                ->column();
        }
        
        return $ids;
        
    }
    
    public static function getParentCategory($modelCategory)
    {
        if($modelCategory->left === 1) {
            return $modelCategory;
        }
        
        return self::find()
                ->where(['<=', 'left', $modelCategory->left])
                ->andWhere(['>=', 'right', $modelCategory->right])
                ->andWhere(['depth' => $modelCategory->depth - 1])
                ->andWhere(['id_portal' => $modelCategory->id_portal])
                ->one();
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com