AppRecordSet::isDeletable() - Code Metrics - capwelton/libapp - Measure and Improve Code Quality continuously with Scrutinizer

AppRecordSet::isDeletable() A
last analyzed 2022-10-21 15:18 UTC

↳ Parent: AppRecordSet
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	1
Metric	Value
eloc	1
c	2
b	1
f	1
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0
<?php

// -------------------------------------------------------------------------
// OVIDENTIA http://www.ovidentia.org
// Ovidentia is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// -------------------------------------------------------------------------
/**
 * @license http://opensource.org/licenses/gpl-license.php GNU General Public License (GPL)
 * @copyright Copyright (c) 2022 by SI4YOU ({@link https://www.siforyou.com})
 */
namespace Capwelton\LibApp\Set;

use Capwelton\LibApp\AppObjectInterface;
use Capwelton\LibApp\Func_App;
use Capwelton\LibApp\AppAccessManager;
use Capwelton\LibApp\Exceptions\AppNotFoundException;
use Capwelton\LibApp\Exceptions\AppDeletedRecordException;
use Capwelton\LibOrm\ORMRecordSet;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Field\ORMFkField;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Exceptions\ORMBackEndSelectException;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Exceptions\ORMException;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Criteria\ORMCriteria;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\ORMIterator;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Criteria\ORMCriterion;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\MySql\ORMMySqlRecordSet;
filter:
    dependency_paths: ["lib/*"]
use ReflectionClass;

/**
 * @property ORMPkField $id
 *
 * @method AppRecord get(mixed $criteria)
 * @method AppRecord request(mixed $criteria)
 * @method AppRecord[]|ORMMySqlRecordSet select(ORMCriteria $criteria = null)
 * @method AppRecord newRecord()
 */
class AppRecordSet extends ORMRecordSet implements AppObjectInterface
{
    
    /**
     * @var Func_App
     */
    protected $app = null;
    
    protected $accessRights = null;
    
    /**
     * @var AppAccessManager
     */
    private $accessManager = null;
    
    /**
     * @var array
     */
    private $customFields = null;
    
    /**
     * @param Func_App $app
     */
    public function __construct(Func_App $app)
    {
        parent::__construct();
        $this->setApp($app);
        $this->accessRights = array();
        
        $this->setAccessManager($app->AccessManager());
        $this->setPrimaryKey('id');
    }
    
    /**
     * {@inheritdoc}
     * @see AppObjectInterface::setApp()
     */
    public function setApp(Func_App $app)
    {
        $this->app = $app;
        return $this;
    }
    
    /**
     * {@inheritdoc}
     * @see AppObjectInterface::App()
     */
    public function App()
    {
        return $this->app;
    }
    
    /**
     * @param string $setName
     */
    protected function trimSetName($setName)
    {
        if(strpos($setName, '_') === false){
            return $setName;
        }
        $pos = strrpos($setName, '\\');
        if($pos === false){
            return explode('_', $setName)[1];
        }
        return substr($setName, $pos + 1);
    }
    
    /**
     * Similar to the ORMRecordSet::join() method but instanciates the
     * joined RecordSet using App methods.
     *
     * @see ORMRecordSet::join()
     */
    public function join($fkFieldName)
    {
        $fkField = $this->getField($fkFieldName);
        if(! ($fkField instanceof ORMFkField)){
            return $this;
        }
        $setName = $fkField->getForeignSetName();
        
        if(! $setName || 'Set' === $setName){
            throw new \Exception('The set name is missing on foreign key field ' . $fkFieldName);
        }
        
        $appSetName = $this->trimSetName($setName);
        $set = $this->App()->$appSetName();
        $set->setName($fkField->getName());
        $set->setDescription($fkField->getDescription());
        
        $this->aField[$fkFieldName] = $set;

        $set->setParentSet($this);
        return $this;
    }
    
    // /**
    // *
    // * @param string $accessName
    // * @param string $type
    // */
    // public function addAccessRight($accessName, $type = 'acl')
    // {
    // $this->accessRights[$accessName] = $type;
    // }
    
    // /**
    // * @return array
    // */
    // public function getAccessRights()
    // {
    // return $this->accessRights;
    // }
    
