Zemit\Mvc\Model\Traits\Relationship::getEntityFromData()

Complexity

Conditions	17
Paths	82

Size

Total Lines	94
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	24
CRAP Score	48.6227

Importance

Changes

0

<?php
    public function getEntityFromData(array $data, array $configuration = []): ModelInterface|Row|null
    {
        assert($this instanceof ModelInterface);
        assert($this instanceof EntityInterface);
        
        $alias = $configuration['alias'] ?? null;
        $fields = $configuration['fields'] ?? [];
        $modelClass = $configuration['modelClass'] ?? null;
        $readFields = $configuration['readFields'] ?? null;
        $type = $configuration['type'] ?? null;
        $whiteList = $configuration['whiteList'] ?? null;
        $dataColumnMap = $configuration['dataColumnMap'] ?? null;
        
        if (!is_array($fields)) {
            throw new \Exception('Parameter `fields` must be an array');
        }
        
        if (!isset($modelClass)) {
            throw new \Exception('Parameter `modelClass` is mandatory');
        }
        
        // using primary key first
        $entity = $this->findFirstByPrimaryKeys($data, $modelClass);
        
        // not found, using the relationship fields instead
        if (!$entity) {
            if ($type === Relation::HAS_ONE || $type === Relation::BELONGS_TO) {
                
                // Set value to compare
                if (!empty($readFields)) {
                    
                    foreach ($readFields as $key => $field) {
                        
                        if (empty($data[$fields[$key]])) {
                            
                            // @todo maybe remove this if
                            $value = $this->readAttribute($field);
                            if (!empty($value)) {
                                
                                // @todo maybe remove this if
                                $data [$fields[$key]] = $value;
                            }
                        }
                    }
                }
            }
            
            // array_keys_exists (if $referencedFields keys exists)
            $dataKeys = array_intersect_key($data, array_flip($fields));
            
            // all keys were found
            if (count($dataKeys) === count($fields)) {
                
                if ($type === Relation::HAS_MANY) {
                    
                    $modelsMetaData = $this->getModelsMetaData();
                    $primaryKeys = $modelsMetaData->getPrimaryKeyAttributes($this);
                    
                    // Force primary keys for single to many
                    foreach ($primaryKeys as $primaryKey) {
                        
                        if (!in_array($primaryKey, $fields, true)) {
                            $dataKeys [$primaryKey] = $data[$primaryKey] ?? null;
                            $fields [] = $primaryKey;
                        }
                    }
                }
                
                $modelsManager = $this->getModelsManager();
                $relatedModel = $modelsManager->load($modelClass);
                
                $entity = $relatedModel::findFirst([
                    'conditions' => implode_sprintf($fields, ' and ', '[' . $relatedModel::class . '].[%s] = ?%s'),
                    'bind' => array_values($dataKeys),
                    'bindTypes' => array_fill(0, count($dataKeys), Column::BIND_PARAM_STR),
                ]);
            }
        }
        
        // not found, we will create a new related entity
        if (!$entity) {
            $entity = new $modelClass();
        }
        
        assert($entity instanceof ModelInterface);
        
        // assign new values
        // can be null to bypass, empty array for nothing or filled array
        $whiteListAlias = isset($whiteList, $alias)? $whiteList[$alias] ?? [] : null;
        $dataColumnMapAlias = isset($dataColumnMap, $alias)? $dataColumnMap[$alias] ?? [] : null;
        $entity->assign($data, $whiteListAlias, $dataColumnMapAlias);
//        $entity->setDirtyState(self::DIRTY_STATE_TRANSIENT);
        
        return $entity;
    }