Backpack\CRUD\app\Library\CrudPanel\Traits\Update

Complexity

Total Complexity

31

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Importance

Changes	5
Bugs	2	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	getUpdateFields()	0	29	7
A	update()	0	18	1
D	getModelAttributeValue()	0	83	23

<?php

namespace Backpack\CRUD\app\Library\CrudPanel\Traits;

use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphOne;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Support\Arr;

trait Update
{
    /*
    |--------------------------------------------------------------------------
    |                                   UPDATE
    |--------------------------------------------------------------------------
    */

    /**
     * Update a row in the database.
     *
     * @param int   $id   The entity's id
     * @param array $data All inputs to be updated.
     *
     * @return object
     */
    public function update($id, $data)
    {
        $data = $this->decodeJsonCastedAttributes($data);

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);

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

        $item = $this->model->findOrFail($id);

        // omit the n-n relationships when updating the eloquent item
        $nn_relationships = Arr::pluck($this->getRelationFieldsWithPivot(), 'name');

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

        // handle BelongsTo 1:1 relations
        $item = $this->associateOrDissociateBelongsToRelations($item, $data);

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

        $item->fill(Arr::except($data, $nn_relationships));
        $item->save();

        $this->createRelations($item, $data);

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

        return $item;
    }

    /**
     * Get all fields needed for the EDIT ENTRY form.
     *
     * @param int $id The id of the entry that is being edited.
     *
     * @return array The fields with attributes, fake attributes and values.
     */
    public function getUpdateFields($id = false)
    {
        $fields = $this->fields();

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

        $entry = ($id != false) ? $this->getEntry($id) : $this->getCurrentEntry();

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

It seems like you are loosely comparing $id of type false|integer against false; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

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

        foreach ($fields as &$field) {
            // set the value
            if (! isset($field['value'])) {
                if (isset($field['subfields'])) {
                    $field['value'] = [];
                    foreach ($field['subfields'] as $subfield) {
                        $field['value'][] = $entry->{$subfield['name']};
                    }
                } else {
                    $field['value'] = $this->getModelAttributeValue($entry, $field);
                }
            }
        }

        // always have a hidden input for the entry id
        if (! array_key_exists('id', $fields)) {
            $fields['id'] = [
                'name'  => $entry->getKeyName(),
                'value' => $entry->getKey(),
                'type'  => 'hidden',
            ];
        }

        return $fields;
    }

    /**
     * Get the value of the 'name' attribute from the declared relation model in the given field.
     *
     * @param \Illuminate\Database\Eloquent\Model $model The current CRUD model.
     * @param array                               $field The CRUD field array.
     *
     * @return mixed The value of the 'name' attribute from the relation model.
     */
    private function getModelAttributeValue($model, $field)
    {
        if (isset($field['entity'])) {
            $relational_entity = $this->parseRelationFieldNamesFromHtml([$field])[0]['name'];

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

            $relation_array = explode('.', $relational_entity);

            $relatedModel = $relatedModel = array_reduce(array_splice($relation_array, 0, -1), function ($obj, $method) {

The assignment to $relatedModel is dead and can be removed.

                return $obj->{$method} ? $obj->{$method} : $obj;
            }, $model);

            $relationMethod = Arr::last($relation_array);
            if (method_exists($relatedModel, $relationMethod)) {
                $relation = $relatedModel->{$relationMethod}();
                if ($relation instanceof HasOne || $relation instanceof MorphOne) {
                    return $relatedModel->{$relationMethod}->{Arr::last(explode('.', $relational_entity))};
                }

                if ($relation instanceof HasMany || $relation instanceof MorphMany) {
                    if (isset($field['pivotFields']) && is_array($field['pivotFields'])) {
                        $pivot_fields = Arr::where($field['pivotFields'], function ($item) use ($field) {
                            return $field['name'] != $item['name'];
                        });
                        $related_models = $relatedModel->{$relationMethod};
                        $return = [];

                        // for any given model, we grab the attributes that belong to our pivot table.
                        foreach ($related_models as $related_model) {
                            //for any given related model, we attach the pivot fields.
                            foreach ($pivot_fields as $pivot_field) {
                                $item[$pivot_field['name']] = $related_model->{$pivot_field['name']};
                                $item[$related_model->getKeyName()] = $related_model->getKey();
                            }
                            $return[] = $item;

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

                        }
                        // we return the json encoded result as expected by repeatable field.
                        return json_encode($return);
                    }
                }

                if ($relation instanceof BelongsToMany || $relation instanceof MorphToMany) {

                    // if pivot is true and there are `pivotFields` we need to get those pivot values to show on the edit page
                    if (isset($field['pivot']) && $field['pivot'] && isset($field['pivotFields']) && is_array($field['pivotFields'])) {

                        // we remove our current relation from the pivotFields.
                        $pivot_fields = Arr::where($field['pivotFields'], function ($item) use ($field) {
                            return $field['name'] != $item['name'];
                        });

                        $related_models = $relatedModel->{$relationMethod};
                        $return = [];

                        // for any given model, we grab the attributes that belong to our pivot table.
                        foreach ($related_models as $related_model) {
                            $item[$field['name']] = $related_model->getKey();
                            //for any given related model, we attach the pivot fields.
                            foreach ($pivot_fields as $pivot_field) {
                                $item[$pivot_field['name']] = $related_model->pivot->{$pivot_field['name']};
                            }
                            $return[] = $item;
                        }

                        // we return the json encoded result as expected by repeatable field.
                        return json_encode($return);
                    }
                }
            }

            return $relatedModel->{$relationMethod};
        }

        if (is_string($field['name'])) {
            return $model->{$field['name']};
        }

        if (is_array($field['name'])) {
            $result = [];
            foreach ($field['name'] as $key => $value) {
                $result = $model->{$value};
            }

            return $result;
        }
    }
}