Epesi\Base\CommonData\Database\Models\CommonData

Complexity

Total Complexity

40

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getArray()	0	3	1
A	validateArrayKeys()	0	6	3
A	deleteArray()	0	6	2
A	getId()	0	18	6
A	getCollection()	0	13	4
A	getValue()	0	11	4
A	extendArray()	0	12	3
A	newId()	0	21	6
A	clearCache()	0	3	1
A	newArray()	0	26	6
A	setValue()	0	13	4

<?php

namespace Epesi\Base\CommonData\Database\Models;

use Kalnoy\Nestedset\NodeTrait;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Collection;

class CommonDataNotFound extends \Exception {}

class CommonData extends Model {
    use NodeTrait;

The trait Kalnoy\Nestedset\NodeTrait requires the property $forceDeleting which is not provided by Epesi\Base\CommonData\Database\Models\CommonData.

    
    protected $table = 'commondata';
    public $timestamps = false;
    protected static $unguarded = true;
    
    protected static $cache = [
    		'id' => [],
    		'value' => [],
    		'array' => []
    ];
    
    public static function getId($path, $clearCache = false)
    {
    	$parentId = null;
    	foreach(explode('/', trim($path,'/')) as $nodeKey) {
    		if ($nodeKey === '') continue; //ignore empty paths
    		
    		if ($clearCache || empty(self::$cache['id'][$parentId][$nodeKey])) {
    			if (! $node = self::where('parent_id', $parentId)->where('key', $nodeKey)->first()) {
    				return false;
    			}

    			self::$cache['id'][$parentId][$nodeKey] = $node->id;
    		}
    		
    		$parentId = $id = self::$cache['id'][$parentId][$nodeKey];
    	}
    	
    	return $id;

The variable $id does not seem to be defined for all execution paths leading up to this point.

    }
   
    public static function newId($path, $readonly = false)
    {
    	if (! $path = trim($path,'/')) return false;

    	$id = $parentId = null;
    	foreach(explode('/', $path) as $nodeKey) {
    		if ($nodeKey === '') continue;

    		if (! $node = self::where('parent_id', $parentId)->where('key', $nodeKey)->first()) {
    			$node = self::create([
    					'parent_id' => $parentId,
    					'key' => $nodeKey,
    					'readonly' => $readonly,
    					'position' => self::where('parent_id', $parentId)->count()
    			], $parentId? self::find($parentId): null);
    		}
    		
    		$parentId = $id = $node->id;
    	}
    	
    	return $id;
    }
    
    public static function setValue($path, $value, $overwrite = true, $readonly = false)
    {
    	if (! $id = self::getId($path)) {
    		if (! $id = self::newId($path, $readonly)) return false;
    	} else {
    		if (! $overwrite) return false;
    	}

    	self::findOrFail($id)->update(compact('value', 'readonly'));
    	
    	self::clearCache();
    	
    	return true;
    }
    
    public static function clearCache()
    {
    	self::$cache = array_fill_keys(array_keys(self::$cache), []);
    }
    
    public static function getValue($path, $translate = false)
    {
    	$key = md5(serialize($path));
    	
    	if (! isset(self::$cache['value'][$key])) {
    		if(! $id = self::getId($path)) return false;

    		self::$cache['value'][$key] = self::find($id)->value;
	    }
	    
	    return $translate? __(self::$cache['value'][$key]): self::$cache['value'][$key];
    }
        
    /**
     * Creates new array for common use.
     *
     * @param $path string
     * @param $array array initialization value
     * @param $overwrite bool whether method should overwrite if array already exists, otherwise the data will be appended
     * @param $readonly bool do not allow user to change this array from GUI
     */
    public static function newArray($path, $array, $overwrite = false, $readonly = false)
    {
    	self::validateArrayKeys($array);
    		
    	$path = trim($path, '/');
    	
		if ($id = self::getId($path)) {
    		if (! $overwrite) {
    			self::extendArray($path, $array);
    			return true;
    		}
    				
    		self::find($id)->delete();
    	}
    			
    	if(! $id = self::newId($path, $readonly)) return false;
    			
    	if ($overwrite) {
    		self::find($id)->update(compact('readonly'));
    	}
    			
    	foreach ($array as $key => $value) {
    		self::setValue($path . '/' . $key, $value, true, $readonly);
    	}
    			
    	return true;
    }

    /**
     * Extends common data array.
     *
     * @param $path string
     * @param $array array values to insert
     * @param $overwrite bool whether method should overwrite data if array key already exists, otherwise the data will be preserved
     */
    public static function extendArray($path, $array, $overwrite=false, $readonly=false)
    {
    	self::validateArrayKeys($array);
    	
    	$path = trim($path, '/');
    			
    	if (! self::getId($path)){
    		return self::newArray($path, $array, $overwrite, $readonly);
    	}

    	foreach ($array as $key => $value) {
    		self::setValue($path . '/' . $key, $value, $overwrite, $readonly);
    	}
    }
        
    /**
     * Returns common data array.
     *
     * @param string array name
     * @return mixed returns an array if such array exists, false otherwise
     */
    public static function getArray($path, $sortColumn = 'position', $silent = false)
    {
    	return self::getCollection($path, $silent)->sortBy($sortColumn)->pluck('value', 'key')->all();
    }

    /**
     * Removes common data array or entry.
     *
     * @param $path string
     * @return true on success, false otherwise
     */
    public static function deleteArray($path){
    	if (! $id = self::getId($path, true)) return false;

The expression return false returns the type false which is incompatible with the documented return type true.

    	
    	self::find($id)->delete();
    	
    	self::clearCache();
    }

    /**
     * Returns common data collection.
     *
     * @param $path string
     * @return Collection
     */
    public static function getCollection($path, $silent = false)
    {
    	if(isset(self::$cache['array'][$path])) {
    		return self::$cache['array'][$path];
    	}
    	
    	if (! $id = self::getId($path)) {
    		if ($silent) return collect();
    		
    		throw new CommonDataNotFound('Invalid CommonData::getArray() request: ' . $path);
    	}
    	
    	return self::$cache['array'][$path] = self::where('parent_id', $id)->get();
    }
    
    protected static function validateArrayKeys($array)
    {
    	foreach($array as $key => $value) {
    		if (strpos($key, '/') === false) continue;
    		
    		\Exception('Invalid common data key: '. $key);

The function Exception was not found. Maybe you did not declare it correctly or list all dependencies?

    	}
    }
}