ValidatorsManager::validateFromCache_() - Code Metrics - Inspection of "Add ValidatorsManagerInitTrait" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 834a6d...ff4a25 )

by Jean-Christophe

created 2019-01-10 15:38 UTC

ValidatorsManager::validateFromCache_() A

↳ Parent: ValidatorsManager

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	7
nc	4
nop	2
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php

namespace Ubiquity\contents\validation;

use Ubiquity\cache\CacheManager;
use Ubiquity\log\Logger;
use Ubiquity\contents\validation\validators\multiples\LengthValidator;
use Ubiquity\contents\validation\validators\multiples\IdValidator;
use Ubiquity\contents\validation\validators\basic\NotNullValidator;
use Ubiquity\contents\validation\validators\basic\NotEmptyValidator;
use Ubiquity\contents\validation\validators\comparison\EqualsValidator;
use Ubiquity\contents\validation\validators\basic\TypeValidator;
use Ubiquity\contents\validation\validators\comparison\GreaterThanValidator;
use Ubiquity\contents\validation\validators\comparison\LessThanValidator;
use Ubiquity\contents\validation\validators\basic\IsNullValidator;
use Ubiquity\contents\validation\validators\basic\IsEmptyValidator;
use Ubiquity\contents\validation\validators\basic\IsTrueValidator;
use Ubiquity\contents\validation\validators\basic\IsFalseValidator;
use Ubiquity\contents\validation\validators\strings\RegexValidator;
use Ubiquity\contents\validation\validators\strings\EmailValidator;
use Ubiquity\contents\validation\validators\strings\UrlValidator;
use Ubiquity\contents\validation\validators\strings\IpValidator;
use Ubiquity\contents\validation\validators\comparison\RangeValidator;
use Ubiquity\contents\validation\validators\comparison\GreaterThanOrEqualValidator;
use Ubiquity\contents\validation\validators\comparison\LessThanOrEqualValidator;
use Ubiquity\contents\validation\validators\dates\DateValidator;
use Ubiquity\contents\validation\validators\dates\DateTimeValidator;
use Ubiquity\contents\validation\validators\dates\TimeValidator;
use Ubiquity\contents\validation\validators\basic\IsBooleanValidator;
use Ubiquity\cache\objects\SessionCache;

/**
 * Validators manager
 * @author jcheron <[email protected]>
 * @version 1.0.0
 */
class ValidatorsManager {
	use ValidatorsManagerInitTrait;
	protected static $instanceValidators=[];
	protected static $cache;
	
	public static function start(){
		self::$cache=new SessionCache();
	}
	
	public static $validatorTypes=[
			"notNull"=>NotNullValidator::class,
			"isNull"=>IsNullValidator::class,
			"notEmpty"=>NotEmptyValidator::class,
			"isEmpty"=>IsEmptyValidator::class,
			"isTrue"=>IsTrueValidator::class,
			"isFalse"=>IsFalseValidator::class,
			"isBool"=>IsBooleanValidator::class,
			"equals"=>EqualsValidator::class,
			"type"=>TypeValidator::class,
			"greaterThan"=>GreaterThanValidator::class,
			"greaterThanOrEqual"=>GreaterThanOrEqualValidator::class,
			"lessThan"=>LessThanValidator::class,
			"lessThanOrEqual"=>LessThanOrEqualValidator::class,
			"length"=>LengthValidator::class,
			"id"=>IdValidator::class,
			"regex"=>RegexValidator::class,
			"email"=>EmailValidator::class,
			"url"=>UrlValidator::class,
			"ip"=>IpValidator::class,
			"range"=>RangeValidator::class,
			"date"=>DateValidator::class,
			"dateTime"=>DateTimeValidator::class,
			"time"=>TimeValidator::class
			
	];
	
	protected static $key="contents/validators/";
	
	protected static function store($model,$validators){
		CacheManager::$cache->store(self::getModelCacheKey($model), $validators);
	}
	
	protected static function fetch($model){
		$key=self::getModelCacheKey($model);
		if(CacheManager::$cache->exists($key)){
			return CacheManager::$cache->fetch($key);
		}
		return [];
	}
	
	protected static function getGroupArrayValidators(array $validators,$group){
		$result=[];
		foreach ($validators as $member=>$validators){
			$filteredValidators=self::getGroupMemberValidators($validators, $group);
			if(sizeof($filteredValidators)){
				$result[$member]=$filteredValidators;
			}
		}
		return $result;
	}
	
	protected static function getGroupMemberValidators(array $validators,$group){
		$result=[];
		foreach ($validators as $validator){
			if(isset($validator["group"]) && $validator["group"]===$group){
				$result[]=$validator;
			}
		}
		return $result;
	}
	
