Backpack\CRUD\PanelTraits\Fields

Complexity

Total Complexity

55

Size/Duplication

Total Lines	373
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

74.62%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
B	addField()	0	44	9
A	addFields()	0	8	3
A	afterField()	0	6	1
A	beforeField()	0	6	1
A	moveField()	0	20	4
A	removeField()	0	8	1
A	removeFields()	0	8	3
A	removeAllFields()	0	9	3
A	modifyField()	0	19	4
A	setFieldLabel()	0	9	3
A	checkIfFieldIsFirstOfItsType()	0	11	2
A	getCurrentFields()	0	8	2
A	orderFields()	0	6	1
A	applyOrderToFields()	0	17	4
A	setFieldOrder()	0	4	1
A	setFieldsOrder()	0	4	1
A	transformFields()	0	17	3
B	decodeJsonCastedAttributes()	0	27	9

<?php

namespace Backpack\CRUD\PanelTraits;

trait Fields
{
    // ------------
    // FIELDS
    // ------------

    /**
     * Add a field to the create/update form or both.
     *
     * @param string|array $field The new field.
     * @param string       $form  The CRUD form. Can be 'create', 'update' or 'both'. Default is 'both'.
     *
     * @return self
     */
    public function addField($field, $form = 'both')
    {
        if (! empty($field['form'])) {
            $form = $field['form'];
        }
        // if the field_definition_array array is a string, it means the programmer was lazy and has only passed the name

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

        // set some default values, so the field will still work
        if (is_string($field)) {
            $completeFieldsArray['name'] = $field;

$completeFieldsArray was never initialized. Although not strictly required by PHP, it is generally a good practice to add $completeFieldsArray = array(); before regardless.

        } else {
            $completeFieldsArray = $field;
        }

        // if this is a relation type field and no corresponding model was specified, get it from the relation method
        // defined in the main model
        if (isset($completeFieldsArray['entity']) && ! isset($completeFieldsArray['model'])) {
            $completeFieldsArray['model'] = $this->getRelationModel($completeFieldsArray['entity']);

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

        }

        // if the label is missing, we should set it
        if (! isset($completeFieldsArray['label'])) {
            $completeFieldsArray['label'] = mb_ucfirst(str_replace('_', ' ', $completeFieldsArray['name']));
        }

        // if the field type is missing, we should set it
        if (! isset($completeFieldsArray['type'])) {
            $completeFieldsArray['type'] = $this->getFieldTypeFromDbColumnType($completeFieldsArray['name']);

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

        }

        // if a tab was mentioned, we should enable it
        if (isset($completeFieldsArray['tab'])) {
            if (! $this->tabsEnabled()) {

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

                $this->enableTabs();

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

            }
        }

        $this->transformFields($form, function ($fields) use ($completeFieldsArray) {
            $fields[$completeFieldsArray['name']] = $completeFieldsArray;

            return $fields;
        });

        return $this;
    }

    /**
     * Add multiple fields to the create/update form or both.
     *
     * @param array  $fields The new fields.
     * @param string $form   The CRUD form. Can be 'create', 'update' or 'both'. Default is 'both'.
     */
    public function addFields($fields, $form = 'both')
    {
        if (count($fields)) {
            foreach ($fields as $field) {
                $this->addField($field, $form);
            }
        }
    }

    /**
     * Move the most recently added field after the given target field.
     *
     * @param string $targetFieldName The target field name.
     * @param string $form            The CRUD form. Can be 'create', 'update' or 'both'. Default is 'both'.
     */
    public function afterField($targetFieldName, $form = 'both')
    {
        $this->transformFields($form, function ($fields) use ($targetFieldName) {
            return $this->moveField($fields, $targetFieldName, false);
        });
    }

    /**
     * Move the most recently added field before the given target field.
     *
     * @param string $targetFieldName The target field name.
     * @param string $form            The CRUD form. Can be 'create', 'update' or 'both'. Default is 'both'.
     */
    public function beforeField($targetFieldName, $form = 'both')
    {
        $this->transformFields($form, function ($fields) use ($targetFieldName) {
            return $this->moveField($fields, $targetFieldName, true);
        });
    }

