Backpack\CRUD\PanelTraits\Create

Complexity

Total Complexity

41

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

85.86%

Importance

Changes	2
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	14	1
A	getCreateFields()	0	4	1
C	getRelationFields()	0	26	8
A	getRelationFieldsWithPivot()	0	8	2
A	createRelations()	0	5	1
C	syncPivot()	0	24	11
A	createDirectRelations()	0	5	1
D	createRelationsForItem()	0	45	9
C	getRelationDataFromFormData()	0	31	7

<?php

namespace Backpack\CRUD\PanelTraits;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

trait Create
{
    /*
    |--------------------------------------------------------------------------
    |                                   CREATE
    |--------------------------------------------------------------------------
    */

    /**
     * Insert a row in the database.
     *
     * @param  [Request] All input values to be inserted.
     *
     * @return [Eloquent Collection]

The doc-type Eloquent">[Eloquent could not be parsed: Unknown type name "[" at position 0. [(view supported doc-types)

     */
    public function create($data)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $data = $this->decodeJsonCastedAttributes($data, 'create');

It seems like decodeJsonCastedAttributes() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $data = $this->compactFakeFields($data, 'create');

It seems like compactFakeFields() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        // omit the n-n relationships when updating the eloquent item
        $nn_relationships = array_pluck($this->getRelationFieldsWithPivot('create'), 'name');
        $item = $this->model->create(array_except($data, $nn_relationships));

The property model does not exist. Did you maybe forget to declare it?

        // if there are any relationships available, also sync those
        $this->createRelations($item, $data);