    /**
     * @return AppCustomField[]
     */
    public function getCustomFields()
    {
        $App = $this->App();
        
        if(null === $this->customFields){
            $this->customFields = array();
            
            if(isset($App->CustomField)){

                $customFieldSet = $App->CustomFieldSet();
                $object = mb_substr(get_class($this), mb_strlen($App->classPrefix), - mb_strlen('Set'));
                try{
                    $customFields = $customFieldSet->select($customFieldSet->object->is($object));
                    
                    foreach ($customFields as $customfield){
                        $this->customFields[] = $customfield;
                        
                        /*@var $customfield AppCustomField */
                    }
                }
                catch (ORMBackEndSelectException $e){
                    // table does not exist, this error is thrown by the install program while creating the sets
                }
            }
        }
        
        return $this->customFields;
    }
    
    /**
     * @return AppCustomField[]
     */
    public function selectCustomFields()
    {
        $App = $this->App();
        
        $customFieldSet = $App->CustomFieldSet();
        $object = mb_substr(get_class($this), mb_strlen($App->classPrefix), - mb_strlen('Set'));
        
        $customFields = $customFieldSet->select($customFieldSet->object->is($object));
        
        return $customFields;
    }
    
    /**
     * @return self
     */
    public function addCustomFields()
    {
        $customFields = $this->selectCustomFields();
        foreach ($customFields as $customField){
            /*@var $customField AppCustomField */
            $description = $customField->name;
            $ormField = $customField->getORMField()->setDescription($description);
            if($ormField instanceof ORMFkField){
                $this->hasOne($customField->fieldname, $ormField->getForeignSetName())
                    ->setDescription($description);
            }
            else{
                $this->addFields($ormField);
            }
        }
        
        return $this;
    }
    
    /**
     * Similar to ORMRecordSet::get() method but throws a AppNotFoundException if the
     * record is not found.
     *
     * @since 1.0.18
     * @throws ORMException::
     * @throws AppNotFoundException
     *
     * @param ORMCriteria|string $mixedParam
     *            Criteria for selecting records
     *            or the value for selecting record
     * @param string $sPropertyName
     *            The name of the property on which
     *            the value applies. If not
     *            specified or null, the set's
     *            primary key will be used.
     * @return AppRecord
     */
    public function request($mixedParam = null, $sPropertyName = null)
    {
        $record = $this->get($mixedParam, $sPropertyName);
        $record = $this->get($mixedParam, $sPropertyName);
        if(! isset($record)){
            // This will remove the default criteria for TraceableRecords and
            // fetch even 'deleted' ones.
            $this->setDefaultCriteria(null);
            $record = $this->get($mixedParam, $sPropertyName);
            if(isset($record)){
                throw new AppDeletedRecordException($record, $mixedParam);
                throw /** @scrutinizer ignore-call */ new AppDeletedRecordException($record, $mixedParam);
            }
            throw new AppNotFoundException($this, $mixedParam);
        }
        return $record;
    }
    
    /**
     * Returns an iterator of traceableRecord linked to the specified source,
     * optionally filtered on the specified link type.
     *
     * @param
     *            AppRecord | array $source source can be an array of record
     * @param string $linkType
     *
     * @return ORMIterator
     */
    public function selectLinkedTo($source, $linkType = null)
    {
        $linkSet = $this->App()->LinkSet();
        
        $targetClass = $this->getRecordClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = (new \ReflectionClass($targetClass))->getShortName();
        }
        
