ModelAdminPlus::SearchForm() - Code Metrics - Inspection of "Make assotiation match for autocomplete fields a l..." - i-lateral/silverstripe-modeladminplus - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 1 ( 9746a9...f9fc50 )

by Morven
created 2018-11-01 11:53 UTC
ModelAdminPlus::SearchForm() C

↳ Parent: ModelAdminPlus
Complexity

Conditions	12
Paths	85
Size

Total Lines	85
Code Lines	57
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	12
eloc	57
nc	85
nop	0
dl	0
loc	85
rs	6.5115
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

namespace ilateral\SilverStripe\ModelAdminPlus;

use SilverStripe\Forms\Form;
use SilverStripe\ORM\ArrayLib;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Forms\TextField;
use SilverStripe\Admin\ModelAdmin;
use SilverStripe\View\Requirements;
use Colymba\BulkManager\BulkManager;
use SilverStripe\Control\Controller;
use SilverStripe\Core\Config\Config;
use SilverStripe\Forms\DatetimeField;
use SilverStripe\Core\Injector\Injector;
use Colymba\BulkManager\BulkAction\UnlinkHandler;
use SilverStripe\Forms\GridField\GridFieldPaginator;
use SilverStripe\Forms\GridField\GridFieldDataColumns;
use SilverStripe\Forms\GridField\GridFieldSortableHeader;
use SilverStripe\Forms\GridField\GridField_ColumnProvider;
use ilateral\SilverStripe\ModelAdminPlus\AutoCompleteField;
use Symbiote\GridFieldExtensions\GridFieldConfigurablePaginator;

/**
 * Custom version of model admin that adds extra features
 * (such as submitting search results via a POST, saving the query
 * as a session and automatic Bulk Editing support)
 *
 * @author ilateral
 * @package ModelAdminPlus
 */
abstract class ModelAdminPlus extends ModelAdmin
{
    const EXPORT_FIELDS = "export_fields";

    /**
     * Automatically convert date fields on gridfields
     * to use `Date.Nice`.
     *
     * @var boolean
     */
    private static $auto_convert_dates = true;


    /**
     * Automatically convert DB text fields to AutoComplete fields
     *
     * @var boolean
     */
    private static $convert_to_autocomplete = true;

    private static $allowed_actions = [

        "SearchForm"
    ];

    /**
     * List of currently registered ModelAdminSnippets, that is represented as
     * a list of classnames.
     *
     * These snippets are then setup when ModelAdminPlus is initilised and
     * rendered into the ModelAdminPlus content template.
     *
     * @var array
     */
    private static $registered_snippets = [];

    /**
     * Setup
     */
    public function getSnippets()
    {
        $snippets = ArrayList::create();

        // Setup any model admin plus snippets
        foreach ($this->config()->registered_snippets as $snippet) {
            $snippet = Injector::inst()->create($snippet);
            $snippet->setParent($this);
            $snippets->add($snippet);
        }

        $snippets = $snippets->sort("Order", "DESC");

        $this->extend("updateSnippets", $snippets);

        return $snippets;
    }

    public function init()
    {
        parent::init();

        // Require additional CSS
        Requirements::css("i-lateral/silverstripe-modeladminplus:client/dist/css/admin.css");

        $clear = $this->getRequest()->getVar("clear");

        if (isset($clear) && $clear == 1) {
            $this->clearSearchSession();
            // Remove clear flag
            return $this->redirect(
                $this->Link(
                    $this->sanitiseClassName($this->modelClass)
                )
            );
        }
    }

    /**
     * Get the default export fields for the current model.
     *
     * First this checks if there is an `export_fields` config variable set on
     * the model class, if not, it reverts to the default behaviour.
     *
     * @return array
     */
    public function getExportFields()
    {
        $export_fields = Config::inst()->get(
            $this->modelClass,
            self::EXPORT_FIELDS
        );

        if (isset($export_fields) && is_array($export_fields)) {
            $fields = $export_fields;
        } else {
            $fields = parent::getExportFields();
        }

        $this->extend("updateExportFields", $fields);

        return $fields;
    }

    /**
     * Get the name of the session to be useed by this model admin's search
     * form.
     *
     * @return string
     */
    public function getSearchSessionName()
    {
        $curr = $this->sanitiseClassName(self::class);
        $model = $this->sanitiseClassName($this->modelClass);
        return $curr . "." . $model;
    }

    /**
     * Empty the current search session
     *
     * @return Session
filter:
    dependency_paths: ["lib/*"]
     */
    public function clearSearchSession()
    {
        $session = $this->getRequest()->getSession();
        return $session->clear($this->getSearchSessionName());
    }

    /**
     * Get the current search session
     *
     * @return Session
     */
    public function getSearchSession()
    {
        $session = $this->getRequest()->getSession();
        return $session->get($this->getSearchSessionName());
    }

    /**
     * Set some data to a search session. This needs to be an array of
     * data (like the data submitted by a form).
     *
     * @param array $data An array of data to store in the session
     *
     * @return self
     */
    public function setSearchSession($data)
    {
        $session = $this->getRequest()->getSession();
        return $session->set($this->getSearchSessionName(), $data);
    }

    /**
     * Get the current search results, combined with any saved
     * search results and resturn (as an array).
     *
     * @return array
     */
    public function getSearchData()
    {
        $data = $this->getSearchSession();

        if (!$data || $data && !is_array($data)) {

            $data = [];
        }

        return $data;
    }

