Update::getModelAttributeValue() - Code Metrics - Inspection of "Relationship fixes" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — master (#3410)

unknown
created 2021-01-06 15:34 UTC
Update::getModelAttributeValue() D

↳ Parent: Update
Complexity

Conditions	24
Paths	24
Size

Total Lines	89
Code Lines	53
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
cc	24
eloc	53
c	2
b	1
f	0
nc	24
nop	2
dl	0
loc	89
rs	4.1666
How to fix Long Method Complexity

<?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);
        $data = $this->decodeJsonCastedAttributes($data);
        $data = $this->compactFakeFields($data);
        $data = $this->compactFakeFields($data);
        $item = $this->model->findOrFail($id);

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

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

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

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

        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();
        $fields = $this->fields();
        $entry = ($id != false) ? $this->getEntry($id) : $this->getCurrentEntry();
        $entry = ($id != false) ? $this->getEntry($id) : $this->/** @scrutinizer ignore-call */ getCurrentEntry();

        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']) && $field['entity'] !== false) {
            $relational_entity = $this->parseRelationFieldNamesFromHtml([$field])[0]['name'];
            $relational_entity = $this->/** @scrutinizer ignore-call */ parseRelationFieldNamesFromHtml([$field])[0]['name'];

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

            $relatedModel = array_reduce(array_splice($relation_array, 0, -1), function ($obj, $method) {
                return $obj->{$method} ? $obj->{$method} : $obj;
            }, $model);

            $relationMethod = Arr::last($relation_array);
            if (method_exists($relatedModel, $relationMethod)) {
                $relation = $relatedModel->{$relationMethod}();
                $relation_type = get_class($relation);

                switch ($relation_type) {
                    case HasOne::class:
                    case MorphOne::class:
                        return $relatedModel->{$relationMethod}->{Arr::last(explode('.', $relational_entity))};
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                    case HasMany::class:
                    case MorphMany::class:
                        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) {
                                $item = [];
                                //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;
                            }
                            // we return the json encoded result as expected by repeatable field.
                            return json_encode($return);
                        }
                    break;
                    case BelongsToMany::class:
                    case MorphToMany::class:
                        // 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 = [];
                                $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);
                        }
                    break;
                }
            }

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

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Pull Request — master (#3410)

Update::getModelAttributeValue() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