	private static function getCacheValidators($instance,$group=""){
		if(isset(self::$cache)){
			$key=self::getHash(get_class($instance).$group);
			if(self::$cache->exists($key)){
				return self::$cache->fetch($key);
			}
		}
		return false;
	}
	
	/**
	 * Validates an instance
	 * @param object $instance
	 * @param string $group
	 * @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
	 */
	public static function validate($instance,$group=""){
		$cache=self::getCacheValidators($instance,$group);
		if($cache!==false){
			return self::validateFromCache_($instance,$cache);
		}
		$members=self::fetch(get_class($instance));
		if($group!==""){
			$members=self::getGroupArrayValidators($members, $group);
		}
		return self::validate_($instance,$members);
	}
	
	/**
	 * Validates an array of objects
	 * @param array $instances
	 * @param string $group
	 * @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
	 */
	public static function validateInstances($instances,$group=""){
		if(sizeof($instances)>0){
			$instance=reset($instances);
			$cache=self::getCacheValidators($instance,$group);
			if($cache===false){
				$class=get_class($instance);
				$members=self::fetch($class);
				self::initInstancesValidators($instance, $members,$group);
				$cache=self::$instanceValidators[$class];
			}
			return self::validateInstances_($instances,$cache);
		}
		return [];
	}
	
	public static function clearCache($model=null,$group=""){
		if(isset(self::$cache)){
			if(isset($model)){
				$key=self::getHash($model.$group);
				self::$cache->remove($key);
			}else{
				self::$cache->clear();
			}
		}
	}
	
	protected static function validateInstances_($instances,$members){
		$result=[];
		foreach ($instances as $instance){
			foreach ($members as $accessor=>$validators){
				foreach ($validators as $validator){
					$valid=$validator->validate_($instance->$accessor());
					if($valid!==true){
						$result[]=$valid;
					}
				}
			}
		}
		return $result;
	}
	
	protected static function validate_($instance,$members){
		$result=[];
		foreach ($members as $member=>$validators){
			$accessor="get".ucfirst($member);
			if(method_exists($instance, $accessor)){
				foreach ($validators as $validator){
					$validatorInstance=self::getValidatorInstance($validator["type"]);
					if($validatorInstance!==false){
						$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
						$valid=$validatorInstance->validate_($instance->$accessor());
						if($valid!==true){
							$result[]=$valid;
						}
					}
				}
			}
		}
		return $result;
	}
	
	protected static function validateFromCache_($instance,$members){
		$result=[];
		foreach ($members as $accessor=>$validators){
			foreach ($validators as $validatorInstance){
				$valid=$validatorInstance->validate_($instance->$accessor());
				if($valid!==true){
					$result[]=$valid;
				}
			}
		}
		return $result;
	}
	
	/**
	 * Initializes the cache (SessionCache) for the class of înstance
	 * @param object $instance
	 * @param string $group
	 */
	public static function initCacheInstanceValidators($instance,$group=""){
		$class=get_class($instance);
		$members=self::fetch($class);
		self::initInstancesValidators($instance, $members,$group);
	}
	
	protected static function initInstancesValidators($instance,$members,$group=""){
		$class=get_class($instance);
		$result=[];
		foreach ($members as $member=>$validators){
			$accessor="get".ucfirst($member);
			if(method_exists($instance, $accessor)){
				foreach ($validators as $validator){
					$validatorInstance=self::getValidatorInstance($validator["type"]);
					if($validatorInstance!==false){
						$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
						if($group==="" || (isset($validator["group"]) && $validator["group"]===$group)){
							self::$instanceValidators[$class][$accessor][]=$validatorInstance;
							$result[$accessor][]=$validatorInstance;
						}
					}
				}
			}
		}
		self::$cache->store(self::getHash($class.$group), $result);
	}
	
	protected static function getHash($class){
		return hash("sha1", $class);
	}
	
	protected static function getModelCacheKey($classname){
		return self::$key.\str_replace("\\", \DS, $classname);
	}
	
	protected static function getValidatorInstance($type){
		if(isset(self::$validatorTypes[$type])){
			$class=self::$validatorTypes[$type];
			return new $class();
		}else{
			Logger::warn("validation", "Validator ".$type." does not exists!");
			return false;
		}
	}
}



