SilverstripeColumnsPageExtension

Complexity

Total Complexity

53

Size/Duplication

Total Lines	263
Duplicated Lines	11.41 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
B	updateCMSFields()	0	38	2
B	UseDefaultSideBarContent()	0	21	5
C	MySidebarImage()	0	22	9
A	getMyDefaultSidebarContent()	10	10	3
A	getFullWidthContent()	10	10	3
A	getSummaryContent()	10	10	3
D	ChildrenShowInMenu()	0	29	10
C	MyMenuItems()	0	25	8
B	MyMenuItemsParentPage()	0	12	6
A	MyMenuItemsParentLink()	0	8	2
A	MyMenuItemsMenuLink()	0	7	2

<?php

/**
 *@author nicolaas [at] sunnysideup.co.nz
 *
 *
 **/

class SilverstripeColumnsPageExtension extends DataExtension

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    private static $db = [

The property $db is not used and could be removed.

        'Summary' => 'HTMLVarchar(255)',
        'DefaultSidebarContent' => 'HTMLText'
    ];

    private static $has_one = [

The property $has_one is not used and could be removed.

        'SummaryImage' => 'Image',
        'SidebarImage' => 'Image'
    ];

    private static $casting = [

The property $casting is not used and could be removed.

        'MyDefaultSidebarContent' => 'HTMLText',
        'FullWidthContent' => 'HTMLText',
        'SummaryContent' => 'HTMLText'
    ];

    private static $field_labels = [

The property $field_labels is not used and could be removed.

        'Summary' => 'Page Summary',
        'DefaultSidebarContent' => 'Sidebar content',
        'SummaryImage' => 'Image for Summaries',
        'SidebarImage' => 'Sidebar Image'
    ];

    private static $field_labels_right = [

The property $field_labels_right is not used and could be removed.

        'Summary' => 'A summary of the page for use on other pages.',
        'DefaultSidebarContent' => 'The sidebar show up to the right of the main content. It is usually for something like DID YOU KNOW? or CONTACT DETAILS.',
        'SummaryImage' => 'Image used to show a link to this page together with the summary of the page provided.',
        'SidebarImage' => 'Image to show up in the sidebar instead of content.'
    ];

    private static $page_types_that_use_the_default_sidebar = [];

The property $page_types_that_use_the_default_sidebar is not used and could be removed.

    private static $page_types_that_use_the_second_column = [];

The property $page_types_that_use_the_second_column is not used and could be removed.

    public function updateCMSFields(FieldList $fields)
    {
        $fieldLabels = $this->owner->FieldLabels();
        $fieldLabelsRight = Config::inst()->get('SilverstripeColumnsPageExtension', 'field_labels_right');
        $tabTitleSummary = _t('SilverstripeColumnsPageExtension.SUMMARY_TAB', 'Summary');
        $tabTitleContent = _t('SilverstripeColumnsPageExtension.ADDITIONAL_CONTENT_TAB', 'MoreContent');
        $fields->addFieldsToTab(
            'Root.' . $tabTitleSummary,
            [
                HTMLEditorField::create(
                    'Summary',
                    $fieldLabels['Summary']
                )->setRows(3)
                ->setRightTitle($fieldLabelsRight['Summary']),
                UploadField::create(
                    'SummaryImage',
                    $fieldLabels['SummaryImage']
                )->setRightTitle($fieldLabelsRight['SummaryImage'])
            ]
        );
        if($this->owner->UseDefaultSidebarContent()) {
            $fields->addFieldsToTab(
                'Root.' . $tabTitleContent,
                [
                    HTMLEditorField::create(
                        'DefaultSidebarContent',
                        $fieldLabels['DefaultSidebarContent']
                    )->setRightTitle($fieldLabelsRight['DefaultSidebarContent']),
                    UploadField::create(
                        'SidebarImage',
                        $fieldLabels['SidebarImage']
                    )->setRightTitle($fieldLabelsRight['SidebarImage'])
                ]
            );
        }

        return $fields;
    }



    /**
     * @return boolean
     */
    function UseDefaultSideBarContent()

It is generally recommended to explicitly declare the visibility for methods.

    {
        if($this->owner->hasMethod('UseDefaultSideBarContentOverloaded')) {
            $v = $this->owner->UseDefaultSideBarContentOverloaded();
            if($v !== null) {
                return $v;
            }
        }

        $testArray = Config::inst()->get('SilverstripeColumnsPageExtension', 'page_types_that_use_the_default_sidebar');
        if(count($testArray) === 0) {

            return true;
        } else {
            if(in_array($this->owner->ClassName, $testArray)) {

This if statement, and the following return statement can be replaced with return in_array($this->owner->ClassName, $testArray);.

                return true;
            }
            return false;
        }
        return false;

return false; does not seem to be reachable.

    }

    /**
     * @return Image | null
     */
    function MySidebarImage()

