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

Complexity

Total Complexity

22

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	update()	0	15	1
C	getUpdateFields()	0	49	13
B	getModelAttributeValue()	0	29	8

<?php

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

use Illuminate\Database\Eloquent\Relations\HasOneOrMany;

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

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

        $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?

        // omit the n-n relationships when updating the eloquent item
        $nn_relationships = array_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?

The function array_pluck() has been deprecated with message: Arr::pluck() should be used directly instead. Will be removed in Laravel 6.0.

        $data = array_except($data, $nn_relationships);

The function array_except() has been deprecated with message: Arr::except() should be used directly instead. Will be removed in Laravel 6.0.

        $updated = $item->update($data);

$updated is not used, you could remove the assignment.

        return $item;
    }

    /**
     * Get all fields needed for the EDIT ENTRY form.
     *
     * @param int $id The id of the entry that is being edited.

Should the type for parameter $id not be false|integer?

     *
     * @return array The fields with attributes, fake attributes and values.
     */
    public function getUpdateFields($id = false)
    {
        $fields = $this->fields();

The method fields() does not exist on Backpack\CRUD\app\Library\CrudPanel\Traits\Update. Did you maybe mean getUpdateFields()?

        $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 getCurrentEntry() 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.

        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']};
                    }

                    // handle fake fields
                } elseif (! empty($field['fake'])) {
                    // determine the stored-in attribute
                    $fakeStoredInAttribute = $field['store_in'] ?? 'extras';
                    // check if the fake stored-in attribute exists
                    if (! empty($entry->{$fakeStoredInAttribute})) {
                        $fakeStoredInArray = $entry->{$fakeStoredInAttribute};
                        // check if it's a string, decode it
                        // otherwise, it should be an array
                        if (is_string($fakeStoredInArray)) {
                            // decode it
                            $fakeStoredInArray = json_decode($fakeStoredInArray, true);
                        }

                        if (! empty($fakeStoredInArray) && is_array($fakeStoredInArray) && isset($fakeStoredInArray[$field['name']])) {
                            $field['value'] = $fakeStoredInArray[$field['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'])) {
            $relationArray = explode('.', $field['entity']);
            $relatedModel = array_reduce(array_splice($relationArray, 0, -1), function ($obj, $method) {
                return $obj->{$method} ? $obj->{$method} : $obj;
            }, $model);

            $relationMethod = end($relationArray);
            if ($relatedModel->{$relationMethod} && $relatedModel->{$relationMethod}() instanceof HasOneOrMany) {
                return $relatedModel->{$relationMethod}->{$field['name']};
            } else {
                return $relatedModel->{$field['name']};
            }
        }

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