    /**
     * Overwrite the default search list to account for the new session based
     * search data.
     *
     * You can override how ModelAdmin returns DataObjects by either overloading this method,
     * or defining an extension to ModelAdmin that implements the `updateList` method
     * (and takes a {@link \SilverStripe\ORM\DataList} as the
     * first argument).
     *
     * @return \SilverStripe\ORM\DataList
     */
    public function getList()
    {
        $context = $this->getSearchContext();
        $context = /** @scrutinizer ignore-deprecated */ $this->getSearchContext();
        $params = $this->getSearchData();

        if (is_array($params)) {

            $params = ArrayLib::array_map_recursive('trim', $params);

            // Parse all DateFields to handle user input non ISO 8601 dates
            foreach ($context->getFields() as $field) {
                if ($field instanceof DatetimeField && !empty($params[$field->getName()])) {
                    $params[$field->getName()] = date(
                        'Y-m-d',
                        strtotime($params[$field->getName()])
                    );
                }
            }
        }

        $list = $context->getResults($params);

        $this->extend('updateList', $list);

        return $list;
    }

    /**
     * Gets a list of fields that have been searched
     *
     * @return SilverStripe\ORM\ArrayList

     */
    public function SearchSummary()
    {
        $context = $this->getSearchContext();
        $context = /** @scrutinizer ignore-deprecated */ $this->getSearchContext();
        $params = $this->getSearchData();
        $context->setSearchParams($params);

        return $context->getSummary();
    }

    
    /**
     * Add bulk editor to Edit Form
     *
     * @param int|null  $id
     * @param FieldList $fields
filter:
    dependency_paths: ["lib/*"]
     *
     * @return Form A Form object
     */
    public function getEditForm($id = null, $fields = null)
    {
        $form = parent::getEditForm($id, $fields);
        $grid_field = $form
            ->Fields()
            ->fieldByName($this->sanitiseClassName($this->modelClass));

        // Add bulk editing to gridfield
        $manager = new BulkManager();
        $manager->removeBulkAction(UnlinkHandler::class);

        $config = $grid_field->getConfig();

        $config
            ->removeComponentsByType(GridFieldPaginator::class)
            ->addComponent($manager)
            ->addComponent(new GridFieldConfigurablePaginator());

        if ($this->config()->auto_convert_dates) {
            GridFieldDateFinder::create($grid_field)->convertDateFields();
        }

        return $form;
    }

    /**
     * Overwrite default search form
     *
     * @return Form
     */
    public function SearchForm()
    {
        $form = parent::SearchForm();
        $form = /** @scrutinizer ignore-deprecated */ parent::SearchForm();
        $fields = $form->Fields();
        $data = $this->getSearchData();
        $class = $this->modelClass;
        $use_autocomplete = $this->config()->convert_to_autocomplete;

        $db = Config::inst()->get($class, "db");
        $has_one = Config::inst()->get($class, "has_one");
        $has_many = Config::inst()->get($class, "has_many");
        $many_many = Config::inst()->get($class, "many_many");
        $belongs_many_many = Config::inst()->get($class, "belongs_many_many");
        $associations = array_merge(
            $has_one,
            $has_many,
            $many_many,
            $belongs_many_many
        );

        // Change currently scaffolded query fields to use conventional
        // field names
        foreach ($fields as $field) {
            $field_class = $this->modelClass;
            $name = $field->getName();
            $title = $field->Title();
            $in_db = false;
            $db_field = str_replace(["q[", "]"], "", $name);

            // Find any text fields an replace with autocomplete fields
            if ($field instanceof TextField && $use_autocomplete) {
                // If this is a relation, switch class name
                if (strpos($name, "__")) {
                    $parts = explode("__", $db_field);
                    $field_class = isset($associations[$parts[0]]) ? $associations[$parts[0]] : null;
                    $db_field = $parts[1];
                    $in_db = ($field_class) ? true : false;
                }

                // If this is in the DB (not casted)
                if (in_array($db_field, array_keys($db))) {
                    $in_db = true;
                }

                if ($in_db) {
                    $fields->replaceField(
                        $name,
                        $field = AutoCompleteField::create(
                            $name,
                            $title,
                            $field->Value(),
                            $field_class,
                            $db_field
                        )->setForm($form)
                        ->setDisplayField($db_field)
                        ->setLabelField($db_field)
                        ->setStoredField($db_field)
                    );
                }
            }
            
            if ($name[0] == "q" && $name[1] == "[") {
                $name = substr($name, 2);
            }
            
            if (substr($name, -1) == "]") {
                $name = substr($name, 0, -1);
            }

            $field->setName($name);
        }
        
        $form
            ->removeExtraClass('cms-search-form')
            ->setFormMethod('post')
            ->setFormAction(
                $this->Link(
                    Controller::join_links(
                        $this->sanitiseClassName($this->modelClass),
                        $form->getName()
                    )
                )
            )->loadDataFrom($data);

        return $form;
    }

    /**
     * Set the session from the submitted form data (and redirect back)
     *
     * @param array $data Submitted form
     * @param Form  $form The current form
     *
     * @return HTTPResponse

     */
    public function search($data, $form)
    public function search($data, /** @scrutinizer ignore-unused */ $form)
    {
        foreach ($data as $key => $value) {
            // Ensure we clear any null values
            // so they don't mess up the list
            if (empty($data[$key])) {
                unset($data[$key]);
            }

            // Ensure we clear any null values
            // so they don't mess up the list
            if (strpos($key, "action_") !== false) {
                unset($data[$key]);
            }
        }

        $this->setSearchSession($data);

        return $this->redirectBack();
    }
}

i-lateral / silverstripe-modeladminplus

Push — 1 ( 9746a9...f9fc50 )

ModelAdminPlus::SearchForm() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