It is generally recommended to explicitly declare the visibility for methods.

    {
        if($this->owner->hasMethod('MySidebarImageOverloaded')) {
            $v = $this->owner->MySidebarImageOverloaded();
            if($v !== null) {
                return $v;
            }
        }

        if($this->owner->SidebarImageID) {
            $image = $this->owner->SidebarImage();
            if($image && $image->exists()) {
                return $image;
            }
        }
        $parent = $this->owner->Parent();
        if($parent && $parent->exists() && $parent instanceof SiteTree) {
            return $parent->MySidebarImage();
        }

        return null;
    }

    /**
     *
     * @return string (HTML)
     */
    function getMyDefaultSidebarContent()

It is generally recommended to explicitly declare the visibility for methods.

This method seems to be duplicated in your project.

    {
        if($this->owner->hasMethod('MyDefaultSidebarContentOverloaded')) {
            $v = $this->owner->MyDefaultSidebarContentOverloaded();
            if($v !== null) {
                return $v;
            }
        }
        return $this->owner->DefaultSidebarContent;
    }

    /**
     *
     * @return string (HTML)
     */
    function getFullWidthContent()

It is generally recommended to explicitly declare the visibility for methods.

This method seems to be duplicated in your project.

    {
        if($this->owner->hasMethod('FullWidthContentOverloaded')) {
            $v = $this->owner->FullWidthContentOverloaded();
            if($v !== null) {
                return $v;
            }
        }
        return $this->owner->renderWith('FullWidthContent');
    }

    /**
     *
     * @return string (HTML)
     */
    function getSummaryContent()

It is generally recommended to explicitly declare the visibility for methods.

This method seems to be duplicated in your project.

    {
        if($this->owner->hasMethod('SummaryContentOverloaded')) {
            $v = $this->owner->SummaryContentOverloaded();
            if($v !== null) {
                return $v;
            }
        }
        return $this->owner->renderWith('SummaryContent');
    }

    private static $_children_show_in_menu = [];

    function ChildrenShowInMenu($root = false)

The return type could not be reliably inferred; please add a @return annotation.

It is generally recommended to explicitly declare the visibility for methods.

    {
        if($this->owner->hasMethod('ChildrenShowInMenuOverloaded')) {
            $v = $this->owner->ChildrenShowInMenuOverloaded();
            if($v !== null) {
                return $v;
            }
        }
        $key = $this->owner->ID. '_'.($root ? 'true' : 'false');
        if(!isset(self::$_children_show_in_menu[$key])) {
            if($root) {
                $list = Page::get()->filter(['ShowInMenus' => 1, 'ParentID' => 0]);
                foreach($list as $page) {
                    if(! $page->canView()) {
                        $list->remove($page);
                    }
                }
            } else {
                $list = $this->owner->Children();
                foreach($list as $page) {
                    if(! $page->ShowInMenus) {
                        $list->remove($page);
                    }
                }
            }
            self::$_children_show_in_menu[$key] = $list;
        }
        return self::$_children_show_in_menu[$key];
    }


    function MyMenuItems()

The return type could not be reliably inferred; please add a @return annotation.

It is generally recommended to explicitly declare the visibility for methods.

    {
        if($this->owner->hasMethod('MyMenuItemsOverloaded')) {
            $v = $this->owner->MyMenuItemsOverloaded();
            if($v !== null) {
                return $v;
            }
        }
        //first stop: children ...
        $parent = $this->owner;
        $dataSet = false;
        while($parent && $dataSet === false) {
            $dataSet = $parent->ChildrenShowInMenu();
            if($dataSet->count() === 0) {
                $dataSet = false;
            }
            if($dataSet === false) {
                $parent = Page::get()->byID($parent->ParentID);
            }
        }
        if($dataSet === false) {
            $dataSet = $this->ChildrenShowInMenu(true);
        }
        return $dataSet;
    }

    function MyMenuItemsParentPage()

The return type could not be reliably inferred; please add a @return annotation.

It is generally recommended to explicitly declare the visibility for methods.

    {
        $children = $this->MyMenuItems();
        if($children) {
            if($child = $children->first()) {
                $page = Page::get()->byID($child->ParentID);
                if($page && $page->ShowInMenus && $page->canView()) {
                    return $page;
                }
            }
        }
    }

    function MyMenuItemsParentLink()

The return type could not be reliably inferred; please add a @return annotation.

It is generally recommended to explicitly declare the visibility for methods.

    {
        $parent = $this->MyMenuItemsParentPage();
        if($parent) {
            return $parent->MyMenuItemsMenuLink($parent->ParentID);
        }
        return $this->MyMenuItemsMenuLink(0);
    }

    function MyMenuItemsMenuLink($id = null)

It is generally recommended to explicitly declare the visibility for methods.

    {
        if($id === null) {
            $id = $this->owner->ID;
        }
        return $this->owner->Link().'myspecificpagemenuitems/'.$id.'/';
    }

}