    /**
     * Move the most recently added field before or after the given target field. Default is before.
     *
     * @param array  $fields          The form fields.
     * @param string $targetFieldName The target field name.
     * @param bool   $before          If true, the field will be moved before the target field, otherwise it will be moved after it.

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

     *
     * @return array
     */
    private function moveField($fields, $targetFieldName, $before = true)
    {
        if (array_key_exists($targetFieldName, $fields)) {
            $targetFieldPosition = $before ? array_search($targetFieldName, array_keys($fields))
                : array_search($targetFieldName, array_keys($fields)) + 1;

            if ($targetFieldPosition >= (count($fields) - 1)) {
                // target field name is same as element
                return $fields;
            }

            $element = array_pop($fields);
            $beginningArrayPart = array_slice($fields, 0, $targetFieldPosition, true);
            $endingArrayPart = array_slice($fields, $targetFieldPosition, null, true);

            $fields = array_merge($beginningArrayPart, [$element['name'] => $element], $endingArrayPart);
        }

        return $fields;
    }

    /**
     * Remove a certain field from the create/update/both forms by its name.
     *
     * @param string $name Field name (as defined with the addField() procedure)
     * @param string $form update/create/both
     */
    public function removeField($name, $form = 'both')
    {
        $this->transformFields($form, function ($fields) use ($name) {
            array_forget($fields, $name);

The function array_forget() has been deprecated with message: Arr::forget() should be used directly instead. Will be removed in Laravel 5.9.

            return $fields;
        });
    }

    /**
     * Remove many fields from the create/update/both forms by their name.
     *
     * @param array  $array_of_names A simple array of the names of the fields to be removed.
     * @param string $form           update/create/both
     */
    public function removeFields($array_of_names, $form = 'both')

The parameter $array_of_names is not named in camelCase.

    {
        if (! empty($array_of_names)) {
            foreach ($array_of_names as $name) {
                $this->removeField($name, $form);
            }
        }
    }

    /**
     * Remove all fields from the create/update/both forms.
     *
     * @param string $form update/create/both
     */
    public function removeAllFields($form = 'both')
    {
        $current_fields = $this->getCurrentFields();
        if (! empty($current_fields)) {
            foreach ($current_fields as $field) {
                $this->removeField($field['name'], $form);
            }
        }
    }

    /**
     * Update value of a given key for a current field.
     *
     * @param string $field         The field
     * @param array  $modifications An array of changes to be made.
     * @param string $form          update/create/both
     */
    public function modifyField($field, $modifications, $form = 'both')
    {
        foreach ($modifications as $key => $newValue) {
            switch (strtolower($form)) {
          case 'create':
              $this->create_fields[$field][$key] = $newValue;

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

              break;

          case 'update':
              $this->update_fields[$field][$key] = $newValue;

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

              break;

          default:
              $this->create_fields[$field][$key] = $newValue;
              $this->update_fields[$field][$key] = $newValue;
              break;
        }
        }
    }

    /**
     * Set label for a specific field.
     *
     * @param string $field
     * @param string $label
     */
    public function setFieldLabel($field, $label)
    {
        if (isset($this->create_fields[$field])) {
            $this->create_fields[$field]['label'] = $label;
        }
        if (isset($this->update_fields[$field])) {
            $this->update_fields[$field]['label'] = $label;
        }
    }

    /**
     * Check if field is the first of its type in the given fields array.
     * It's used in each field_type.blade.php to determine wether to push the css and js content or not (we only need to push the js and css for a field the first time it's loaded in the form, not any subsequent times).

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

     *
     * @param array $field        The current field being tested if it's the first of its type.
     *
     * @return bool true/false
     */
    public function checkIfFieldIsFirstOfItsType($field)
    {
        $fields_array = $this->getCurrentFields();
        $first_field = $this->getFirstOfItsTypeInArray($field['type'], $fields_array);

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

        if ($field['name'] == $first_field['name']) {

This if statement, and the following return statement can be replaced with return $field['name'] == $first_field['name'];.

            return true;
        }

        return false;
    }

