AppRecord::isRestorable() - Code Metrics - Inspection of "add app-container style" - capwelton/libapp - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — feature/useWidgetsNamespaces (b6928f)

by Robin
created 2022-08-12 08:22 UTC
AppRecord::isRestorable() A

↳ Parent: AppRecord
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
eloc	4
c	1
b	0
f	1
dl	0
loc	6
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\Exceptions\AppException;
use Capwelton\LibApp\Ctrl\AppController;
use Capwelton\LibApp\Exceptions\AppAccessException;
use Capwelton\LibOrm\ORMRecord;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Field\ORMFkField;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\MySql\ORMManyRelation;
filter:
    dependency_paths: ["lib/*"]

/**
 * @property int $id
 *
 * @method AppRecordSet getParentSet()
 */
class AppRecord extends ORMRecord implements AppObjectInterface
{
    
    /**
     * @var Func_App
     */
    protected $app = null;
    
    /**
     * Returns the value of the specified field or an iterator if $sFieldName represents a 'Many relation'.
     *
     * @param string $sFieldName
     *            The name of the field or relation for which the value must be returned.
     * @param array $args
     *            Optional arguments.
     * @return mixed The value of the field or null if the field is not a part of the record.
     */
    public function __call($sFieldName, $args)
    {
        $value = $this->oParentSet->getBackend()->getRecordValue($this, $sFieldName);
        $field = $this->oParentSet->$sFieldName;
        if(! is_null($value) && $field instanceof ORMFkField){
            
            $sClassName = $field->getForeignSetName();
            
            $App = $this->App();
            $prefixLength = mb_strlen($App->classPrefix);
            $methodName = mb_substr($sClassName, $prefixLength);
            $set = $App->$methodName();
            
            $set->setName($field->getName());
            $set->setDescription($field->getDescription());
            
            $record = $set->get($value);
            return $record;
        }
        return $value;
    }
    
    /**
     * {@inheritdoc}
     * @see AppObjectInterface::setApp()
     */
    public function setApp(Func_App $app)
    {
        $this->app = $app;
        return $this;
    }
    
    /**
     * Get APP object to use with this record
     *
     * @return Func_App
     */
    public function App()
    {
        if(! isset($this->app)){
            // If the app object was not specified (through the setApp() method),
            // we set it as parent set's App.
            $this->setApp($this->getParentSet()
                ->App());
        }
        return $this->app;
    }
    
    /**
     * Returns the base class name of a record.
     * For example xxx_Contact will return 'Contact'.
     *
     * @since 1.0.40
     * @return string
     */
    public function getClassName()
    {
        $App = $this->App();
        $rClass = new \ReflectionClass(get_class($this));
        $component = $App->getComponentByName($rClass->getShortName());
        if(isset($component)){
            return $component->getRecordClassName();
            // list(, $classname) = explode('_', $component->getRecordClassName());
            // return $classname;
        }
        list (, $classname) = explode('_', get_class($this));
        return $classname;
    }
    
    /**
     * Returns the string reference corresponding to the record.
     *
     * @return string A reference string (e.g. Contact:12)
     */
    public function getRef()
    {
        if(! isset($this->id)){
            throw new AppException('Trying to get the reference string of a record without an id.');
        }
        $classname = $this->getClassName();
        return $classname . ':' . $this->id;
    }
    
    /**
     * @return AppController
     */
    public function getController()
    {
        $App = $this->App();
        
        $ctrlName = $this->getClassName();
        return $App->Controller()->$ctrlName();
    }
    
