ElementPageExtension

Complexity

Total Complexity

57

Size/Duplication

Total Lines	386
Duplicated Lines	12.18 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
C	updateCMSFields()	0	64	10
D	getAvailableTypes()	35	46	10
C	onBeforeWrite()	0	48	8
C	onAfterDelete()	0	35	7
B	supportsElemental()	0	20	7
A	onAfterDuplicate()	6	17	4
A	onAfterDuplicateToSubsite()	6	15	2
B	onAfterPublish()	0	22	5
A	onBeforeRollback()	0	21	4

<?php

/**
 * @package elemental
 */
class ElementPageExtension extends DataExtension

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

{

    /**
     * @config
     *
     * @var string $elements_title Title of the element in the CMS.
     */
    private static $elements_title = 'Content Blocks';

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

    /**
     * @config
     *
     * @var array $ignored_classes Classes to ignore adding elements too.
     */
    private static $ignored_classes = array();

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

    /**
     * @config
     *
     * @var boolean
     */
    private static $copy_element_content_to_contentfield = true;

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

    /**
     * @config
     *
     * @var boolean
     */
    private static $clear_contentfield = false;

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

    /**
     * @var array $db
     */
    private static $db = array();

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

    /**
     * @var array $has_one
     */
    private static $has_one = array(

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

        'ElementArea' => 'ElementalArea'
    );

    /**
     * Setup the CMS Fields
     *
     * @param FieldList
     */
    public function updateCMSFields(FieldList $fields)
    {
        if(!$this->supportsElemental()) {
            return;
        }

        // add an empty holder for content as some module explicitly use insert
        // after content.
        $fields->replaceField('Content', new LiteralField('Content', ''));

        $adder = new ElementalGridFieldAddNewMultiClass('buttons-before-left');

        $list = $this->getAvailableTypes();
        if($list) {

The expression $list of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $adder->setClasses($list);
        }

        $area = $this->owner->ElementArea();
        if ($this->owner->exists() && (!$area->exists() || !$area->isInDB())) {
            $area->write();

            $this->owner->ElementAreaID = $area->ID;
            $this->owner->write();
        }

        $gridField = GridField::create('ElementArea',
            Config::inst()->get('ElementPageExtension', 'elements_title'),
            $area->AllElements(),
            $config = GridFieldConfig_RelationEditor::create()
                ->removeComponentsByType('GridFieldAddNewButton')
                ->removeComponentsByType('GridFieldSortableHeader')
                ->removeComponentsByType('GridFieldDeleteAction')
                ->removeComponentsByType('GridFieldAddExistingAutocompleter')
                ->addComponent($autocomplete = new ElementalGridFieldAddExistingAutocompleter('buttons-before-right'))
                ->addComponent(new GridFieldTitleHeader())
                ->addComponent($adder)
                ->addComponent(new GridFieldSortableRows('Sort'))
        );

        if ($this->owner->canArchive()) {
            $config->addComponent(new ElementalGridFieldDeleteAction());
        }

        $searchList = BaseElement::get()->filter('AvailableGlobally', true);
        if($list) {

The expression $list of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $searchList = $searchList->filter('ClassName', array_keys($list));
        }
        $autocomplete->setSearchList($searchList);

        $autocomplete->setResultsFormat('($ID) $Title');
        $autocomplete->setSearchFields(array('ID', 'Title'));

        $config = $gridField->getConfig();
        $paginator = $config->getComponentByType('GridFieldPaginator');
        $paginator->setItemsPerPage(100);

        if ($this->owner instanceof SiteTree && $fields->findOrMakeTab('Root.Main')->fieldByName('Metadata')) {

The class SiteTree does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $fields->addFieldToTab('Root.Main', $gridField, 'Metadata');
        } else {
            $fields->addFieldToTab('Root.Main', $gridField);
        }

        return $fields;
    }


    /**
     * @return array
     */
    public function getAvailableTypes() {
        if (is_array($this->owner->config()->get('allowed_elements'))) {
            $list = $this->owner->config()->get('allowed_elements');

            if($this->owner->config()->get('sort_types_alphabetically') !== false) {

This code seems to be duplicated across your project.

                $sorted = array();

                foreach ($list as $class) {
                    $inst = singleton($class);

                    if ($inst->canCreate()) {
                        $sorted[$class] = singleton($class)->i18n_singular_name();
                    }
                }

                $list = $sorted;
                asort($list);
            }
        } else {

This code seems to be duplicated across your project.

            $classes = ClassInfo::subclassesFor('BaseElement');
            $list = array();
            unset($classes['BaseElement']);

            $disallowedElements = (array) $this->owner->config()->get('disallowed_elements');

            if (!in_array('ElementVirtualLinked', $disallowedElements)) {
                array_push($disallowedElements, 'ElementVirtualLinked');
            }

            foreach ($classes as $class) {
                $inst = singleton($class);

                if (!in_array($class, $disallowedElements) && $inst->canCreate()) {
                    $list[$class] = singleton($class)->i18n_singular_name();
                }
            }

            asort($list);
        }

        if (method_exists($this->owner, 'sortElementalOptions')) {
            $this->owner->sortElementalOptions($list);
        }

        return $list;
    }

    /**
     * Make sure there is always a WidgetArea sidebar for adding widgets
     *
     */
    public function onBeforeWrite()
    {
        if(!$this->supportsElemental()) {
            return;
        }

        // enable theme in case elements are being rendered with templates stored in theme folder
        $originalThemeEnabled = Config::inst()->get('SSViewer', 'theme_enabled');
        Config::inst()->update('SSViewer', 'theme_enabled', true);

        if ($this->owner->hasMethod('ElementArea') && Config::inst()->get(__CLASS__, 'copy_element_content_to_contentfield')) {
            $elements = $this->owner->ElementArea();

            if (!$elements->isInDB()) {
                $elements->write();
                $this->owner->ElementAreaID = $elements->ID;
            } else {
                // Copy widgets content to Content to enable search
                $searchableContent = array();

                Requirements::clear();

                foreach ($elements->Elements() as $element) {
                    if ($element->config()->exclude_from_content) {
                        continue;
                    }

                    $controller = $element->getController();
                    $controller->init();

                    array_push($searchableContent, $controller->WidgetHolder());
                }

                Requirements::restore();

                $this->owner->Content = trim(implode(' ', $searchableContent));
            }
        } else {
            if(Config::inst()->get(__CLASS__, 'clear_contentfield')) {
                $this->owner->Content = '';
            }
        }

        // set theme_enabled back to what it was
        Config::inst()->update('SSViewer', 'theme_enabled', $originalThemeEnabled);

        parent::onBeforeWrite();
    }

    /**
     * Ensure that if there are elements that belong to this page
     * and are virtualised (Virtual Element links to them), that we move the
     * original element to replace one of the virtual elements
     * But only if it's a delete not an unpublish
     */
    public function onAfterDelete() {
        if(Versioned::get_reading_mode() == 'Stage.Stage') {
            $area = $this->owner->ElementArea();
            foreach ($area->Widgets() as $element) {
                $firstVirtual = false;
                if ($element->getPublishedVirtualLinkedElements()->Count() > 0) {
                    // choose the first one
                    $firstVirtual = $element->getPublishedVirtualLinkedElements()->First();
                    $wasPublished = true;
                } else if ($element->getVirtualLinkedElements()->Count() > 0) {
                    // choose the first one
                    $firstVirtual = $element->getVirtualLinkedElements()->First();
                    $wasPublished = false;
                }
                if ($firstVirtual) {
                    $origParentID = $element->ParentID;
                    $origSort = $element->Sort;

                    // change element to first's values
                    $element->ParentID = $firstVirtual->ParentID;
                    $element->Sort = $firstVirtual->Sort;

                    $firstVirtual->ParentID = $origParentID;
                    $firstVirtual->Sort = $origSort;
                    // write
                    $element->write();
                    $firstVirtual->write();
                    if ($wasPublished) {

The variable $wasPublished does not seem to be defined for all execution paths leading up to this point.

                        $element->doPublish();
                        $firstVirtual->doPublish();
                    }
                }
            }
        }
    }

    /**
     * @return boolean
     */
    public function supportsElemental() {
        if ($this->owner->hasMethod('includeElemental')) {
            $res = $this->owner->includeElemental();
            if ($res !== null) {
                return $res;
            }
        }

        if (is_a($this->owner, 'RedirectorPage')) {
            return false;
        } else if ($ignored = Config::inst()->get('ElementPageExtension', 'ignored_classes')) {
            foreach ($ignored as $check) {
                if (is_a($this->owner, $check)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * If the page is duplicated, copy the widgets across too.
     *
     * Gets called twice from either direction, due to bad DataObject and SiteTree code, hence the weird if statement
     *
     * @return Page The duplicated page

Should the return type not be Page|null?

     */
    public function onAfterDuplicate($duplicatePage)
    {
        if ($this->owner->ID != 0 && $this->owner->ID < $duplicatePage->ID) {
            $originalWidgetArea = $this->owner->getComponent('ElementArea');
            $duplicateWidgetArea = $originalWidgetArea->duplicate(false);
            $duplicateWidgetArea->write();
            $duplicatePage->ElementAreaID = $duplicateWidgetArea->ID;
            $duplicatePage->write();

            foreach ($originalWidgetArea->Items() as $originalWidget) {

This code seems to be duplicated across your project.

                $duplicateWidget = $originalWidget->duplicate(true);

                // manually set the ParentID of each widget, so we don't get versioning issues
                DB::query(sprintf("UPDATE Widget SET ParentID = %d WHERE ID = %d", $duplicateWidgetArea->ID, $duplicateWidget->ID));
            }
        }
    }

    /**
     * If the page is duplicated across subsites, copy the widgets across too.
     *
     * @return Page The duplicated page

Should the return type not be Page|null?

     */
    public function onAfterDuplicateToSubsite($originalPage)
    {
        $originalWidgetArea = $originalPage->getComponent('ElementArea');
        $duplicateWidgetArea = $originalWidgetArea->duplicate(false);
        $duplicateWidgetArea->write();
        $this->owner->ElementAreaID = $duplicateWidgetArea->ID;
        $this->owner->write();

        foreach ($originalWidgetArea->Items() as $originalWidget) {

This code seems to be duplicated across your project.

            $duplicateWidget = $originalWidget->duplicate(true);

            // manually set the ParentID of each widget, so we don't get versioning issues
            DB::query(sprintf("UPDATE Widget SET ParentID = %d WHERE ID = %d", $duplicateWidgetArea->ID, $duplicateWidget->ID));
        }
    }

    /**
     * Publish
     */
    public function onAfterPublish()
    {
        if ($id = $this->owner->ElementAreaID) {
            $widgets = Versioned::get_by_stage('BaseElement', 'Stage', "ParentID = '$id'");
            $staged = array();

            foreach ($widgets as $widget) {
                $staged[] = $widget->ID;

                $widget->publish('Stage', 'Live');
            }

            // remove any elements that are on live but not in draft.
            $widgets = Versioned::get_by_stage('BaseElement', 'Live', "ParentID = '$id'");

            foreach ($widgets as $widget) {
                if (!in_array($widget->ID, $staged)) {
                    $widget->deleteFromStage('Live');
                }
            }
        }
    }

    /**
     * Roll back all changes if the parent page has a rollback event
     *
     * Only do rollback if it's the 'cancel draft changes' rollback, not a specific version
     * rollback.
     *
     * @param string $version
     * @return null
     */
    public function onBeforeRollback($version)
    {
        if ($version !== 'Live') {
            // we don't yet have a smart way of rolling back to a specific version
            return;
        }
        if ($id = $this->owner->ElementAreaID) {
            $widgets = Versioned::get_by_stage('BaseElement', 'Live', "ParentID = '$id'");
            $staged = array();

            foreach ($widgets as $widget) {
                $staged[] = $widget->ID;

                $widget->invokeWithExtensions('onBeforeRollback', $widget);

                $widget->publish('Live', 'Stage', false);

                $widget->invokeWithExtensions('onAfterRollback', $widget);
            }
        }
    }
}