        if(is_array($source) || ($source instanceof \Iterator)){
            return $linkSet->selectForSources($source, $targetClass, $linkType);
        }
        else{
            return $linkSet->selectForSource($source, $targetClass, $linkType);
        }
    }
    
    /**
     * Returns an iterator of traceableRecord linked to the specified target,
     * optionally filtered on the specified link type.
     *
     * @param
     *            AppRecord | array $target target can be an array of record
     * @param string $linkType
     *
     * @return ORMIterator
     */
    public function selectLinkedFrom($target, $linkType = null)
    {
        $linkSet = $this->App()->LinkSet();
        
        $sourceClass = $this->getRecordClassName();
        if(strpos($sourceClass, '\\')){
            $sourceClass = (new \ReflectionClass($sourceClass))->getShortName();
        }
        
        if(is_array($target) || ($target instanceof \Iterator)){
            return $linkSet->selectForTargets($target, $sourceClass, $linkType);
        }
        else{
            return $linkSet->selectForTarget($target, $sourceClass, $linkType);
        }
    }
    
    /**
     * Returns a criteria usable to select records of this set which are source of app_Links to the specified AppRecord.
     *
     * @param AppRecord $target
     * @param string $linkType
     * @return ORMCriteria
     */
    public function isSourceOf(AppRecord $target, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        
        $recordClassName = $this->getRecordClassName();
        if(strpos($recordClassName, '\\')){
            $recordClassName = (new \ReflectionClass($recordClassName))->getShortName();
        }
        $linkSet->hasOne('sourceId', $recordClassName);
        
        $targetClass = $target->getClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = (new \ReflectionClass($targetClass))->getShortName();
        }
        
        $criteria = $linkSet->targetClass->is($targetClass)
            ->_AND_($linkSet->targetId->is($target->id))
            ->_AND_($linkSet->sourceClass->is($this->newRecord()
            ->getClassName()));
        if(isset($linkType)){
            if(is_array($linkType)){

                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $criteria = $this->id->in($criteria, 'sourceId');
        
        return $criteria;
    }
    
    /**
     * Returns a criteria usable to select records of this set which are target of app_Links to the specified AppRecord.
     *
     * @param AppRecord $source
     * @param null|string|string[] $linkType
     * @return ORMCriteria
     */
    public function isTargetOf(AppRecord $source, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        
        $recordClassName = $this->getRecordClassName();
        if(strpos($recordClassName, '\\')){
            $recordClassName = (new \ReflectionClass($recordClassName))->getShortName();
        }
        $linkSet->hasOne('targetId', $recordClassName);
        
        $sourceClass = $source->getClassName();
        if(strpos($sourceClass, '\\')){
            $sourceClass = new \ReflectionClass($sourceClass);
        }
        
        $targetClass = $this->newRecord()->getClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = new \ReflectionClass($targetClass);
        }
        
        $criteria = $linkSet->sourceClass->is($sourceClass)
            ->_AND_($linkSet->sourceId->is($source->id))
            ->_AND_($linkSet->targetClass->is($targetClass));
        if(isset($linkType)){
            if(is_array($linkType)){
                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $criteria = $this->id->in($criteria, 'targetId');
        
        return $criteria;
    }
    
    /**
     * Returns a criteria usable to select records of this set which are target of app_Links from the specified AppRecords.
     *
     * @since 1.0.23
     * @param AppRecord[] $sources
     * @param null|string|string[] $linkType
     * @return ORMCriteria
     */
    public function isTargetOfAny($sources, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        $recordClassName = $linkSet->getRecordClassName();
        if(strpos($recordClassName, '\\')){
            $recordClassName = (new \ReflectionClass($recordClassName))->getShortName();
        }
        $linkSet->hasOne('targetId', $recordClassName);
        
        $sourceIdsByClasses = array();
        foreach ($sources as $source){
            $sourceClass = $source->getClassName();
            if(strpos($sourceClass, '\\')){
                $sourceClass = (new \ReflectionClass($sourceClass))->getShortName();
            }
            if(! isset($sourceIdsByClasses[$sourceClass])){
                $sourceIdsByClasses[$sourceClass] = array();
            }
            $sourceIdsByClasses[$sourceClass][] = $source->id;
        }
        
        $sourcesCriteria = array();
        foreach ($sourceIdsByClasses as $sourceClass => $sourceIds){
            $sourcesCriteria[] = $linkSet->sourceClass->is($sourceClass)->_AND_($linkSet->sourceId->in($sourceIds));
        }
        
        $targetClass = $this->newRecord()->getClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = (new \ReflectionClass($targetClass))->getShortName();
        }
        
        $criteria = $linkSet->all($linkSet->targetClass->is($targetClass), $linkSet->any($sourcesCriteria));
        if(isset($linkType)){
            if(is_array($linkType)){
                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $criteria = $this->id->in($criteria, 'targetId');
        
        return $criteria;
    }
    
    /**
     * Returns a criteria usable to select records of this set which are source of app_Links to the specified AppRecords.
     *
     * @since 1.0.23
     * @param AppRecord[] $targets
     * @param string|null $linkType
     * @return ORMCriteria
     */
    public function isSourceOfAny($targets, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        $recordClassName = $this->getRecordClassName();
        if(strpos($recordClassName, '\\')){
            $recordClassName = (new \ReflectionClass($recordClassName))->getShortName();
        }
        $linkSet->hasOne('sourceId', $recordClassName);
        
        $targetIdsByClasses = array();
        foreach ($targets as $target){
            $targetClass = $target->getClassName();
            if(strpos($targetClass, '\\')){
                $targetClass = (new \ReflectionClass($targetClass))->getShortName();
            }
            if(! isset($targetIdsByClasses[$targetClass])){
                $targetIdsByClasses[$targetClass] = array();
            }
            $targetIdsByClasses[$targetClass][] = $target->id;
        }
        
        $targetsCriteria = array();
        foreach ($targetIdsByClasses as $targetClass => $targetIds){
            $targetsCriteria[] = $linkSet->targetClass->is($targetClass)->_AND_($linkSet->targetId->in($targetIds));
        }
        
        $sourceClass = $this->newRecord()->getClassName();
        if(strpos($sourceClass, '\\')){
            $sourceClass = (new \ReflectionClass($sourceClass))->getShortName();
        }
        
        $criteria = $linkSet->all($linkSet->sourceClass->is($sourceClass), $linkSet->any($targetsCriteria));
        if(isset($linkType)){
            if(is_array($linkType)){

                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $criteria = $this->id->in($criteria, 'sourceId');
        
        return $criteria;
    }
    
    /**
     * @param AppAccessManager $accessManager
     * @return self
     */
    public function setAccessManager(AppAccessManager $accessManager)
    {
        $this->accessManager = $accessManager;
        return $this;
    }
    
    /**
     * @return AppAccessManager
     */
    public function getAccessManager()
    {
        return $this->accessManager;
    }
    
    /**
     * Defines if records can be created by the current user.
     *
     * @return boolean
     */
    public function isCreatable()
    {
        return false;
    }
    
    /**
     * @return ORMCriteria
     */
    public function isReadable()
    {
        return $this->hasAccess('read');
    }
    
    /**
     * @return ORMCriteria
     */
    public function isUpdatable()
    {
        return $this->hasAccess('update');
    }
    
    /**
     * @return ORMCriteria
     */
    public function isDeletable()
    {
        return $this->hasAccess('delete');
    }
    
    /**
     * Returns a criterion matching records that can be put to trash by the current user.
     *
     * @return ORMCriterion
     */
    public function isRemovable()
    {
        return $this->isUpdatable();
    }
    
    /**
     * Returns a criterion matching records that can be restored from the trash by the current user.
     *
     * @return ORMCriterion
     */
    public function isRestorable()
    {
        return $this->isUpdatable();
    }
    
    /**
     * Returns a criterion matching records deletable by the current user.
     *
     * @param string $accessType
     * @param int|null $user
     *
     * @return ORMCriterion
     */
    public function hasAccess($accessType, $user = null)
    {
        $accessManager = $this->getAccessManager();
        return $accessManager->getAccessCriterion($this, $accessType, $user);
    }
    
    /**
     * Returns a criteria usable to select records of this set associated to the specified tags.
     *
     * @array	$tags		An array of tag ids
     * @string	$type		The link type [optional]
     * @return ORMCriteria
     */
    public function haveTagLabels($tagLabels, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        
        /* @var $tagSet AppRecordSet */
        $tagSet = $App->TagSet();
        $tagSet = $App->TagSet();
        $tagClassName = (new \ReflectionClass($tagSet->getRecordClassName()))->getShortName();
        
        $linkSet->joinTarget($tagClassName);
        $criteria = $linkSet->sourceClass->is((new \ReflectionClass($this->getRecordClassName()))->getShortName())
            ->_AND_($linkSet->targetClass->is($tagClassName));
        
        if(is_array($tagLabels)){
            $criteria = $criteria->_AND_($linkSet->targetId->label->in($tagLabels));
        }
        else{
            $criteria = $criteria->_AND_($linkSet->targetId->label->is($tagLabels));
        }
        if(isset($linkType)){
            $criteria = $criteria->_AND_($linkSet->type->is($linkType));
        }
        $links = $linkSet->select($criteria);
        $links = $linkSet->select($criteria);
        
        $ids = array();
        foreach ($links as $link){
            $ids[$link->sourceId] = $link->sourceId;
        }
        
        return $this->id->in($ids);
    }
    
    public function getVisibilityCriteriaFields()
    {
        $fields = $this->getFields();
        $manyRelations = $this->getHasManyRelations();
        foreach ($manyRelations as $fieldName => $manyRelation){
            $fields[$fieldName] = $manyRelation;
        }
        return $fields;
    }

    public function getController($proxy = true){
        $name = $this->getRecordClassName();
        $reflection = new ReflectionClass($name);
        $name = $reflection->getShortName();
        return $this->App()->Controller()->$name($proxy);
    }

    public function getDisplayNameField(){
        if($this->fieldExist("name")){
            return $this->name;
        }else{
            return $this->id;
        }
    }
}
capwelton / libapp

AppRecordSet::isDeletable() A last analyzed 2022-10-21 15:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AppRecordSet::isDeletable() A
last analyzed 2022-10-21 15:18 UTC
