SilverstripeColumnsPageExtension

Complexity

Total Complexity

58

Size/Duplication

Total Lines	283
Duplicated Lines	21.2 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	updateCMSFields()	30	39	3
A	UseDefaultSideBarContent()	0	11	3
A	UseSummaries()	0	11	3
C	MySidebarImage()	0	22	9
A	getMyDefaultSidebarContent()	10	10	3
A	getFullWidthContent()	10	10	3
A	getSummaryContent()	10	10	3
A	setShowMenuItemsFor()	0	4	1
D	ChildrenShowInMenu()	0	30	10
D	MyMenuItems()	0	35	10
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.'
    ];

    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');
        if($this->owner->UseSummaries())

This code seems to be duplicated across your project.

        $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()) {

This code seems to be duplicated across your project.

            $fields->addFieldsToTab(
                'Root.' . $tabTitleContent,
                [
                    UploadField::create(
                        'SidebarImage',
                        $fieldLabels['SidebarImage']
                    )->setRightTitle($fieldLabelsRight['SidebarImage']),
                    HTMLEditorField::create(
                        'DefaultSidebarContent',
                        $fieldLabels['DefaultSidebarContent']
                    )->setRightTitle($fieldLabelsRight['DefaultSidebarContent'])
                ]
            );
        }

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

        return false;
    }


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

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

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

        return false;
    }

    /**
     * @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 = [];

    private $showMenuItemsFor = null;

    public function setShowMenuItemsFor($showMenuItemsFor) {
        $showMenuItemsFor = intval($showMenuItemsFor);
        $this->showMenuItemsFor = $showMenuItemsFor;
    }

    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.

    {
        $key = $this->owner->ID. '_'.($root ? 'true' : 'false');
        if(!isset(self::$_children_show_in_menu[$key])) {
            if($this->owner->hasMethod('ChildrenShowInMenuOverloaded')) {
                $v = $this->owner->ChildrenShowInMenuOverloaded();
                if($v instanceof ArrayList) {
                    self::$_children_show_in_menu[$key] = $v;
                }
            } else {
                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;
        if($this->showMenuItemsFor !== null) {
            if($this->showMenuItemsFor) {
                $page = Page::get()->byID($this->showMenuItemsFor);
                $dataSet = $page->ChildrenShowInMenu();
            } else {
                $dataSet = $this->ChildrenShowInMenu(true);
            }

        } else {
            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 Controller::curr()->Link().'myspecificpagemenuitems/'.$id.'/';
    }

}