CatalogProduct::getCMSFields() - Code Metrics - Inspection of "SilverStripe 4 upgrade" - dynamic/silverstripe-product-catalog - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#24)

by Jason
created 2017-07-12 21:02 UTC
CatalogProduct::getCMSFields() B

↳ Parent: CatalogProduct
Complexity

Conditions	3
Paths	4
Size

Total Lines	86
Code Lines	57
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	65
CRAP Score	3
Importance

Changes
Metric	Value
dl	0
loc	86
ccs	65
cts	65
cp	1
rs	8.6583
c	0
b	0
f	0
cc	3
eloc	57
nc	4
nop	0
crap	3
1 Method

Rating	Name	Duplication	Size	Complexity
A	CatalogProduct::ProductThumbnail()	0	9	3
How to fix Long Method

<?php

namespace Dynamic\ProductCatalog\ORM;

use Dynamic\ProductCatalog\Docs\CareCleaningDoc;
use Dynamic\ProductCatalog\Docs\OperationManual;
use Dynamic\ProductCatalog\Docs\SpecSheet;
use Dynamic\ProductCatalog\Docs\Warranty;
use Dynamic\ProductCatalog\Page\CatalogCategory;
use Dynamic\ViewableDataObject\VDOInterfaces\ViewableDataObjectInterface;
use SilverStripe\Assets\Image;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Forms\GridField\GridFieldConfig_RecordEditor;
use SilverStripe\Forms\GridField\GridFieldConfig_RelationEditor;
use SilverStripe\Forms\HTMLEditor\HTMLEditorField;
use SilverStripe\Forms\TextField;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\Permission;
use SilverStripe\Security\PermissionProvider;
use Symbiote\GridFieldExtensions\GridFieldAddExistingSearchButton;
use Symbiote\GridFieldExtensions\GridFieldOrderableRows;

class CatalogProduct extends DataObject implements PermissionProvider, ViewableDataObjectInterface
{
    /**
     * @var string
     */
    private static $singular_name = 'Product';

    /**
     * @var string
     */
    private static $plural_name = 'Products';

    /**
     * @var array
     */
    private static $db = array(
        'Title' => 'Varchar(255)',
        'Content' => 'HTMLText',
        'QuickFeatures' => 'HTMLText',
        'Dimensions' => 'Varchar(255)',
        'SKU' => 'Varchar(50)',
    );

    /**
     * @var array
     */
    private static $many_many = array(
        'Categories' => CatalogCategory::class,
        'CareCleaningDocs' => CareCleaningDoc::class,
        'OperationManuals' => OperationManual::class,
        'SpecSheets' => SpecSheet::class,
        'Warranties' => Warranty::class,
    );

    /**
     * @var array
     */
    private static $many_many_extraFields = array(
        'Categories' => array(
            'SortOrder' => 'Int',
        ),
        'CareCleaningDocs' => array(
            'Sort' => 'Int',
        ),
        'OperationManuals' => array(
            'Sort' => 'Int',
        ),
        'SpecSheets' => array(
            'Sort' => 'Int',
        ),
        'Warranties' => array(
            'Sort' => 'Int',
        ),
    );

    /**
     * @var string
     */
    private static $table_name = 'CatalogProdcut';


    /**
     * @var array
     */
    private static $summary_fields = array(
        'ProductThumbnail' => 'Image',
        'Title' => 'Title',
        'Type' => 'Type',
        'CategoryList' => 'Categories',
    );

    /**
     * @var array
     */
    private static $searchable_fields = array(
        'Title' => array(
            'title' => 'Product Name',
        ),
        'Categories.ID' => array(
            'title' => 'Category',
        ),
    );

    /**
     * @param bool $includerelations
     * @return array|string
     */
    public function fieldLabels($includerelations = true)
    {
        $labels = parent::fieldLabels($includerelations);

        $labels['Title'] = 'Product Name';
        $labels['Categories.ID'] = 'Category';

        return $labels;
    }