    /**
     * Deletes the record with respect to referential integrity.
     * Uses referential integrity as defined by hasManyRelation to delete/update
     * referenced elements.
     *
     * @see AppRecordSet::hasMany()
     *
     * @return self
     */
    public function delete($deletedStatus = null)
    {
        $App = $this->App();
        
        if(! isset($deletedStatus)){
            $deletedStatus = AppTraceableRecord::DELETED_STATUS_DELETED;
        }
        
        $set = $this->getParentSet();
        $recordIdName = $set->getPrimaryKey();
        $recordId = $this->$recordIdName;
        
        // Uses referential integrity as defined by hasManyRelation to delete/update
        // referenced elements.
        $manyRelations = $set->getHasManyRelations();
        
        foreach ($manyRelations as $manyRelation){
            /* @var $manyRelation ORMManyRelation */
            
            $foreignSetClassName = $manyRelation->getForeignSetClassName();
            $foreignSetFieldName = $manyRelation->getForeignFieldName();
            $method = mb_substr($foreignSetClassName, mb_strlen($App->classPrefix));
            $foreignSet = $App->$method();
            
            switch ($manyRelation->getOnDeleteMethod()) {
                
                case ORMManyRelation::ON_DELETE_SET_NULL:
                    
                    $foreignRecords = $foreignSet->select($foreignSet->$foreignSetFieldName->is($recordId));
                    
                    foreach ($foreignRecords as $foreignRecord){
                        $foreignRecord->$foreignSetFieldName = 0;
                        $foreignRecord->save();
                    }
                    
                    break;
                
                case ORMManyRelation::ON_DELETE_CASCADE:
                    
                    $foreignRecords = $foreignSet->select($foreignSet->$foreignSetFieldName->is($recordId));
                    
                    foreach ($foreignRecords as $foreignRecord){
                        $foreignRecord->delete();
                    }
                    
                    break;
                
                case ORMManyRelation::ON_DELETE_NO_ACTION:
                default:
                    break;
            }
        }
        
        // We remove all links to and from this record.
        $linkSet = $App->LinkSet();
        $recordClassName = $set->newRecord()->getClassName();
        
        $linkSet->delete($linkSet->sourceClass->is($recordClassName)
            ->_AND_($linkSet->sourceId->is($recordId))
            ->_OR_($linkSet->targetClass->is($recordClassName)
            ->_AND_($linkSet->targetId->is($recordId))));
        
        $set->delete($set->$recordIdName->is($recordId), $deletedStatus);
        
        return $this;
    }
    