    /**
     * Decode attributes that are casted as array/object/json in the model.
     * So that they are not json_encoded twice before they are stored in the db
     * (once by Backpack in front-end, once by Laravel Attribute Casting).
     */
    public function decodeJsonCastedAttributes($data, $form, $id = false)

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

    {
        // get the right fields according to the form type (create/update)
        $fields = $this->getFields($form, $id);

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

        $casted_attributes = $this->model->getCastedAttributes();

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

        foreach ($fields as $field) {

            // Test the field is castable
            if (isset($field['name']) && array_key_exists($field['name'], $casted_attributes)) {

                // Handle JSON field types
                $jsonCastables = ['array', 'object', 'json'];
                $fieldCasting = $casted_attributes[$field['name']];

                if (in_array($fieldCasting, $jsonCastables) && isset($data[$field['name']]) && ! empty($data[$field['name']]) && ! is_array($data[$field['name']])) {

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

                    try {
                        $data[$field['name']] = json_decode($data[$field['name']]);
                    } catch (\Exception $e) {
                        $data[$field['name']] = [];
                    }
                }
            }
        }

        return $data;
    }

    /**
     * @return array
     */
    public function getCurrentFields()
    {
        if ($this->entry) {
            return $this->getUpdateFields($this->entry->getKey());

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

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

        }

        return $this->getCreateFields();

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

    }

    /**
     * Order the CRUD fields in the given form. If certain fields are missing from the given order array, they will be
     * pushed to the new fields array in the original order.
     *
     * @param array  $order An array of field names in the desired order.
     * @param string $form  The CRUD form. Can be 'create', 'update' or 'both'.
     */
    public function orderFields($order, $form = 'both')
    {
        $this->transformFields($form, function ($fields) use ($order) {
            return $this->applyOrderToFields($fields, $order);
        });
    }

    /**
     * Apply the given order to the fields and return the new array.
     *
     * @param array $fields The fields array.
     * @param array $order  The desired field order array.
     *
     * @return array The ordered fields array.
     */
    private function applyOrderToFields($fields, $order)
    {
        $orderedFields = [];
        foreach ($order as $fieldName) {
            if (array_key_exists($fieldName, $fields)) {
                $orderedFields[$fieldName] = $fields[$fieldName];
            }
        }

        if (empty($orderedFields)) {
            return $fields;
        }

        $remaining = array_diff_key($fields, $orderedFields);

        return array_merge($orderedFields, $remaining);
    }

    /**
     * Set the order of the CRUD fields.
     *
     * @param array $fields Fields order.
     *
     * @deprecated This method was not and will not be implemented since its a duplicate of the orderFields method.
     * @see        Fields::orderFields() to order the CRUD fields.
     */
    public function setFieldOrder($fields)

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

    {
        // not implemented
    }

    /**
     * Set the order of the CRUD fields.
     *
     * @param array $fields Fields order.
     *
     * @deprecated This method was not and will not be implemented since its a duplicate of the orderFields method.
     * @see        Fields::orderFields() to order the CRUD fields.
     */
    public function setFieldsOrder($fields)
    {
        $this->setFieldOrder($fields);

The method Backpack\CRUD\PanelTraits\Fields::setFieldOrder() has been deprecated with message: This method was not and will not be implemented since its a duplicate of the orderFields method.

    }

    /**
     * Apply the given callback to the form fields.
     *
     * @param string   $form     The CRUD form. Can be 'create', 'update' or 'both'.
     * @param callable $callback The callback function to run for the given form fields.
     */
    private function transformFields($form, callable $callback)
    {
        switch (strtolower($form)) {
            case 'create':
                $this->create_fields = $callback($this->create_fields);
                break;

            case 'update':
                $this->update_fields = $callback($this->update_fields);
                break;

            default:
                $this->create_fields = $callback($this->create_fields);
                $this->update_fields = $callback($this->update_fields);
                break;
        }
    }
}