    /**
     * @return string
     */
    public function CategoryList()
    {
        $list = '';

        if ($this->Categories()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $i = 0;
            foreach ($this->Categories()->sort('SortOrder') as $category) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                $list .= $category->Title;
                if(++$i !== $this->Categories()->Count()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    $list .= ", ";
                }
            }
        }
        return $list;
    }

    /**
     * @return mixed
     */
    public function getImage()
    {
        if ($this->Slides()->exists()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $slide = $this->Slides()->first();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            if ($slide->ImageID > 0) {
                return $slide->Image();
            }
        }
        return false;
    }

    /**
     * @return mixed
     */
    public function Image()
    {
        return $this->getImage();
    }

    /**
     * @return mixed
     */
    public function ProductThumbnail()
    {
        if ($image = $this->getImage()) {
            if ($thumb = Image::get()->byID($image->ID)) {
                return $thumb->CMSThumbnail();
            }
        }
        return false;
    }

    /**
     * @return FieldList
     */
    public function getCMSFields()
    {
        $fields = parent::getCMSFields();

        $remove = [
            'Categories',
            'CareCleaningDocs',
            'OperationManuals',
            'SpecSheets',
            'Warranties',
            'DisabledBlocks',
        ];

        if (!$this->ID) {
            $remove[] = 'Blocks';
        }

        $fields->removeByName($remove);

        $fields->insertBefore(
            $fields->dataFieldByName('SKU'),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            'Content'
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        $fields->addFieldsToTab('Root.Info', array(
            TextField::create('Dimensions'),
            HTMLEditorField::create('QuickFeatures'),
        ));

        if ($this->ID) {
            // Categories
            $config = GridFieldConfig_RelationEditor::create();
            $config->addComponent(new GridFieldOrderableRows('SortOrder'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->addComponent(new GridFieldAddExistingSearchButton());
            $config->removeComponentsByType('GridFieldAddNewButton');
            $categories = $this->Categories()->sort('SortOrder');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $categoryField = GridField::create('Categories', 'Categories', $categories, $config);

            $fields->addFieldsToTab('Root.Categories.Categories', array(
                $categoryField,
            ));

            // Care and Cleaning
            $config = GridFieldConfig_RecordEditor::create();
            $config->addComponent(new GridFieldOrderableRows('Sort'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->addComponent(new GridFieldAddExistingSearchButton());
            $operation = GridField::create('CareCleaningDocs', 'Care and Cleaning', $this->CareCleaningDocs()->sort('Sort'), $config);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $fields->addFieldsToTab('Root.Files.Care', array(
                $operation,
            ));

            // Operation Manuals
            $config = GridFieldConfig_RecordEditor::create();
            $config->addComponent(new GridFieldOrderableRows('Sort'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->addComponent(new GridFieldAddExistingSearchButton());
            $operation = GridField::create('OperationManuals', 'Operation Manuals', $this->OperationManuals()->sort('Sort'), $config);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $fields->addFieldsToTab('Root.Files.Operation', array(
                $operation,
            ));

            // Spec Sheets
            $config = GridFieldConfig_RecordEditor::create();
            $config->addComponent(new GridFieldOrderableRows('Sort'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->addComponent(new GridFieldAddExistingSearchButton());
            $specsheets = GridField::create('SpecSheets', 'Spec Sheets', $this->SpecSheets()->sort('Sort'), $config);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $fields->addFieldsToTab('Root.Files.SpecSheets', array(
                $specsheets,
            ));

            // Warranties
            $config = GridFieldConfig_RecordEditor::create();
            $config->addComponent(new GridFieldOrderableRows('Sort'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->addComponent(new GridFieldAddExistingSearchButton());
            $warranties = GridField::create('Warranties', 'Warranties', $this->Warranties()->sort('Sort'), $config);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $fields->addFieldsToTab('Root.Files.Warranty', array(
                $warranties,
            ));
        }

        return $fields;
    }

    /**
     * @return CatalogCategory
     */
    public function getPrimaryCategory()
    {
        if ($this->Categories()->exists()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $category = $this->Categories()->sort('SortOrder')->first();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        } else {
            $category = CatalogCategory::get()->first();
        }
        return $category;
    }

    /**
     * set ParentPage for ViewableDataobject
     *
     * @return string
     */
    public function getParentPage()
    {
        return $this->getPrimaryCategory();
    }

    /**
     * set ViewAction for ViewableDataobject
     *
     * @return string
     */
    public function getViewAction()
    {
        return 'view';
    }

    /**
     * @return \SilverStripe\ORM\DataList
     */
    public function getAncestors()
    {
        return CatalogCategory::get();
    }

    /**
     * @return array
     */
    public function providePermissions()
    {
        return array(
            'Product_EDIT' => 'Edit a Product',
            'Product_DELETE' => 'Delete a Product',
            'Product_CREATE' => 'Create a Product',
        );
    }

    /**
     * @param null $member
     *
     * @return bool|int
     */
    public function canEdit($member = null, $context = [])

    {
        return Permission::check('Product_EDIT', 'any', $member);
    }

    /**
     * @param null $member
     *
     * @return bool|int
     */
    public function canDelete($member = null, $context = [])

    {
        return Permission::check('Product_DELETE', 'any', $member);
    }

    /**
     * @param null $member
     *
     * @return bool|int
     */
    public function canCreate($member = null, $context = [])
    {
        return Permission::check('Product_CREATE', 'any', $member);
    }

    /**
     * @param null $member
     *
     * @return bool
     */
    public function canView($member = null, $context = [])

    {
        return true;
    }

    public function allowedChildren()
    {
        return [];
    }
}
dynamic / silverstripe-product-catalog

Pull Request — master (#24)

CatalogProduct::getCMSFields() B

Complexity

Size

Duplication

Code Coverage

Importance

1 Method

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
