CatalogProduct - Code Metrics - Inspection of "Merge pull request #9 from jsirish/bugfix/blocksCM..." - dynamic/silverstripe-product-catalog - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 488d66...816407 )

by Jason
created 2017-03-03 05:15 UTC
CatalogProduct A

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	335
Duplicated Lines	0 %
Coupling/Cohesion

Components	1
Dependencies	12
Test Coverage

Coverage
93.5%
Importance

Changes
Metric	Value
wmc	21
lcom	1
cbo	12
dl	0
loc	335
ccs	115
cts	123
cp	0.935
rs	10
c	0
b	0
f	0
14 Methods

Rating	Name	Size	Complexity
A	fieldLabels()	9	1
A	CategoryList()	15	4
A	getImage()	6	2
A	Image()	4	1
B	getCMSFields()	97	3
A	getPrimaryCategory()	9	2
A	getParentPage()	4	1
A	getViewAction()	4	1
A	getAncestors()	5	1
A	providePermissions()	8	1
A	canEdit()	4	1
A	canDelete()	4	1
A	canCreate()	4	1
A	canView()	4	1
<?php

class CatalogProduct extends DataObject implements PermissionProvider, Dynamic\ViewableDataObject\VDOInterfaces\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 $has_many = array(
        'Features' => 'CatalogProductFeature',
    );

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

    /**
     * @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 array
     */
    private static $summary_fields = array(
        'Image.CMSThumbnail' => 'Image',
        'Title' => 'Title',
        'Type' => 'Type',
        'CategoryList' => 'Categories',
    );

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

    /**
     * @var array
     */
    private static $extensions = [
        'VersionedDataObject',
    ];

    /**
     * @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 { }
            return $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 { }
        }
    }

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

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

            // Features
            $config = GridFieldConfig_RecordEditor::create();
            $config->addComponent(new GridFieldOrderableRows('SortOrder'));
            $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
            $config->removeComponentsByType('GridFieldDeleteAction');
            $config->addComponent(new GridFieldDeleteAction(false));
            $featuresField = GridField::create('Features', 'Features', $this->Features()->sort('SortOrder'), $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.Features', array(
                $featuresField,
            ));

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

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

    /**
     * @return string
     */
    public function getViewAction()
    {
        return 'view';
    }

    /**
     * needed for Blocks
     *
     * @return DataList
     */
    public function getAncestors()
    {
        debug::show(CatalogCategory::get());
        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)
    {
        return Permission::check('Product_EDIT', 'any', $member);
    }

    /**
     * @param null $member
     *
     * @return bool|int
     */
    public function canDelete($member = null)
    {
        return Permission::check('Product_DELETE', 'any', $member);
    }

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

    /**
     * @param null $member
     *
     * @return bool
     */
    public function canView($member = null)
    {
        return true;
    }
}
dynamic / silverstripe-product-catalog

Push — master ( 488d66...816407 )

CatalogProduct A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

14 Methods

Duplication Side-by-Side

Filter issues like