1			<?php
2
3			namespace Ubiquity\contents\validation;
4
5			use Ubiquity\cache\CacheManager;
6			use Ubiquity\log\Logger;
7			use Ubiquity\contents\validation\validators\multiples\LengthValidator;
8			use Ubiquity\contents\validation\validators\multiples\IdValidator;
9			use Ubiquity\contents\validation\validators\basic\NotNullValidator;
10			use Ubiquity\contents\validation\validators\basic\NotEmptyValidator;
11			use Ubiquity\contents\validation\validators\comparison\EqualsValidator;
12			use Ubiquity\contents\validation\validators\basic\TypeValidator;
13			use Ubiquity\contents\validation\validators\comparison\GreaterThanValidator;
14			use Ubiquity\contents\validation\validators\comparison\LessThanValidator;
15			use Ubiquity\contents\validation\validators\basic\IsNullValidator;
16			use Ubiquity\contents\validation\validators\basic\IsEmptyValidator;
17			use Ubiquity\contents\validation\validators\basic\IsTrueValidator;
18			use Ubiquity\contents\validation\validators\basic\IsFalseValidator;
19			use Ubiquity\contents\validation\validators\strings\RegexValidator;
20			use Ubiquity\contents\validation\validators\strings\EmailValidator;
21			use Ubiquity\contents\validation\validators\strings\UrlValidator;
22			use Ubiquity\contents\validation\validators\strings\IpValidator;
23			use Ubiquity\contents\validation\validators\comparison\RangeValidator;
24			use Ubiquity\contents\validation\validators\comparison\GreaterThanOrEqualValidator;
25			use Ubiquity\contents\validation\validators\comparison\LessThanOrEqualValidator;
26			use Ubiquity\contents\validation\validators\dates\DateValidator;
27			use Ubiquity\contents\validation\validators\dates\DateTimeValidator;
28			use Ubiquity\contents\validation\validators\dates\TimeValidator;
29			use Ubiquity\contents\validation\validators\basic\IsBooleanValidator;
30			use Ubiquity\cache\objects\SessionCache;
31
32			/**
33			* Validators manager
34			* @author jcheron <[email protected]>
35			* @version 1.0.0
36			*/
37			class ValidatorsManager {
38			use ValidatorsManagerInitTrait;
39			protected static $instanceValidators=[];
40			protected static $cache;
41
42			public static function start(){
43			self::$cache=new SessionCache();
44			}
45
46			public static $validatorTypes=[
47			"notNull"=>NotNullValidator::class,
48			"isNull"=>IsNullValidator::class,
49			"notEmpty"=>NotEmptyValidator::class,
50			"isEmpty"=>IsEmptyValidator::class,
51			"isTrue"=>IsTrueValidator::class,
52			"isFalse"=>IsFalseValidator::class,
53			"isBool"=>IsBooleanValidator::class,
54			"equals"=>EqualsValidator::class,
55			"type"=>TypeValidator::class,
56			"greaterThan"=>GreaterThanValidator::class,
57			"greaterThanOrEqual"=>GreaterThanOrEqualValidator::class,
58			"lessThan"=>LessThanValidator::class,
59			"lessThanOrEqual"=>LessThanOrEqualValidator::class,
60			"length"=>LengthValidator::class,
61			"id"=>IdValidator::class,
62			"regex"=>RegexValidator::class,
63			"email"=>EmailValidator::class,
64			"url"=>UrlValidator::class,
65			"ip"=>IpValidator::class,
66			"range"=>RangeValidator::class,
67			"date"=>DateValidator::class,
68			"dateTime"=>DateTimeValidator::class,
69			"time"=>TimeValidator::class
70
71			];
72
73			protected static $key="contents/validators/";
74
75			protected static function store($model,$validators){
76			CacheManager::$cache->store(self::getModelCacheKey($model), $validators);
77			}
78
79			protected static function fetch($model){
80			$key=self::getModelCacheKey($model);
81			if(CacheManager::$cache->exists($key)){
82			return CacheManager::$cache->fetch($key);
83			}
84			return [];
85			}
86
87			protected static function getGroupArrayValidators(array $validators,$group){
88			$result=[];
89			foreach ($validators as $member=>$validators){
90			$filteredValidators=self::getGroupMemberValidators($validators, $group);
91			if(sizeof($filteredValidators)){
92			$result[$member]=$filteredValidators;
93			}
94			}
95			return $result;
96			}
97
98			protected static function getGroupMemberValidators(array $validators,$group){
99			$result=[];
100			foreach ($validators as $validator){
101			if(isset($validator["group"]) && $validator["group"]===$group){
102			$result[]=$validator;
103			}
104			}
105			return $result;
106			}
107
108			private static function getCacheValidators($instance,$group=""){
109			if(isset(self::$cache)){
110			$key=self::getHash(get_class($instance).$group);
111			if(self::$cache->exists($key)){
112			return self::$cache->fetch($key);
113			}
114			}
115			return false;
116			}
117
118			/**
119			* Validates an instance
120			* @param object $instance
121			* @param string $group
122			* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
123			*/
124			public static function validate($instance,$group=""){
125			$cache=self::getCacheValidators($instance,$group);
126			if($cache!==false){
127			return self::validateFromCache_($instance,$cache);
128			}
129			$members=self::fetch(get_class($instance));
130			if($group!==""){
131			$members=self::getGroupArrayValidators($members, $group);
132			}
133			return self::validate_($instance,$members);
134			}
135
136			/**
137			* Validates an array of objects
138			* @param array $instances
139			* @param string $group
140			* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
141			*/
142			public static function validateInstances($instances,$group=""){
143			if(sizeof($instances)>0){
144			$instance=reset($instances);
145			$cache=self::getCacheValidators($instance,$group);
146			if($cache===false){
147			$class=get_class($instance);
148			$members=self::fetch($class);
149			self::initInstancesValidators($instance, $members,$group);
150			$cache=self::$instanceValidators[$class];
151			}
152			return self::validateInstances_($instances,$cache);
153			}
154			return [];
155			}
156
157			public static function clearCache($model=null,$group=""){
158			if(isset(self::$cache)){
159			if(isset($model)){
160			$key=self::getHash($model.$group);
161			self::$cache->remove($key);
162			}else{
163			self::$cache->clear();
164			}
165			}
166			}
167
168			protected static function validateInstances_($instances,$members){
169			$result=[];
170			foreach ($instances as $instance){
171			foreach ($members as $accessor=>$validators){
172			foreach ($validators as $validator){
173			$valid=$validator->validate_($instance->$accessor());
174			if($valid!==true){
175			$result[]=$valid;
176			}
177			}
178			}
179			}
180			return $result;
181			}
182
183			protected static function validate_($instance,$members){
184			$result=[];
185			foreach ($members as $member=>$validators){
186			$accessor="get".ucfirst($member);
187			if(method_exists($instance, $accessor)){
188			foreach ($validators as $validator){
189			$validatorInstance=self::getValidatorInstance($validator["type"]);
190			if($validatorInstance!==false){
191			$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
192			$valid=$validatorInstance->validate_($instance->$accessor());
193			if($valid!==true){
194			$result[]=$valid;
195			}
196			}
197			}
198			}
199			}
200			return $result;
201			}
202
203			protected static function validateFromCache_($instance,$members){
204			$result=[];
205			foreach ($members as $accessor=>$validators){
206			foreach ($validators as $validatorInstance){
207			$valid=$validatorInstance->validate_($instance->$accessor());
208			if($valid!==true){
209			$result[]=$valid;
210			}
211			}
212			}
213			return $result;
214			}
215
216			/**
217			* Initializes the cache (SessionCache) for the class of înstance
218			* @param object $instance
219			* @param string $group
220			*/
221			public static function initCacheInstanceValidators($instance,$group=""){
222			$class=get_class($instance);
223			$members=self::fetch($class);
224			self::initInstancesValidators($instance, $members,$group);
225			}
226
227			protected static function initInstancesValidators($instance,$members,$group=""){
228			$class=get_class($instance);
229			$result=[];
230			foreach ($members as $member=>$validators){
231			$accessor="get".ucfirst($member);
232			if(method_exists($instance, $accessor)){
233			foreach ($validators as $validator){
234			$validatorInstance=self::getValidatorInstance($validator["type"]);
235			if($validatorInstance!==false){
236			$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
237			if($group==="" \|\| (isset($validator["group"]) && $validator["group"]===$group)){
238			self::$instanceValidators[$class][$accessor][]=$validatorInstance;
239			$result[$accessor][]=$validatorInstance;
240			}
241			}
242			}
243			}
244			}
245			self::$cache->store(self::getHash($class.$group), $result);
246			}
247
248			protected static function getHash($class){
249			return hash("sha1", $class);
250			}
251
252			protected static function getModelCacheKey($classname){
253			return self::$key.\str_replace("\\", \DS, $classname);
254			}
255
256			protected static function getValidatorInstance($type){
257			if(isset(self::$validatorTypes[$type])){
258			$class=self::$validatorTypes[$type];
259			return new $class();
260			}else{
261			Logger::warn("validation", "Validator ".$type." does not exists!");
262			return false;
263			}
264			}
265			}
266
267

phpMv / ubiquity

Push — master ( 834a6d...ff4a25 )

ValidatorsManager::validateFromCache_() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like