Fields::moveField() - Code Metrics - Inspection of "[WIP] 3.2.20 patch update" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#966)

by Cristian

created 2017-09-27 11:48 UTC

Fields::moveField() A

↳ Parent: Fields

Complexity

Conditions	4
Paths	5

Size

Total Lines	18
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	10
c	0
b	0
f	0
nc	5
nop	3
dl	0
loc	18
rs	9.2

<?php

namespace Backpack\CRUD\PanelTraits;

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

    /**
     * Add a field to the create/update form or both.
     *
     * @param string   $form    The form to add the field to (create/update/both)
     */
    public function addField($field, $form = 'both')
    {
        // if the field_definition_array array is a string, it means the programmer was lazy and has only passed the name

        // set some default values, so the field will still work
        if (is_string($field)) {
            $complete_field_array['name'] = $field;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        } else {
            $complete_field_array = $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($complete_field_array['entity']) && ! isset($complete_field_array['model'])) {
            $complete_field_array['model'] = $this->getRelationModel($complete_field_array['entity']);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

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

        // if the field type is missing, we should set it
        if (! isset($complete_field_array['type'])) {
            $complete_field_array['type'] = $this->getFieldTypeFromDbColumnType($complete_field_array['name']);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        // if a tab was mentioned, we should enable it
        if (isset($complete_field_array['tab'])) {
            if (! $this->tabsEnabled()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                $this->enableTabs();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }
        }

        // store the field information into the correct variable on the CRUD object
        switch (strtolower($form)) {
            case 'create':
                $this->create_fields[$complete_field_array['name']] = $complete_field_array;
class MyClass { }

$x = new MyClass();
$x->foo = true;
                break;

            case 'update':
                $this->update_fields[$complete_field_array['name']] = $complete_field_array;
class MyClass { }

$x = new MyClass();
$x->foo = true;
                break;

            default:
                $this->create_fields[$complete_field_array['name']] = $complete_field_array;
                $this->update_fields[$complete_field_array['name']] = $complete_field_array;
                break;
        }

        return $this;
    }

    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->moveFieldInForm($targetFieldName, $form, 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->moveFieldInForm($targetFieldName, $form);
    }

    /**
     * Move the most recently added field from a given form before or after the given target field. Default is before.
     *
     * @param string $targetFieldName The target field name.
     * @param string $form The CRUD form. Can be 'create', 'update' or 'both'. Default is 'both'.
     * @param bool $before If true, the field will be moved before the target field, otherwise it will be moved after it.

     */
    protected function moveFieldInForm($targetFieldName, $form = 'both', $before = true)
    {
        switch ($form) {
            case 'create':
                $this->moveField($this->create_fields, $targetFieldName, $before);
                break;
            case 'update':
                $this->moveField($this->update_fields, $targetFieldName, $before);
                break;
            default:
                $this->moveField($this->create_fields, $targetFieldName, $before);
                $this->moveField($this->update_fields, $targetFieldName, $before);
                break;
        }
    }

    /**
     * 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.

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

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

    /**
     * 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')
    {
        switch (strtolower($form)) {
            case 'create':
                array_forget($this->create_fields, $name);
                break;

            case 'update':
                array_forget($this->update_fields, $name);
                break;

            default:
                array_forget($this->create_fields, $name);
                array_forget($this->update_fields, $name);
                break;
        }
    }

    /**
     * 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')

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

    /**
     * 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).

     *
     * @param array $field        The current field being tested if it's the first of its type.
     * @param array $fields_array All the fields in that particular form.
     *
     * @return bool true/false
     */
    public function checkIfFieldIsFirstOfItsType($field, $fields_array)

    {
        $first_field = $this->getFirstOfItsTypeInArray($field['type'], $fields_array);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

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

            return true;
        }

        return false;
    }

    /**
     * Order the fields in a certain way.
     *
     * @param [string] Column name.
     * @param [attributes and values array]
     */
    public function setFieldOrder($fields)

    {
        // TODO
    }

    // ALIAS of setFieldOrder($fields)
    public function setFieldsOrder($fields)
    {
        $this->setFieldOrder($fields);
    }

    /**
     * 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)

    {
        // get the right fields according to the form type (create/update)
        $fields = $this->getFields($form, $id);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        $casted_attributes = $this->model->getCastedAttributes();
class MyClass { }

$x = new MyClass();
$x->foo = true;

        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']])) {

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

                        $data[$field['name']] = [];
                    }
                }
            }
        }

        return $data;
    }

    public function getCurrentFields()

    {
        if ($this->entry) {
            return $this->getUpdateFields($this->entry->getKey());
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        return $this->getCreateFields();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    // ------------
    // TONE FUNCTIONS - UNDOCUMENTED, UNTESTED, SOME MAY BE USED
    // ------------
    // TODO: check them

    public function orderFields($order)
    {
        $this->setSort('fields', (array) $order);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }
}


1			<?php
2
3			namespace Backpack\CRUD\PanelTraits;
4
5			trait Fields
6			{
7			// ------------
8			// FIELDS
9			// ------------
10
11			/**
12			* Add a field to the create/update form or both.
13			*
14			* @param string $form The form to add the field to (create/update/both)
15			*/
16			public function addField($field, $form = 'both')
17			{
18			// if the field_definition_array array is a string, it means the programmer was lazy and has only passed the name
			0 ignored issues – show Coding Style introduced 2017-08-11 14:26 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 121 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
19			// set some default values, so the field will still work
20			if (is_string($field)) {
21			$complete_field_array['name'] = $field;
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-06-16 14:52 UTC by Report Bug Copy Issue Report `$complete_field_array` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$complete_field_array = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
22			} else {
23			$complete_field_array = $field;
24			}
25
26			// if this is a relation type field and no corresponding model was specified, get it from the relation method
27			// defined in the main model
28			if (isset($complete_field_array['entity']) && ! isset($complete_field_array['model'])) {
29			$complete_field_array['model'] = $this->getRelationModel($complete_field_array['entity']);
			0 ignored issues – show Bug introduced 2017-08-11 14:26 UTC by Report Bug Copy Issue Report It seems like `getRelationModel()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
30			}
31
32			// if the label is missing, we should set it
33			if (! isset($complete_field_array['label'])) {
34			$complete_field_array['label'] = ucfirst($complete_field_array['name']);
35			}
36
37			// if the field type is missing, we should set it

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Pull Request — master (#966)

Fields::moveField() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like