    /**
     * Reassociates all data asociated to the record to another
     * specified one.
     *
     * @param int $id
     *
     * @return self
     */
    public function replaceWith($id)
    {
        $App = $this->App();
        
        $set = $this->getParentSet();
        $recordIdName = $set->getPrimaryKey();
        $recordId = $this->$recordIdName;
        
        // Use referential integrity as defined by hasManyRelation to delete/update
        // referenced elements.
        $manyRelations = $set->getHasManyRelations();
        
        foreach ($manyRelations as $manyRelation){
            /* @var $manyRelation ORMManyRelation */
            
            $foreignSetClassName = $manyRelation->getForeignSetClassName();
            $foreignSetFieldName = $manyRelation->getForeignFieldName();
            $method = mb_substr($foreignSetClassName, mb_strlen($App->classPrefix));
            $foreignSet = $App->$method();
            // $foreignSet = new $foreignSetClassName($App);
            $foreignRecords = $foreignSet->select($foreignSet->$foreignSetFieldName->is($recordId));
            
            foreach ($foreignRecords as $foreignRecord){
                $foreignRecord->$foreignSetFieldName = $id;
                $foreignRecord->save();
            }
        }
        
        // We replace all links to and from this record.
        $linkSet = $App->LinkSet();
        $recordClassName = $set->newRecord()->getClassName();
        
        $links = $linkSet->select($linkSet->sourceClass->is($recordClassName)
        $links = $linkSet->select($linkSet->sourceClass->is($recordClassName)
            ->_AND_($linkSet->sourceId->is($recordId)));
        
        foreach ($links as $link){
            $link->sourceId = $id;
            $link->save();
        }
        
        $links = $linkSet->select($linkSet->targetClass->is($recordClassName)
            ->_AND_($linkSet->targetId->is($recordId)));
        
        foreach ($links as $link){
            $link->targetId = $id;
            $link->save();
        }
        
        return $this;
    }
    
    /**
     * @return array
     */
    public function getRelatedRecords()
    {
        $App = $this->App();
        
        $set = $this->getParentSet();
        $recordIdName = $set->getPrimaryKey();
        $recordId = $this->$recordIdName;
        
        // Use referential integrity as defined by hasManyRelation to delete/update
        // referenced elements.
        $manyRelations = $set->getHasManyRelations();
        
        $relatedRecords = array();
        
        foreach ($manyRelations as $manyRelation){
            /* @var $manyRelation ORMManyRelation */
            
            $foreignSetClassName = $manyRelation->getForeignSetClassName();
            $foreignSetFieldName = $manyRelation->getForeignFieldName();
            
            $method = mb_substr($foreignSetClassName, mb_strlen($App->classPrefix));
            $foreignSet = $App->$method();
            // $foreignSet = new $foreignSetClassName($App);
            $foreignRecords = $foreignSet->select($foreignSet->$foreignSetFieldName->is($recordId));
            
            if($foreignRecords->count() > 0){
                $relatedRecords[$foreignSetClassName] = $foreignRecords;
            }
        }
        
        return $relatedRecords;
    }
    
    /**
     * Upload path for record attachments
     *
     * @return \bab_Path
     */
    public function uploadPath()
    {
        $path = $this->App()->uploadPath();
        
        if(null === $path){
            throw new \Exception('Missing upload path information');
            return null;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        }
        
        $path->push($this->getClassName());
        $path->push($this->id);
        
        return $path;
    }
    
    /**
     * @return bool
     */
    public function isLinkedTo(AppRecord $source, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        
        $sourceClass = $source->getClassName();
        if(strpos($sourceClass, '\\')){
            $targetClass = (new \ReflectionClass($sourceClass))->getShortName();

        }
        
        $targetClass = $this->getClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = (new \ReflectionClass($targetClass))->getShortName();
        }
        
        $criteria = $linkSet->sourceClass->is($sourceClass)
            ->_AND_($linkSet->sourceId->is($source->id))
            ->_AND_($linkSet->targetClass->is($targetClass))
            ->_AND_($linkSet->targetId->is($this->id));
        if(isset($linkType)){
            if(is_array($linkType)){
                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $links = $linkSet->select($criteria);
        $links = $linkSet->select($criteria);
        
        $isLinked = ($links->count() > 0);
        
        $linkSet->__destruct();
        unset($linkSet);
        
        return $isLinked;
    }
    
    /**
     * @return bool
     */
    public function isSourceOf(AppRecord $target, $linkType = null)
    {
        $App = $this->App();
        $linkSet = $App->LinkSet();
        
        $sourceClass = $this->getClassName();
        if(strpos($sourceClass, '\\')){
            $targetClass = (new \ReflectionClass($sourceClass))->getShortName();

        }
        
        $targetClass = $target->getClassName();
        if(strpos($targetClass, '\\')){
            $targetClass = (new \ReflectionClass($targetClass))->getShortName();
        }
        
        $criteria = $linkSet->all($linkSet->targetClass->is($targetClass), $linkSet->targetId->is($target->id), $linkSet->sourceClass->is($sourceClass), $linkSet->sourceId->is($this->id));
        
        if(isset($linkType)){
            if(is_array($linkType)){
                $criteria = $criteria->_AND_($linkSet->type->in($linkType));
            }
            else{
                $criteria = $criteria->_AND_($linkSet->type->is($linkType));
            }
        }
        $links = $linkSet->select($criteria);
        $links = $linkSet->select($criteria);
        
        $isLinked = ($links->count() > 0);
        
        $linkSet->__destruct();
        unset($linkSet);
        
        return $isLinked;
    }
    
    /**
     * Link record to $source
     *
     * @param AppRecord $source
     * @param string $linkType
     * @param string $data
     * @return self
     */
    public function linkTo(AppRecord $source, $linkType = '', $data = '')
    {
        $linkSet = $this->App()->LinkSet();
        
        $link = $linkSet->create($source, $this, $linkType, $data);
        
        $link->__destruct();
        unset($link);
        
        $linkSet->__destruct();
        unset($linkSet);
        
        return $this;
    }
    
    /**
     * Unlink record from $source
     *
     * @return self
     */
    public function unlinkFrom(AppRecord $source, $linkType = null)
    {
        $linkSet = $this->App()->LinkSet();
        
        $linkSet->deleteLink($source, $this, $linkType);
        
        return $this;
    }
    
    /**
     * import a value into a traceable record property if the value is not equal
     *
     * @param string $name
     *            property name
     * @param mixed $value
     *            value to set
     * @return int 1 : the value has been modified | 0 : no change
     */
    protected function importProperty($name, $value)
    {
        if(((string) $this->$name) !== ((string) $value)){
            $this->$name = $value;
            return 1;
        }
        
        return 0;
    }
    
    /**
     * import a value into a tracable record property if the value is not equal, try with multiple date format
     * this method work for date field 0000-00-00
     *
     * @param string $name
     *            property name
     * @param mixed $value
     *            value to set
     * @return int 1 : the value has been modified | 0 : no change
     */
    protected function importDate($name, $value)
    {
        if(preg_match('/[0-9]{4}-[0-9]{2}-[0-9]{2}/', $value)){
            return $this->importProperty($name, $value);
        }
        
        // try in DD/MM/YYYY format
        
        if(preg_match('/(?P<day>[0-9]+)\/(?P<month>[0-9]+)\/(?P<year>[0-9]{2,4})/', $value, $matches)){
            
            $value = sprintf('%04d-%02d-%02d', (int) $matches['year'], (int) $matches['month'], (int) $matches['day']);
            
            return $this->importProperty($name, $value);
        }
    }
    
    /**
     * @return string[]
     */
    public function getViews()
    {
        $App = $this->App();
        
        $customContainerSet = $App->CustomContainerSet();
        $customContainers = $customContainerSet->select($customContainerSet->object->is($this->getClassName()));
        $customContainers->groupBy($customContainerSet->view);
        
        $views = array();
        foreach ($customContainers as $customContainer){
            $views[] = $customContainer->view;
        }
        
        if(empty($views)){
            $views[] = '';
        }
        
        return $views;
    }
    
    /**
     * Checks if the record is readable by the current user.
     *
     * @since 1.0.21
     * @return bool
     */
    public function isReadable()
    {
        $set = $this->getParentSet();
        return $set->select($set->isReadable()
            ->_AND_($set->id->is($this->id)))
            ->count() == 1;
    }
    
    /**
     * Checks if the record is updatable by the current user.
     *
     * @since 1.0.21
     * @return bool
     */
    public function isUpdatable()
    {
        $set = $this->getParentSet();
        return $set->select($set->isUpdatable()
            ->_AND_($set->id->is($this->id)))
            ->count() == 1;
    }
    
    /**
     * Checks if the record is deletable by the current user.
     *
     * @since 1.0.21
     * @return bool
     */
    public function isDeletable()
    {
        $set = $this->getParentSet();
        return $set->select($set->isDeletable()
            ->_AND_($set->id->is($this->id)))
            ->count() == 1;
    }
    
    /**
     * Checks if the record can be put to the trash by the current user.
     *
     * @return bool
     */
    public function isRemovable()
    {
        $set = $this->getParentSet();
        return $set->select($set->isRemovable()
            ->_AND_($set->id->is($this->id)))
            ->count() == 1;
    }
    
    /**
     * Checks if the record can be restored from the trash by the current user.
     *
     * @return bool
     */
    public function isRestorable()
    {
        $set = $this->getParentSet();
        return $set->select($set->isRestorable()
            ->_AND_($set->id->is($this->id)))
            ->count() == 1;
    }
    
    /**
     * Ensures that the record is readable by the current user or throws an exception.
     *
     * @since 1.0.40
     * @param string $message
     * @throws AppAccessException
     */
    public function requireReadable($message = null)
    {
        if(! $this->isReadable()){
            $App = $this->App();
            if(! isset($message)){
                $message = $App->translate('Access denied');
            }
            throw new AppAccessException($message);
        }
    }
    
    /**
     * Ensures that the record is updatable by the current user or throws an exception.
     *
     * @since 1.0.40
     * @param string $message
     * @throws AppAccessException
     */
    public function requireUpdatable($message = null)
    {
        if(! $this->isUpdatable()){
            $App = $this->App();
            if(! isset($message)){
                $message = $App->translate('Access denied');
            }
            throw new AppAccessException($message);
        }
    }
    
    /**
     * Ensures that the record is deletable by the current user or throws an exception.
     *
     * @since 1.0.40
     * @param string $message
     * @throws AppAccessException
     */
    public function requireDeletable($message = null)
    {
        if(! $this->isDeletable()){
            $App = $this->App();
            if(! isset($message)){
                $message = $App->translate('Access denied');
            }
            throw new AppAccessException($message);
        }
    }
}
capwelton / libapp

Branch — feature/useWidgetsNamespaces (b6928f)

AppRecord::isRestorable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