        return $item;
    }

    /**
     * Get all fields needed for the ADD NEW ENTRY form.
     *
     * @return [array] The fields with attributes and fake attributes.

The doc-type [array] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getCreateFields()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->create_fields;

The property create_fields does not exist. Did you maybe forget to declare it?

    }

    /**
     * Get all fields with relation set (model key set on field).
     *
     * @param [string: create/update/both]
     *
     * @return [array] The fields with model key set.

The doc-type [array] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getRelationFields($form = 'create')
    {
        if ($form == 'create') {
            $fields = $this->create_fields;
        } else {
            $fields = $this->update_fields;

The property update_fields does not exist. Did you maybe forget to declare it?

        }

        $relationFields = [];

        foreach ($fields as $field) {
            if (isset($field['model'])) {
                array_push($relationFields, $field);
            }

            if (isset($field['subfields']) &&
                is_array($field['subfields']) &&
                count($field['subfields'])) {
                foreach ($field['subfields'] as $subfield) {
                    array_push($relationFields, $subfield);
                }
            }
        }

        return $relationFields;
    }

    /**
     * Get all fields with n-n relation set (pivot table is true).
     *
     * @param [string: create/update/both]
     *
     * @return [array] The fields with n-n relationships.

The doc-type [array] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getRelationFieldsWithPivot($form = 'create')
    {
        $all_relation_fields = $this->getRelationFields($form);

        return array_where($all_relation_fields, function ($value, $key) {

The parameter $key is not used and could be removed.

            return isset($value['pivot']) && $value['pivot'];
        });
    }

    /**
     * Create the relations for the current model.
     *
     * @param \Illuminate\Database\Eloquent\Model $item The current CRUD model.
     * @param array $data The form data.
     * @param string $form Optional form type. Can be either 'create', 'update' or 'both'. Default is 'create'.
     */
    public function createRelations($item, $data, $form = 'create')
    {
        $this->syncPivot($item, $data, $form);
        $this->createDirectRelations($item, $data, $form);
    }

    /**
     * Sync the declared many-to-many associations through the pivot field.
     *
     * @param \Illuminate\Database\Eloquent\Model $model The current CRUD model.
     * @param array $data The form data.
     * @param string $form Optional form type. Can be either 'create', 'update' or 'both'. Default is 'create'.
     */
    public function syncPivot($model, $data, $form = 'create')
    {
        $fields_with_relationships = $this->getRelationFields($form);

        foreach ($fields_with_relationships as $key => $field) {
            if (isset($field['pivot']) && $field['pivot']) {
                $values = isset($data[$field['name']]) ? $data[$field['name']] : [];
                $model->{$field['name']}()->sync($values);

                if (isset($field['pivotFields'])) {
                    foreach ($field['pivotFields'] as $pivotField) {
                        foreach ($data[$pivotField] as $pivot_id => $pivot_field) {
                            $model->{$field['name']}()->updateExistingPivot($pivot_id, [$pivotField => $pivot_field]);
                        }
                    }
                }
            }

            if (isset($field['morph']) && $field['morph'] && isset($data[$field['name']])) {
                $values = $data[$field['name']];
                $model->{$field['name']}()->sync($values);
            }
        }
    }

    /**
     * Create any existing direct (not n:n) relations for the current model from the form data.
     *
     * @param \Illuminate\Database\Eloquent\Model $item The current CRUD model.
     * @param array $data The form data.
     * @param string $form Optional form type. Can be either 'create', 'update' or 'both'. Default is 'create'.
     */
    private function createDirectRelations($item, $data, $form = 'create')
    {
        $relationData = $this->getRelationDataFromFormData($data, $form);
        $this->createRelationsForItem($item, $relationData);
    }

    /**
     * Create any existing one to one relations for the current model from the relation data.
     *
     * @param \Illuminate\Database\Eloquent\Model $item The current CRUD model.
     * @param array $formattedData The form data.
     */
    private function createRelationsForItem($item, $formattedData)
    {
        if (! isset($formattedData['relations'])) {
            return false;
        }

        foreach ($formattedData['relations'] as $relationMethod => $relationData) {
            $model = $relationData['model'];
            $relation = $item->{$relationMethod}();
            if ($relation instanceof BelongsTo) {
                $modelInstance = $model::find($relationData['values'])->first();
                if ($modelInstance != null) {
                    $relation->associate($modelInstance)->save();
                } else {
                    $relation->dissociate()->save();
                }
            } elseif ($relation instanceof HasOne) {
                if ($item->{$relationMethod} != null) {
                    $item->{$relationMethod}->update([$relation->getForeignKeyName() => $relationData['fallback_id'] ?? null]);

This line exceeds maximum limit of 120 characters; contains 127 characters

                }

                $modelInstance = $model::find($relationData['values'][$relationMethod]);
                $relation->save($modelInstance);
                $modelInstance = $item->{$relationMethod};
            } elseif ($relation instanceof HasMany) {
                $related_ids = collect($relationData['values'][$relationMethod]);
                $old_ids = $item->{$relationMethod}->pluck($relation->getRelated()->getKeyName());
                $removed = $old_ids->diff($related_ids);
                $added = $related_ids->diff($old_ids);

                $instance = new $model();
                $model::whereIn($instance->getKeyName(), $removed)->update([$relation->getForeignKeyName() => $relationData['fallback_id'] ?? null]);

This line exceeds maximum limit of 120 characters; contains 149 characters

                $model::whereIn($instance->getKeyName(), $added)->update([$relation->getForeignKeyName() => $item->getKey()]);

This line exceeds maximum limit of 120 characters; contains 126 characters

                $item = $item->load($relationMethod);
            } else {
                $relationModel = new $model();
                $modelInstance = $relationModel->create($relationData['values']);
                $relation->save($modelInstance);
            }

            if (isset($relationData['relations'])) {
                $this->createRelationsForItem($modelInstance, ['relations' => $relationData['relations']]);

The variable $modelInstance does not seem to be defined for all execution paths leading up to this point.

            }
        }
    }

    /**
     * Get a relation data array from the form data.
     * For each relation defined in the fields through the entity attribute, set the model, the parent model and the
     * attribute values. For relations defined with the "dot" notations, this will be used to calculate the depth in the
     * final array (@see \Illuminate\Support\Arr::set() for more).
     *
     * @param array $data The form data.
     * @param string $form Optional form type. Can be either 'create', 'update' or 'both'. Default is 'create'.
     *
     * @return array The formatted relation data.
     */
    private function getRelationDataFromFormData($data, $form = 'create')
    {
        $relationFields = $this->getRelationFields($form);

        $relationData = [];
        foreach ($relationFields as $relationField) {
            $attributeKey = $relationField['name'];
            if (array_key_exists($attributeKey, $data) && empty($relationField['pivot'])) {
                $key = implode('.relations.', explode('.', $relationField['entity']));
                $fieldData = array_get($relationData, 'relations.'.$key, []);

                if (! array_key_exists('model', $fieldData)) {
                    $fieldData['model'] = $relationField['model'];
                }

                if (! array_key_exists('parent', $fieldData)) {
                    $fieldData['parent'] = $this->getRelationModel($relationField['entity'], -1);

It seems like getRelationModel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                }

                if (array_key_exists('fallback_id', $relationField)) {
                    $fieldData['fallback_id'] = $relationField['fallback_id'];
                }

                $fieldData['values'][$attributeKey] = $data[$attributeKey];

                array_set($relationData, 'relations.'.$key, $fieldData);
            }
        }

        return $relationData;
    }
}