AppTraceableRecordSet::isLoggable() - Code Metrics - Inspection of "add default cancel action for recordeditor" - capwelton/libapp - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — feature/useWidgetsNamespaces (54f503)

by Robin
created 2022-10-21 15:13 UTC
AppTraceableRecordSet::isLoggable() A

↳ Parent: AppTraceableRecordSet
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
eloc	1
c	1
b	0
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\Func_App;
use Capwelton\LibOrm\Criteria\ORMCriteria;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\ORMRecord;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Criteria\ORMIsCriterion;
filter:
    dependency_paths: ["lib/*"]
use function Capwelton\LibOrm\ORM_StringField;

use function Capwelton\LibOrm\ORM_UserField;

use function Capwelton\LibOrm\ORM_DatetimeField;

use function Capwelton\LibOrm\ORM_IntField;

use function Capwelton\LibOrm\ORM_EnumField;


/**
 * @property ORMUserField $createdBy
 * @property ORMDateTimeField $createdOn
 * @property ORMIntField $modifiedBy
 * @property ORMDateTimeField $modifiedOn
 * @property ORMIntField $deletedBy
 * @property ORMDateTimeField $deletedOn
 * @property ORMEnumField $deleted
 * @property ORMStringField $uuid
 *
 * @method AppTraceableRecord                       get(mixed $criteria)
 * @method AppTraceableRecord                       request(mixed $criteria)
 * @method AppTraceableRecord[]|ORMMySqlIterator    select(ORMCriteria $criteria = null)
 * @method AppTraceableRecord                       newRecord()
 */
class AppTraceableRecordSet extends AppRecordSet
{
    
    /**
     * @var bool
     */
    private $loggable = false;
    
    /**
     * @var bool
     */
    private $traceable = true;
    
    /**
     * @param Func_App $App
     */
    public function __construct(Func_App $App)
    {
        parent::__construct($App);
        
        $this->addFields(
            ORM_UserField('createdBy')->setDescription('Created by'), 
            ORM_DatetimeField('createdOn')->setDescription('Created on'), 
            ORM_UserField('modifiedBy')->setDescription('Modified by'), 
            ORM_DateTimeField('modifiedOn')->setDescription('Modified on'), 
            ORM_IntField('deletedBy')->setDescription('Deleted by'), 
            ORM_DateTimeField('deletedOn')->setDescription('Deleted on'), 
            ORM_EnumField('deleted', AppTraceableRecord::getDeletedStatuses())->setDescription('Deleted'), 
            ORM_StringField('uuid')->setDescription('Universally Unique IDentifier')
        );
        
        // This condition will be applied whenever we select or join Records from this RecordSet.
        $this->setDefaultCriteria($this->deleted->is(false));
    }
    
    /**
     * Defines if the insertions/updates/deletions on the recordSet will be logged.
     *
     * @param bool $loggable
     * @return self
     */
    protected function setLoggable($loggable)
    {
        $this->loggable = $loggable;
        return $this;
    }
    
    /**
     * Checks if the insertions/updates/deletions on the recordSet will be logged.
     *
     * @return bool
     */
    protected function isLoggable()
    {
        return $this->loggable;
    }
    
    /**
     * Defines if the insertions/updates/deletions on the recordSet will be traced.
     *
     * @param bool $traceable
     * @return self
     */
    public function setTraceable($traceable)
    {
        $this->traceable = $traceable;
        return $this;
    }
    
    /**
     * Checks if the insertions/updates/deletions on the recordSet will be traced.
     *
     * @return bool
     */
    public function isTraceable()
    {
        return $this->traceable;
    }
    
    /**
     * @param AppTraceableRecord $record
     * @param bool $noTrace
     */
    protected function logSave(AppTraceableRecord $record, $noTrace)
    {
        if(! $this->isLoggable()){
            return;
        }
        $App = $this->App();
        $userId = bab_getUserId();
        $logSet = $App->LogSet();
        $log = $logSet->newRecord();
        $log->noTrace = $noTrace;
        $log->objectClass = get_class($record);
        $log->objectId = $record->id;
        $now = date('Y-m-d H:i:s');
        $log->modifiedOn = $now;
        $log->modifiedBy = $userId;
        $log->data = $logSet->serialize($record);
        $log->save();
    }
    
    /**
     * @param ORMCriteria $criteria
     * @param bool $noTrace
     */
    protected function logDelete(ORMCriteria $criteria, $noTrace)
    {
        if(! $this->isLoggable()){
            return;
        }
        $App = $this->App();
        $userId = bab_getUserId();
        $logSet = $App->LogSet();
        $deletedRecords = $this->select($criteria);
        foreach ($deletedRecords as $record){
            $log = $logSet->newRecord();
            $log->noTrace = $noTrace;
            $log->objectClass = get_class($record);
            $log->objectId = $record->id;
            $now = date('Y-m-d H:i:s');
            $log->modifiedOn = $now;
            $log->modifiedBy = $userId;
            $log->data = '';
            $log->save();
        }
    }
    
