AclDAOProvider::initModelsCache() - Code Metrics - Inspection of "Update .scrutinizer.yml" - phpMv/ubiquity-acl - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( fb0070...d585ad )

by Jean-Christophe

created 2021-12-26 03:33 UTC

AclDAOProvider::initModelsCache() A

↳ Parent: AclDAOProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	5
c	1
b	0
f	1
nc	1
nop	1
dl	0
loc	6
ccs	0
cts	6
cp	0
crap	2
rs	10

<?php
namespace Ubiquity\security\acl\persistence;

use Ubiquity\cache\CacheManager;
use Ubiquity\cache\ClassUtils;
use Ubiquity\controllers\Startup;
use Ubiquity\db\reverse\DbGenerator;
use Ubiquity\exceptions\AclException;
use Ubiquity\orm\DAO;
use Ubiquity\orm\reverse\DatabaseReversor;
use Ubiquity\scaffolding\creators\ClassCreator;
use Ubiquity\security\acl\models\AbstractAclPart;
use Ubiquity\security\acl\models\AclElement;
use Ubiquity\security\acl\models\Permission;
use Ubiquity\security\acl\models\Resource;
use Ubiquity\security\acl\models\Role;

/**
 * Load and save Acls with a database using DAO.
 * Ubiquity\security\acl\persistence$AclDAOProvider
 * This class is part of Ubiquity
 *
 * @author jc
 * @version 1.0.1
 *
 */
class AclDAOProvider implements AclProviderInterface {

	protected string $aclClass;

	protected string $roleClass;

	protected string $permissionClass;

	protected string $resourceClass;

	/**
	 * @param array $config The $config array
	 * @param array $classes
	 *        	associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
	 */
	public function __construct(array &$config,$classes = []) {
		Startup::$config=$config;
		$this->aclClass = $classes['acl'] ?? AclElement::class;
		$this->roleClass = $classes['role'] ?? Role::class;
		$this->resourceClass = $classes['resource'] ?? Resource::class;
		$this->permissionClass = $classes['permission'] ?? Permission::class;
	}

	/**
	 * Initialize the cache for the ACL models.
	 * @param $config
	 */
	public function initModelsCache(&$config) {
		CacheManager::start($config);
		CacheManager::createOrmModelCache($this->aclClass);
		CacheManager::createOrmModelCache($this->roleClass);
		CacheManager::createOrmModelCache($this->resourceClass);
		CacheManager::createOrmModelCache($this->permissionClass);
	}

	/**
	 * Defines the database offset used for ACL.
	 * @param string $dbOffset
	 * @param  bool $persist
	 */
	public function setDbOffset(string $dbOffset = 'default',bool $persist=true):void {
		DAO::setModelDatabase($this->aclClass, $dbOffset);
		DAO::setModelDatabase($this->resourceClass, $dbOffset);
		DAO::setModelDatabase($this->roleClass, $dbOffset);
		DAO::setModelDatabase($this->permissionClass, $dbOffset);
		if($persist){
			CacheManager::storeModelsDatabases(DAO::getModelsDatabase ());
		}
	}

	/**
	 * Generates the models.
	 * @param array $classes associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
	 */
	public function createModels(array $classes=[]):void{
		$this->createModel($classes['acl'] ?? $this->aclClass,AclElement::class);
		$this->createModel($classes['role'] ?? $this->roleClass,Role::class);
		$this->createModel($classes['resource'] ?? $this->resourceClass,Resource::class);
		$this->createModel($classes['permission'] ?? $this->permissionClass,Permission::class);
	}

	public function createModel($modelName,$refName):void{
		if($modelName!==$refName){
			$className=ClassUtils::getClassSimpleName($modelName);
			$ns=ClassUtils::getNamespaceFromCompleteClassname($modelName);
			$cCreator=new ClassCreator($className,'',$ns,' extends '.$refName);
			$cCreator->generate();
		}
	}

