AclDAOProvider.php

Go to the documentation of this file.

<?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;
 
class AclDAOProvider implements AclProviderInterface {
 
    protected string $aclClass;
 
    protected string $roleClass;
 
    protected string $permissionClass;
 
    protected string $resourceClass;
    
    public function __construct(array &$config, array $classes = []) {
        Startup::$config=$config;
        $this->setClasses($classes);
    }
 
    private function setClasses(array $classes): void {
        $this->aclClass = $classes['acl'] ?? AclElement::class;
        $this->roleClass = $classes['role'] ?? Role::class;
        $this->resourceClass = $classes['resource'] ?? Resource::class;
        $this->permissionClass = $classes['permission'] ?? Permission::class;
    }
 
    public function initModelsCache(&$config) {
        CacheManager::start($config);
        CacheManager::createOrmModelCache($this->aclClass);
        CacheManager::createOrmModelCache($this->roleClass);
        CacheManager::createOrmModelCache($this->resourceClass);
        CacheManager::createOrmModelCache($this->permissionClass);
    }
 
    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 ());
        }
    }
 
    public function createModels(string $dbOffset='default', ?array $classes=null): void {
        $classes??=[
            'acl'=>'models\\AclElement','role'=>'models\\Role','resource'=>'models\\Resource','permission'=>'models\\Permission'
        ];
        $this->setClasses($classes);
        $this->createModel($classes['acl'] ?? $this->aclClass,AclElement::class, $dbOffset);
        $this->createModel($classes['role'] ?? $this->roleClass,Role::class, $dbOffset);
        $this->createModel($classes['resource'] ?? $this->resourceClass,Resource::class, $dbOffset);
        $this->createModel($classes['permission'] ?? $this->permissionClass,Permission::class, $dbOffset);
    }
 
    public function createModel(string $modelName, string $refName, string $dbOffset='default'): void {
        if ($modelName!==$refName) {
            $className=ClassUtils::getClassSimpleName($modelName);
            $ns=ClassUtils::getNamespaceFromCompleteClassname($modelName);
            $cCreator=new ClassCreator($className, $ns, ' extends \\'.$refName);
            if ($dbOffset!=='default') {
                $annot=CacheManager::getAnnotationsEngineInstance()->getAnnotation($cCreator, 'database', ['name'=>$dbOffset]);
                $cCreator->addClassAttribute($annot);
            }
            $cCreator->generate();
        }
    }
 
    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!');
        }
    }
 
    public function loadAllAcls(): array {
        $result= DAO::getAll($this->aclClass);
        foreach ($result as $elm) {
            $elm->setType(AclDAOProvider::class);
        }
        return $result;
    }
 
    public function saveAcl(AclElement $aclElement) {
        $aclElement->_rest=[];
        if (!$this->existPart($aclElement->getResource())) {
            $this->savePart($aclElement->getResource());
        }
        if (!$this->existPart($aclElement->getPermission())) {
            $this->savePart($aclElement->getPermission());
        }
        if (!$this->existPart($aclElement->getRole())) {
            $this->savePart($aclElement->getRole());
        }
        $object = $this->castElement($aclElement);
        if ($this->existAcl($aclElement)) {
            $res=DAO::update($object);
        } else {
            $res = DAO::insert($object);
        }
        if ($res) {
            $aclElement->setId($object->getId());
        }
        return $res;
    }
 
    public function removeAcl(AclElement $aclElement) {
        return DAO::remove($aclElement);
    }
 
    protected function loadElements(string $className): array {
        $elements = DAO::getAll($className);
        $result = [];
        foreach ($elements as $elm) {
            $elm->setType(AclDAOProvider::class);
            $result[$elm->getName()] = $elm;
        }
        return $result;
    }
 
    protected function castElement($part) {
        $class = $this->getModelClasses()[get_class($part)] ?? get_class($part);
        return $part->castAs($class);
    }
 
    public function loadAllPermissions(): array {
        return $this->loadElements($this->permissionClass);
    }
 
    public function loadAllResources(): array {
        return $this->loadElements($this->resourceClass);
    }
 
    public function loadAllRoles(): array {
        return $this->loadElements($this->roleClass);
    }
 
    public function savePart(\Ubiquity\security\acl\models\AbstractAclPart $part) {
        $object = $this->castElement($part);
        if ($this->existPart($part)) {
            $object->_rest=[];
            $res = DAO::update($object);
        } else {
            $res=DAO::insert($object);
        }
        if ($res) {
            $part->setName($object->getName());
        }
        return $res;
    }
 
    public function updatePart(string $id, \Ubiquity\security\acl\models\AbstractAclPart $part) {
        $object=$this->castElement($part);
        $object->_rest=[];
        $object->_pkv['___name']=$id;
        return DAO::update($object);
    }
 
    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), 'name= ?', [
            $elm->getName()
        ]);
    }
 
    public function existAcl(AclElement $aclElement): bool {
        $elm = $this->castElement($aclElement);
        return DAO::exists(\get_class($elm), '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 {}
 
    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;
    }
    
    public function cacheUpdated(): bool {
        return false;
    }
}