    /**
     * Returns an iterator on records matching the specified criteria.
     * The iterator will not include records flagged as deleted unless
     * the $includeDeleted parameter is set to true.
     *
     * @param ORMCriteria $criteria
     *            Criteria for selecting records.
     * @param bool $includeDeleted
     *            True to include delete-flagged records.
     * @return AppTraceableRecord[] Iterator on success, null if the backend has not been set
     */
    public function select(ORMCriteria $criteria = null, $includeDeleted = false)
    {
        if($includeDeleted){
            $this->setDefaultCriteria(null);
        }
        return parent::select($criteria);

    }
    
    /**
     * Returns the first item matching the specified criteria.
     * The item will not include records flagged as deleted unless
     * the $includeDeleted parameter is set to true.
     *
     * @param ORMCriteria $criteria
     *            Criteria for selecting records.
     * @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.
     * @param bool $includeDeleted
     *            True to include delete-flagged records.
     * @return \ORM_Item Iterator on success, null if the backend has not been set
     */
    /*
     * public function get(ORMCriteria $criteria = null, $sPropertyName = null, $includeDeleted = false)
     * {
     * if ($includeDeleted) {
     * $this->setDefaultCriteria(null);
     * }
     * return parent::get($criteria, $sPropertyName);
     * }
     */
    
    /**
     * Deleted records matching the specified criteria.
     * If $deletedStatus is true, records are not permanently deleted
     * If $deletedStatus is one of the crm_TraceableRecord::DELETED_STATUS_xxx constants, it is just
     * flagged with this status and kept in the database.
     *
     * @param ORMCriteria $criteria
     *            The criteria for selecting the records to delete.
     * @param int|bool $deletedStatus
     *            True to delete permanently the record.
     * @return bool True on success, false otherwise
     */
    public function delete(ORMCriteria $criteria = null, $deletedStatus = AppTraceableRecord::DELETED_STATUS_DELETED)
    {
        $definitive = ($deletedStatus === true) || ! $this->isTraceable();
        $this->logDelete($criteria, $definitive);
        $this->logDelete(/** @scrutinizer ignore-type */ $criteria, $definitive);
        if($definitive){
            return parent::delete($criteria);
        }
        
        require_once $GLOBALS['babInstallPath'] . '/utilit/dateTime.php';
        $now = \BAB_DateTime::now()->getIsoDateTime();
        
        $records = $this->select($criteria);
        
        foreach ($records as $record){
            /* @var $record AppTraceableRecord */
            // Could be optimized at ORM level
            $record->deleted = $deletedStatus;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
            $record->deletedOn = $now;
            $record->deletedBy = bab_getUserId();
            
            if(! parent::save($record)){
                return false;
            }
        }
        return true;
    }
    
    /**
     * Saves a record and keeps traces of the user doing it.
     *
     * @param ORMRecord $record
     *            The record to save.
     * @param bool $noTrace
     *            True to bypass the tracing of modifications.
     * @return boolean True on success, false otherwise
     */
    public function save(ORMRecord $record, $noTrace = false)
    {
        $noTrace = $noTrace || ! $this->isTraceable();
        $this->logSave($record, $noTrace);
        if($noTrace){
            return parent::save($record);
        }
        
        require_once $GLOBALS['babInstallPath'] . '/utilit/dateTime.php';
        
        $now = \BAB_DateTime::now()->getIsoDateTime();
        
        // We first check if the record already has a createdBy.
        $set = $record->getParentSet();
        $primaryKey = $set->getPrimaryKey();
        
        if(empty($record->{$primaryKey})){
            $record->initValue('createdBy', bab_getUserId());
            $record->initValue('createdOn', $now);
            $record->initValue('uuid', $this->uuid());
        }
        
        $record->initValue('modifiedBy', bab_getUserId());
        $record->initValue('modifiedOn', $now);
        
        return parent::save($record);
    }
    
    /**
     * Generates a Universally Unique IDentifier, version 4.
     * RFC 4122 (http://www.ietf.org/rfc/rfc4122.txt)
     *
     * @return string
     */
    private function uuid()
    {
        return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x', mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0x0fff) | 0x4000, mt_rand(0, 0x3fff) | 0x8000, mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff));
    }
    
    /**
     * Get record by UUID or null if the record does not exists or is deleted or if the uuid is empty
     *
     * @param string $uuid
     * @return AppTraceableRecord
     */
    public function getRecordByUuid($uuid)
    {
        if('' === (string) $uuid){
            return null;
        }
        
        $record = $this->get($this->uuid->is($uuid));
        
        if(! isset($record)){
            return null;
        }
        
        if(! ($record instanceof AppTraceableRecord)){
            return null;
        }
        
        if($record->deleted){
            return null;
        }
        
        return $record;
    }
    
    /**
     * Match records created by the specified user or the current connected user if none specified.
     *
     * @param int|null $userId
     *
     * @return ORMIsCriterion
     */
    public function isOwn($userId = null)
    {
        if(! isset($userId)){
            $userId = bab_getUserId();
        }
        return $this->createdBy->is($userId);
    }

    public function getDisplayNameField(){
        if($this->fieldExist("name")){
            return $this->name;
        }else{
            return $this->uuid;
        }
    }
}

capwelton / libapp

Branch — feature/useWidgetsNamespaces (54f503)

AppTraceableRecordSet::isLoggable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
