RecordController::getSource() - Code Metrics - Inspection of "improve identity system speed" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 4d9b91...c71310 )

by Julien
created 2024-12-27 17:53 UTC
RecordController::getSource() A

↳ Parent: RecordController
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0
<?php
/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

namespace Zemit\Modules\Api\Controllers;

use Phalcon\Mvc\Model\MetaData;
use Phalcon\Mvc\ModelInterface;
use Phalcon\Support\Collection;
use Zemit\Models\Table;
use Zemit\Modules\Api\Controller;
use Zemit\Mvc\Model\Dynamic;

class RecordController extends Controller
{
    protected ?int $limit = 10000;
    protected ?int $maxLimit = 10000;
    protected Collection $columnMap;
    protected array $metaData = [];
    protected string $source = 'dynamic';
    
    public function initialize()
    {
        $this->initializeSource();
        $this->initializeTableColumns();
        
        parent::initialize();
    }
    
    public function initializeSource()
    {
        $this->source = $this->getParam('advanced')['tableUuid'] ?? 'dynamic';
    }
    
    public function initializeTableColumns()
    {
        $this->columnMap = new Collection([
            'id' => 'id',
            'uuid' => 'uuid',
            'deleted' => 'deleted',
        ]);
        
        $table = Table::findFirst([
            'uuid = :uuid:',
            'bind' => ['uuid' => $this->getSource()],
        ]);
        if ($table) {
            $columns = $table->getColumnList();
            foreach ($columns as $column) {
                $this->columnMap->set($column->getUuid(), $column->getUuid());
            }
        }
    }
    
    public function listExpose(iterable $items, ?array $expose = null): array
    public function listExpose(iterable $items, /** @scrutinizer ignore-unused */ ?array $expose = null): array
    {
        return (array)$items;
    }
    
    public function initializeSearchFields(): void
    {
        $this->setSearchFields($this->columnMap);
    }
    
    public function initializeFilterFields(): void
    {
        $this->setFilterFields(new Collection([
            'workspaceId',
            'tableId',
        ]));
    }
    
    public function hasAdvanced(string $key)
    {
        $advanced = $this->getParam('advanced') ?? [];
        return isset($advanced[$key]);
    }
    
    public function getModelName(): ?string
    {
        if (!isset($this->modelName)) {
//            $source = $this->getSource();
//            $sourceClass = '_' . md5($source);
//            $sourceFullClass = '\\Zemit\\Models\\' . $sourceClass;
//            eval('namespace Zemit\Models; class ' . $sourceClass . ' extends \\' . Dynamic::class . ' {}');
//            $this->modelName = $sourceFullClass;
            $this->modelName = Dynamic::class;
        }
        
        return $this->modelName;
    }
    
    public function loadModel(?string $modelName = null): ModelInterface
    {
        $modelName ??= $this->getModelName() ?? '';
        $modelInstance = Dynamic::createInstance($this->getSource(), $this->getColumnMap());
//        $modelInstance = new $modelName();
//        $modelInstance = $this->modelsManager->load($modelName);
        if ($modelInstance instanceof Dynamic) {

            $modelInstance->setDynamicSource($this->getSource());
            $modelInstance->setDynamicMetaData($this->getMetaData());
            $modelInstance->setDynamicColumnMap($this->getColumnMap());
        }
        assert($modelInstance instanceof ModelInterface);
        return $modelInstance;
    }
    
    public function getColumnMap(): array
    {
        return $this->columnMap->toArray();
    }
    
    public function getSource(): string
    {
        return $this->source;
    }
    
    public function getMetaData(): array
    {
        /**
         * Initialize meta-data
         */
        $attributes = [];
        $primaryKeys = [];
        $nonPrimaryKeys = [];
        $numericTyped = [];
        $notNull = [];
        $fieldTypes = [];
        $fieldBindTypes = [];
        $automaticDefault = [];
        $identityField = false;
        $defaultValues = [];
        $emptyStringValues = [];
        
        $columns = $this->dbd->describeColumns($this->getSource());

        foreach ($columns as $column) {
            $fieldName = $column->getName();
            $attributes[] = $fieldName;
            
            /**
             * To mark fields as primary keys
             */
            if ($column->isPrimary()) {
                $primaryKeys[] = $fieldName;
            }
            else {
                $nonPrimaryKeys[] = $fieldName;
            }
            
            /**
             * To mark fields as numeric
             */
            if ($column->isNumeric()) {
                $numericTyped[$fieldName] = true;
            }
            
            /**
             * To mark fields as not null
             */
            if ($column->isNotNull()) {
                $notNull[] = $fieldName;
            }
            
            /**
             * To mark fields as identity $columns
             */
            if ($column->isAutoIncrement()) {
                $identityField = $fieldName;
            }
            
            /**
             * To get the internal types
             */
            $fieldTypes[$fieldName] = $column->getType();
            
            /**
             * To mark how the fields must be escaped
             */
            $fieldBindTypes[$fieldName] = $column->getBindType();
            
            /**
             * If $column has default value or $column is nullable and default value is null
             */
            $defaultValue = $column->getDefault();
            
            if ($defaultValue !== null || !$column->isNotNull()) {
                if (!$column->isAutoIncrement()) {
                    $defaultValues[$fieldName] = $defaultValue;
                }
            }
        }
        
        /**
         * Create an array using the MODELS_* constants as indexes
         */
        return [
            MetaData::MODELS_ATTRIBUTES => $attributes,
            MetaData::MODELS_PRIMARY_KEY => $primaryKeys,
            MetaData::MODELS_NON_PRIMARY_KEY => $nonPrimaryKeys,
            MetaData::MODELS_NOT_NULL => $notNull,
            MetaData::MODELS_DATA_TYPES => $fieldTypes,
            MetaData::MODELS_DATA_TYPES_NUMERIC => $numericTyped,
            MetaData::MODELS_IDENTITY_COLUMN => $identityField,
            MetaData::MODELS_DATA_TYPES_BIND => $fieldBindTypes,
            MetaData::MODELS_AUTOMATIC_DEFAULT_INSERT => $automaticDefault,
            MetaData::MODELS_AUTOMATIC_DEFAULT_UPDATE => $automaticDefault,
            MetaData::MODELS_DEFAULT_VALUES => $defaultValues,
            MetaData::MODELS_EMPTY_STRING_VALUES => $emptyStringValues,
        ];
    }
}

zemit-cms / core

Push — master ( 4d9b91...c71310 )

RecordController::getSource() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
