Zemit\Modules\Cli\Tasks\ScaffoldTask::getRelationshipItems()

Complexity

Conditions	36
Paths	> 20000

Size

Total Lines	234
Code Lines	153

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	1332

Importance

Changes	3
Bugs	1	Features	0

<?php
    public function getRelationshipItems(string $table, array $columns, array $tables): array
    {
        if ($this->isNoRelationships()) {
            return [
                ' *',
                '',
                ''
            ];
        }
        
        $modelNamespace = 'Zemit\\Models\\';
        
        $useModels = [];
        $relationshipUseItems = [];
        $relationshipItems = [];
        $relationshipInjectableItems = [];
        
        $interfaceInjectableItems = [];
        $interfaceUseItems = [];
        $useInterfaces = [];
            
        // Has Many
        foreach ($tables as $otherTable) {
            
            // skip the current table
            if ($otherTable === $table) {
                continue;
            }
            
            $otherTableColumns = $this->describeColumns($otherTable);
            $relationName = $this->getTableName($otherTable);
            $relationClass = $relationName . '::class';
            $relationAlias = $relationName . 'List';
            $relationEager = strtolower($relationAlias);
            $relationInterface = $relationName . 'AbstractInterface';
            
            // foreach columns of that other table
            foreach ($otherTableColumns as $otherTableColumn) {
                $otherColumnName = $otherTableColumn->getName();
                $otherPropertyName = $this->getPropertyName($otherColumnName);
                
                // if the column name starts with the current table name
                if (str_starts_with($otherColumnName, $table . '_')) {
                    
                    // foreach column of the current table
                    foreach ($columns as $column) {
                        assert($column instanceof ColumnInterface);
                        $columnName = $column->getName();
                        
                        // if the field is matching
                        if ($otherColumnName === $table . '_' . $columnName) {
                            $propertyName = $this->getPropertyName($columnName);
                            
                            $useInterfaces[$relationInterface] = true;
                            $interfaceInjectableItems []= <<<PHP
 * @property {$relationInterface}[] \${$relationEager}
 * @property {$relationInterface}[] \${$relationAlias}
 * @method {$relationInterface}[] get{$relationAlias}(?array \$params = null)
PHP;
                            
                            $useModels[$relationName] = true;
                            $relationshipInjectableItems []= <<<PHP
 * @property {$relationName}[] \${$relationEager}
 * @property {$relationName}[] \${$relationAlias}
 * @method {$relationName}[] get{$relationAlias}(?array \$params = null)
PHP;
                            
                            $relationshipItems []= <<<PHP
        \$this->hasMany('{$propertyName}', {$relationClass}, '{$otherPropertyName}', ['alias' => '{$relationAlias}']);
PHP;
                            // check if we have many-to-many
                            foreach ($otherTableColumns as $manyTableColumn) {
                                assert($manyTableColumn instanceof ColumnInterface);
                                $manyColumnName = $manyTableColumn->getName();
                                $manyPropertyName = $this->getPropertyName($manyColumnName);
                                
                                // skip itself
                                if ($manyColumnName === $otherColumnName) {
                                    continue;
                                }
                                
                                foreach ($tables as $manyManyTable) {
                                    $manyManyTableName = $this->getTableName($manyManyTable);
                                    $manyManyTableInterface = $manyManyTableName . 'AbstractInterface';
                                    $manyManyTableClass = $manyManyTableName . '::class';
                                    $manyManyTableAlias = $manyManyTableName . 'List';
                                    
                                    // to prevent duplicates in this specific scenario when we find many-to-many relationships
                                    // that are not actually nodes, we will enforce the full many-to-many path alias
                                    if (!(str_starts_with($otherTable, $table . '_') || str_ends_with($otherTable, '_' . $table))) {
                                        $manyManyTableAlias = $relationName . $manyManyTableName . 'List';
                                    }
                                    
                                    $manyManyTableEager = strtolower($manyManyTableAlias);
                                    
                                    if (str_starts_with($manyColumnName, $manyManyTable . '_')) {
                                        
                                        $manyManyTableColumns = $this->describeColumns($manyManyTable);
                                        foreach ($manyManyTableColumns as $manyManyTableColumn) {
                                            $manyManyColumnName = $manyManyTableColumn->getName();
                                            if ($manyColumnName === $manyManyTable . '_' . $manyManyColumnName) {
                                                $manyManyPropertyName = $this->getPropertyName($manyManyColumnName);
                                                
                                                $useInterfaces[$manyManyTableInterface] = true;
                                                $interfaceInjectableItems []= <<<PHP
 * @property {$manyManyTableInterface}[] \${$manyManyTableEager}
 * @property {$manyManyTableInterface}[] \${$manyManyTableAlias}
 * @method {$manyManyTableInterface}[] get{$manyManyTableAlias}(?array \$params = null)
PHP;
                                                
                                                $useModels[$manyManyTableName] = true;
                                                $relationshipInjectableItems []= <<<PHP
 * @property {$manyManyTableName}[] \${$manyManyTableEager}
 * @property {$manyManyTableName}[] \${$manyManyTableAlias}
 * @method {$manyManyTableName}[] get{$manyManyTableAlias}(?array \$params = null)
PHP;
                                                
                                                $relationshipItems []= <<<PHP
        \$this->hasManyToMany(
            '{$propertyName}',
            {$relationClass},
            '{$otherPropertyName}',
            '{$manyPropertyName}',
            {$manyManyTableClass},
            '{$manyManyPropertyName}',
            ['alias' => '{$manyManyTableAlias}']
        );
PHP;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        
        // Belongs To
        foreach ($columns as $column) {
            assert($column instanceof ColumnInterface);
            $columnName = $column->getName();
            $propertyName = $this->getPropertyName($columnName);
            
            $relationName = $this->getTableName(substr($columnName, 0, strlen($columnName) - 3));
            $relationTableName = $relationName;
            
            if (str_ends_with($columnName, '_id')) {
                switch ($relationName) {
                    case 'Parent':
                    case 'Child':
                    case 'Left':
                    case 'Right':
                        $relationTableName = $this->getTableName($table);
                        if (str_contains($table, '_')) {
                            $length = strlen($relationTableName);
                            $midpoint = (int)floor($length / 2);
                            $firstPart = substr($relationTableName, 0, $midpoint);
                            $secondPart = substr($relationTableName, $midpoint + (($length % 2 === 0)? 0 : 1));
                            if ($firstPart === $secondPart) {
                                $relationTableName = $firstPart;
                            }
                        }
                        
                        break;
                }
            }
            
            if (str_ends_with($columnName, '_as') || str_ends_with($columnName, '_by')) {
                $relationName = $this->getTableName($columnName);
                $relationTableName = 'user';
            }
            
            if ($relationName) {
                
                $relationTableNameUncamelized = Helper::uncamelize($relationTableName);
                while (!empty($relationTableNameUncamelized) && !in_array($relationTableNameUncamelized, $tables, true)) {
                    $index = strpos($relationTableNameUncamelized, '_');
                    $relationTableNameUncamelized = $index? substr($relationTableNameUncamelized, $index + 1, strlen($relationTableNameUncamelized)) : null;
                }
                
                // can't find the table, skip
                if (empty($relationTableNameUncamelized)) {
                    continue;
                }
                
                $relationTableName = $this->getTableName($relationTableNameUncamelized);
                $relationTableInterface = $relationTableName . 'AbstractInterface';
                $relationClass = $relationTableName . '::class';
                $relationAlias = $relationName . 'Entity';
                $relationEager = strtolower($relationAlias);
                
                $useInterfaces[$relationTableInterface] = true;
                $interfaceInjectableItems []= <<<PHP
 * @property {$relationTableInterface} \${$relationEager}
 * @property {$relationTableInterface} \${$relationAlias}
 * @method {$relationTableInterface} get{$relationAlias}(?array \$params = null)
PHP;
                
                $useModels[$relationTableName] = true;
                $relationshipInjectableItems []= <<<PHP
 * @property {$relationTableName} \${$relationEager}
 * @property {$relationTableName} \${$relationAlias}
 * @method {$relationTableName} get{$relationAlias}(?array \$params = null)
PHP;
                
                $relationshipItems []= <<<PHP
        \$this->belongsTo('{$propertyName}', {$relationClass}, 'id', ['alias' => '{$relationAlias}']);
PHP;
            }
        }
        
        foreach (array_keys($useModels) as $useItem) {
            $relationshipUseItems []= 'use ' . $modelNamespace . $useItem . ';';
        }
        foreach (array_keys($useInterfaces) as $useInterface) {
            $interfaceUseItems []= 'use ' . $modelNamespace . $useInterface . ';';
        }
        
        // Avoid empty lines if not relationship were found
        if (empty($relationshipInjectableItems)) {
            $relationshipInjectableItems = [' * '];
        }
        if (empty($relationshipItems)) {
            $relationshipItems = ['// no default relationship found'];
        }
        
        return [
            'interfaceInjectableItems' => implode("\n" . ' *' . "\n", $interfaceInjectableItems),
            'injectableItems' => implode("\n" . ' *' . "\n", $relationshipInjectableItems),
            'useItems' => trim(implode("\n", $relationshipUseItems)),
            'interfaceUseItems' => trim(implode("\n", $interfaceUseItems)),
            'items' => trim(implode("\n" . "\n", $relationshipItems)),
        ];