CollectionExtension::GroupedList() - Code Metrics - Inspection of "Fixed multiple sorts being broken (#16)" - dynamic/silverstripe-collection - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( ee0e1b...7ba095 )

by Matthew
created 2018-06-18 18:58 UTC
CollectionExtension::GroupedList() A

↳ Parent: CollectionExtension
Complexity

Conditions	1
Paths	1
Size

Total Lines	8
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	8
ccs	4
cts	4
cp	1
crap	1
rs	9.4285
c	0
b	0
f	0
<?php

namespace Dynamic\Collection;

use League\Flysystem\Exception;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Core\Extension;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\FormAction;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\GroupedList;
use SilverStripe\ORM\PaginatedList;

class CollectionExtension extends Extension
{
    /**
     * @var array
     */
    private static $allowed_actions = array(

        'CollectionSearchForm',
    );

    /**
     * @var DataList|ArrayList
     */
    private $collection;

    /**
     * @var
     */
    private $collection_object;

    /**
     * @return ArrayList|DataList
     */
    public function getCollection()
    {
        if (!$this->collection) {
            $this->setCollection($this->owner->request);
        }
        return $this->collection;
    }

    /**
     * @param HTTPRequest|null $request
     * @return $this
     */
    public function setCollection(HTTPRequest $request = null)
    {
        if ($request === null) {
            $request = $this->owner->request;
        }
        $searchCriteria = $request->requestVars();

        // allow $searchCriteria to be updated via extension
        $this->owner->extend('updateCollectionFilters', $searchCriteria);

        $object = $this->getCollectionObject();

        $context = ($object->hasMethod('getCustomSearchContext'))
            ? $object->getCustomSearchContext()
            : $object->getDefaultSearchContext();

        $sort = ($request->getVar('Sort'))
            ? (string) $request->getVar('Sort')
            : $object->stat('default_sort');
            : /** @scrutinizer ignore-deprecated */ $object->stat('default_sort');


        // check if the sort has an order (ASC or DESC)
        // prevents query errors when sorting on relations with an order ('Location.Title DESC')
        // no order
        if (strpos($sort, ' ') === false) {
            $collection = $context->getResults($searchCriteria)->sort($sort);
            // order is given
        } else {
            if (strpos($sort, ',') === false) {
                $sortParts = explode(' ', $sort);
                $collection = $context->getResults($searchCriteria)->sort($sortParts[0], $sortParts[1]);
            } else {
                // multiple orders are given
                $sortParts = [];
                $sortArgs = explode(',', $sort);
                foreach ($sortArgs as $arg) {
                    $arg = trim($arg);
                    if (strpos($arg, ' ') === false) {
                        $sortParts[$arg] = 'ASC';
                    } else {
                        $part = explode(' ', $arg);
                        $sortParts[$part[0]] = $part[1];
                    }
                }
                $collection = $context->getResults($searchCriteria)->sort($sortParts);
            }
        }

        // allow $collection to be updated via extension
        $this->owner->extend('updateCollectionItems', $collection, $searchCriteria);

        $this->collection = $collection;
        return $this;
    }

    /**
     * @return string|\SilverStripe\ORM\DataObject
     */
    public function getCollectionObject()
    {
        if (!$this->collection_object) {
            $this->setCollectionObject();
        }
        return $this->collection_object;
    }

    /**
     * @return $this
     */
    public function setCollectionObject()
    {
        try {
            /** @var \SilverStripe\ORM\DataObject $collection_object */
            $collection_object = $this->owner->config()->get('managed_object');
            $this->collection_object = $collection_object::create();
        } catch (Exception $e) {
            trigger_error($e, E_USER_NOTICE);
        }

        return $this;
    }

    /**
     * @return int
     */
    public function getCollectionSize()
    {
        if ($object = $this->owner->config()->page_size) {
            return (int) $object;
        }

        return 10;
    }

    /**
     * @param HTTPRequest|null $request
     * @return mixed
     */
    public function PaginatedList(HTTPRequest $request = null)
    {
        if ($request === null) {
            $request = $this->owner->request;
        }
        $start = ($request->getVar('start')) ? (int) $request->getVar('start') : 0;

        $records = PaginatedList::create($this->getCollection(), $this->owner->request);
        $records->setPageStart($start);
        $records->setPageLength($this->getCollectionSize());

        // allow $records to be updated via extension
        $this->owner->extend('updatePaginatedList', $records);

        return $records;
    }

    /**
     * @return GroupedList
     */
    public function GroupedList()
    {
        $records = GroupedList::create($this->getCollection());

        // allow $records to be updated via extension
        $this->owner->extend('updateGroupedList', $records);

        return $records;
    }

    /**
     * @return Form
     */
    public function CollectionSearchForm()
    {
        $object = $this->getCollectionObject();
        /** @var HTTPRequest $request */
        $request = ($this->owner->request) ? $this->owner->request : $this->owner->parentController->getRequest();
        $sort = ($request->getVar('Sort')) ? (string) $request->getVar('Sort') : $object->stat('default_sort');
        $sort = ($request->getVar('Sort')) ? (string) $request->getVar('Sort') : /** @scrutinizer ignore-deprecated */ $object->stat('default_sort');

        $context = ($object->hasMethod('getCustomSearchContext'))
            ? $object->getCustomSearchContext()
            : $object->getDefaultSearchContext();
        $fields = $context->getSearchFields();

        // add sort field if managed object specs getSortOptions()
        if ($object->hasMethod('getSortOptions')) {
            $sortOptions = $object->getSortOptions();
            if ($object->stat('default_sort')) {
            if (/** @scrutinizer ignore-deprecated */ $object->stat('default_sort')) {
                $defaultSort = array(str_replace('"', '', $object->stat('default_sort')) => 'Default');
                $defaultSort = array(str_replace('"', '', /** @scrutinizer ignore-deprecated */ $object->stat('default_sort')) => 'Default');
                $sortOptions = array_merge($defaultSort, $sortOptions);
            }
            $fields->add(
                DropdownField::create('Sort', 'Sort by:', $sortOptions, $sort)
            );
        }

        $actions = new FieldList(
            new FormAction($this->owner->Link(), 'Search')
        );

        if (class_exists(BootstrapForm::class)) {
filter:
    dependency_paths: ["lib/*"]
            $form = BootstrapForm::create(
                $this->owner,
                'CollectionSearchForm',
                $fields,
                $actions
            );
        } else {
            $form = Form::create(
                $this->owner,
                'CollectionSearchForm',
                $fields,
                $actions
            );
        }

        // allow $form to be extended via extension
        $this->owner->extend('updateCollectionForm', $form);

        $form
            ->setFormMethod('get')
            ->disableSecurityToken()
            ->loadDataFrom($request->getVars())
            ->setFormAction($this->owner->Link());

        return $form;
    }
}

dynamic / silverstripe-collection

Push — master ( ee0e1b...7ba095 )

CollectionExtension::GroupedList() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