	/**
	 * Generates the tables for ACL model classes.
	 * @param string $dbOffset
	 * @param bool $createDb
	 * @throws AclException
	 */
	public function generateDbTables(string $dbOffset='default',bool $createDb=false):void{
		$this->setDbOffset($dbOffset);
		$generator = new DatabaseReversor(new DbGenerator(), $dbOffset);
		$activeOffsetValue=DAO::getDbOffset(Startup::$config,$dbOffset);
		if(($dbName=$activeOffsetValue['dbName']??'')!='') {
			$generator->setModels([$this->aclClass,$this->roleClass,$this->resourceClass,$this->permissionClass]);
			$generator->createDatabase($dbName, $createDb);
			$db=DAO::getDatabase($dbOffset);
			$db->beginTransaction();
			$db->execute($generator->__toString());
			$db->commit();
		}else{
			throw new AclException('dbName key is not present or his value is empty!');
		}
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllAcls()
	 */
	public function loadAllAcls(): array {
		return DAO::getAll($this->aclClass);
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::saveAcl()
	 */
	public function saveAcl(AclElement $aclElement) {
		$object = $this->castElement($aclElement);
		$res = DAO::save($object);
		if ($res) {
			$aclElement->setId($object->getId());
		}
		return $res;
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::removeAcl()
	 */
	public function removeAcl(AclElement $aclElement) {
		return DAO::remove($aclElement);
	}

	protected function loadElements(string $className): array {
		$elements = DAO::getAll($className);
		$result = [];
		foreach ($elements as $elm) {
			$result[$elm->getName()] = $elm;
		}
		return $result;
	}

	protected function castElement($part) {
		$class = $this->getModelClasses()[get_class($part)] ?? get_class($part);
		return $part->castAs($class);
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllPermissions()
	 */
	public function loadAllPermissions(): array {
		return $this->loadElements($this->permissionClass);
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllResources()
	 */
	public function loadAllResources(): array {
		return $this->loadElements($this->resourceClass);
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllRoles()
	 */
	public function loadAllRoles(): array {
		return $this->loadElements($this->roleClass);
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::savePart()
	 */
	public function savePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
		$object = $this->castElement($part);
		$res = DAO::insert($object);
		if ($res) {
			$part->setId($object->getId());
		}
		return $res;
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::updatePart()
	 */
	public function updatePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
		return DAO::update($this->castElement($part));
	}

	/**
	 *
	 * {@inheritdoc}
	 * @see \Ubiquity\security\acl\persistence\AclProviderInterface::removePart()
	 */
	public function removePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
		return DAO::remove($this->castElement($part));
	}

	public function isAutosave(): bool {
		return true;
	}

	public function saveAll(): void {}

	public function existPart(AbstractAclPart $part): bool {
		$elm = $this->castElement($part);
		return DAO::exists(\get_class($elm), 'id= ?', [
			$elm->getId()
		]);
	}

	public function existAcl(AclElement $aclElement): bool {
		$elm = $this->castElement($aclElement);
		return DAO::exists(\get_class($aclElement), 'id= ?', [
			$elm->getId()
		]);
	}

	public function getDetails(): array {
		return [
			'user' => $this->roleClass,
			'archive' => $this->resourceClass,
			'unlock alternate' => $this->permissionClass,
			'lock' => $this->aclClass
		];
	}

	public function getModelClassesSwap(): array {
		$swap = $this->getModelClasses();
		$classes = \array_values($swap);
		$result = [];
		foreach ($classes as $class) {
			$result[$class] = $swap;
		}
		return $result;
	}

	public function getModelClasses(): array {
		return [
			AclElement::class => $this->aclClass,
			Role::class => $this->roleClass,
			Resource::class => $this->resourceClass,
			Permission::class => $this->permissionClass
		];
	}

	public function clearAll(): void {}

	/**
	 * Initializes AclDAOProvider and creates ACL tables in the specified dbOffset.
	 * Do not use in production
	 *
	 * @param array $config
	 * @param string $dbOffset
	 * @param array $classes
	 *        	associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
	 * @return AclDAOProvider
	 * @throws AclException
	 */
	public static function initializeProvider(array $config,string $dbOffset='default',array $classes = []): AclDAOProvider {
		$dbProvider=new AclDAOProvider($config,$classes);
		$dbProvider->initModelsCache($config);
		$dbProvider->setDbOffset($dbOffset);
		$dbProvider->generateDbTables($dbOffset);
		return $dbProvider;
	}
}


1		<?php
2		namespace Ubiquity\security\acl\persistence;
3
4		use Ubiquity\cache\CacheManager;
5		use Ubiquity\cache\ClassUtils;
6		use Ubiquity\controllers\Startup;
7		use Ubiquity\db\reverse\DbGenerator;
8		use Ubiquity\exceptions\AclException;
9		use Ubiquity\orm\DAO;
10		use Ubiquity\orm\reverse\DatabaseReversor;
11		use Ubiquity\scaffolding\creators\ClassCreator;
12		use Ubiquity\security\acl\models\AbstractAclPart;
13		use Ubiquity\security\acl\models\AclElement;
14		use Ubiquity\security\acl\models\Permission;
15		use Ubiquity\security\acl\models\Resource;
16		use Ubiquity\security\acl\models\Role;
17
18		/**
19		* Load and save Acls with a database using DAO.
20		* Ubiquity\security\acl\persistence$AclDAOProvider
21		* This class is part of Ubiquity
22		*
23		* @author jc
24		* @version 1.0.1
25		*
26		*/
27		class AclDAOProvider implements AclProviderInterface {
28
29		protected string $aclClass;
30
31		protected string $roleClass;
32
33		protected string $permissionClass;
34
35		protected string $resourceClass;
36
37		/**
38		* @param array $config The $config array
39		* @param array $classes
40		* associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
41		*/
42	4	public function __construct(array &$config,$classes = []) {
43	4	Startup::$config=$config;
44	4	$this->aclClass = $classes['acl'] ?? AclElement::class;
45	4	$this->roleClass = $classes['role'] ?? Role::class;
46	4	$this->resourceClass = $classes['resource'] ?? Resource::class;
47	4	$this->permissionClass = $classes['permission'] ?? Permission::class;
48	4	}
49
50		/**
51		* Initialize the cache for the ACL models.
52		* @param $config
53		*/
54		public function initModelsCache(&$config) {
55		CacheManager::start($config);
56		CacheManager::createOrmModelCache($this->aclClass);
57		CacheManager::createOrmModelCache($this->roleClass);
58		CacheManager::createOrmModelCache($this->resourceClass);
59		CacheManager::createOrmModelCache($this->permissionClass);
60		}
61
62		/**
63		* Defines the database offset used for ACL.
64		* @param string $dbOffset
65		* @param bool $persist
66		*/
67		public function setDbOffset(string $dbOffset = 'default',bool $persist=true):void {
68		DAO::setModelDatabase($this->aclClass, $dbOffset);
69		DAO::setModelDatabase($this->resourceClass, $dbOffset);
70		DAO::setModelDatabase($this->roleClass, $dbOffset);
71		DAO::setModelDatabase($this->permissionClass, $dbOffset);
72		if($persist){
73		CacheManager::storeModelsDatabases(DAO::getModelsDatabase ());
74		}
75		}
76
77		/**
78		* Generates the models.
79		* @param array $classes associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
80		*/
81		public function createModels(array $classes=[]):void{
82		$this->createModel($classes['acl'] ?? $this->aclClass,AclElement::class);
83		$this->createModel($classes['role'] ?? $this->roleClass,Role::class);
84		$this->createModel($classes['resource'] ?? $this->resourceClass,Resource::class);
85		$this->createModel($classes['permission'] ?? $this->permissionClass,Permission::class);
86		}
87
88		public function createModel($modelName,$refName):void{
89		if($modelName!==$refName){
90		$className=ClassUtils::getClassSimpleName($modelName);
91		$ns=ClassUtils::getNamespaceFromCompleteClassname($modelName);
92		$cCreator=new ClassCreator($className,'',$ns,' extends '.$refName);
93		$cCreator->generate();
94		}
95		}
96
97		/**
98		* Generates the tables for ACL model classes.
99		* @param string $dbOffset
100		* @param bool $createDb
101		* @throws AclException
102		*/
103		public function generateDbTables(string $dbOffset='default',bool $createDb=false):void{
104		$this->setDbOffset($dbOffset);
105		$generator = new DatabaseReversor(new DbGenerator(), $dbOffset);
106		$activeOffsetValue=DAO::getDbOffset(Startup::$config,$dbOffset);
107		if(($dbName=$activeOffsetValue['dbName']??'')!='') {
108		$generator->setModels([$this->aclClass,$this->roleClass,$this->resourceClass,$this->permissionClass]);
109		$generator->createDatabase($dbName, $createDb);
110		$db=DAO::getDatabase($dbOffset);
111		$db->beginTransaction();
112		$db->execute($generator->__toString());
113		$db->commit();
114		}else{
115		throw new AclException('dbName key is not present or his value is empty!');
116		}
117		}
118
119		/**
120		*
121		* {@inheritdoc}
122		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllAcls()
123		*/
124	4	public function loadAllAcls(): array {
125	4	return DAO::getAll($this->aclClass);
126		}
127
128		/**
129		*
130		* {@inheritdoc}
131		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::saveAcl()
132		*/
133	1	public function saveAcl(AclElement $aclElement) {
134	1	$object = $this->castElement($aclElement);
135	1	$res = DAO::save($object);
136	1	if ($res) {
137	1	$aclElement->setId($object->getId());
138		}
139	1	return $res;
140		}
141
142		/**
143		*
144		* {@inheritdoc}
145		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::removeAcl()
146		*/
147	1	public function removeAcl(AclElement $aclElement) {
148	1	return DAO::remove($aclElement);
149		}
150
151	4	protected function loadElements(string $className): array {
152	4	$elements = DAO::getAll($className);
153	4	$result = [];
154	4	foreach ($elements as $elm) {
155	4	$result[$elm->getName()] = $elm;
156		}
157	4	return $result;
158		}
159
160	3	protected function castElement($part) {
161	3	$class = $this->getModelClasses()[get_class($part)] ?? get_class($part);
162	3	return $part->castAs($class);
163		}
164
165		/**
166		*
167		* {@inheritdoc}
168		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllPermissions()
169		*/
170	4	public function loadAllPermissions(): array {
171	4	return $this->loadElements($this->permissionClass);
172		}
173
174		/**
175		*
176		* {@inheritdoc}
177		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllResources()
178		*/
179	4	public function loadAllResources(): array {
180	4	return $this->loadElements($this->resourceClass);
181		}
182
183		/**
184		*
185		* {@inheritdoc}
186		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::loadAllRoles()
187		*/
188	4	public function loadAllRoles(): array {
189	4	return $this->loadElements($this->roleClass);
190		}
191
192		/**
193		*
194		* {@inheritdoc}
195		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::savePart()
196		*/
197	2	public function savePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
198	2	$object = $this->castElement($part);
199	2	$res = DAO::insert($object);
200	2	if ($res) {
201	2	$part->setId($object->getId());
202		}
203	2	return $res;
204		}
205
206		/**
207		*
208		* {@inheritdoc}
209		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::updatePart()
210		*/
211	1	public function updatePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
212	1	return DAO::update($this->castElement($part));
213		}
214
215		/**
216		*
217		* {@inheritdoc}
218		* @see \Ubiquity\security\acl\persistence\AclProviderInterface::removePart()
219		*/
220	2	public function removePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
221	2	return DAO::remove($this->castElement($part));
222		}
223
224	1	public function isAutosave(): bool {
225	1	return true;
226		}
227
228		public function saveAll(): void {}
229
230	1	public function existPart(AbstractAclPart $part): bool {
231	1	$elm = $this->castElement($part);
232	1	return DAO::exists(\get_class($elm), 'id= ?', [
233	1	$elm->getId()
234		]);
235		}
236
237	1	public function existAcl(AclElement $aclElement): bool {
238	1	$elm = $this->castElement($aclElement);
239	1	return DAO::exists(\get_class($aclElement), 'id= ?', [
240	1	$elm->getId()
241		]);
242		}
243
244		public function getDetails(): array {
245		return [
246		'user' => $this->roleClass,
247		'archive' => $this->resourceClass,
248		'unlock alternate' => $this->permissionClass,
249		'lock' => $this->aclClass
250		];
251		}
252
253		public function getModelClassesSwap(): array {
254		$swap = $this->getModelClasses();
255		$classes = \array_values($swap);
256		$result = [];
257		foreach ($classes as $class) {
258		$result[$class] = $swap;
259		}
260		return $result;
261		}
262
263	3	public function getModelClasses(): array {
264		return [
265	3	AclElement::class => $this->aclClass,
266	3	Role::class => $this->roleClass,
267	3	Resource::class => $this->resourceClass,
268	3	Permission::class => $this->permissionClass
269		];
270		}
271
272	1	public function clearAll(): void {}
273
274		/**
275		* Initializes AclDAOProvider and creates ACL tables in the specified dbOffset.
276		* Do not use in production
277		*
278		* @param array $config
279		* @param string $dbOffset
280		* @param array $classes
281		* associative array['acl'=>'','role'=>'','resource'=>'','permission'=>'']
282		* @return AclDAOProvider
283		* @throws AclException
284		*/
285		public static function initializeProvider(array $config,string $dbOffset='default',array $classes = []): AclDAOProvider {
286		$dbProvider=new AclDAOProvider($config,$classes);
287		$dbProvider->initModelsCache($config);
288		$dbProvider->setDbOffset($dbOffset);
289		$dbProvider->generateDbTables($dbOffset);
290		return $dbProvider;
291		}
292		}
293

phpMv / ubiquity-acl

Push — main ( fb0070...d585ad )

AclDAOProvider::initModelsCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like