DNADesign\Elemental\Models\ElementalArea

Complexity

Total Complexity

36

Size/Duplication

Total Lines	284
Duplicated Lines	0 %

Importance

Changes	7
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	forTemplate()	0	3	1
A	setElementsCached()	0	5	1
A	supportedPageTypes()	0	11	3
A	canEdit()	0	12	3
A	canView()	0	12	3
A	Breadcrumbs()	0	13	2
A	Elements()	0	7	2
A	ElementControllers()	0	20	4
C	getOwnerPage()	0	80	16
A	setOwnerPageCached()	0	7	1

<?php

namespace DNADesign\Elemental\Models;

use DNADesign\Elemental\Extensions\ElementalAreasExtension;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\ORM\FieldType\DBHTMLText;
use SilverStripe\ORM\HasManyList;
use SilverStripe\ORM\UnsavedRelationList;
use SilverStripe\Versioned\Versioned;
use SilverStripe\View\ViewableData;

/**
 * Class ElementalArea
 * @package DNADesign\Elemental\Models
 *
 * @property string $OwnerClassName
 *
 * @mixin Versioned
 */
class ElementalArea extends DataObject
{
    private static $db = [

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

        'OwnerClassName' => 'Varchar(255)',
    ];

    private static $has_many = [

The private property $has_many is not used, and could be removed.

        'Elements' => BaseElement::class,
    ];

    private static $extensions = [

The private property $extensions is not used, and could be removed.

        Versioned::class,
    ];

    private static $owns = [

The private property $owns is not used, and could be removed.

        'Elements',
    ];

    private static $cascade_deletes = [

The private property $cascade_deletes is not used, and could be removed.

        'Elements',
    ];

    private static $cascade_duplicates = [

The private property $cascade_duplicates is not used, and could be removed.

        'Elements',
    ];

    private static $summary_fields = [

The private property $summary_fields is not used, and could be removed.

        'Title' => 'Title',
    ];

    private static $table_name = 'ElementalArea';

The private property $table_name is not used, and could be removed.

    /**
     * Don't show this model in campaign admin as part of implicit change sets
     *
     * @config
     * @var bool
     */
    private static $hide_in_campaigns = true;

The private property $hide_in_campaigns is not used, and could be removed.

    /**
     * Cache various data to improve CMS load time
     *
     * @internal
     * @var array
     */
    protected $cacheData = [];

    /**
     * @return array
     */
    public function supportedPageTypes()
    {
        $elementalClasses = [];

        foreach (ClassInfo::getValidSubClasses(DataObject::class) as $class) {
            if (ViewableData::has_extension($class, ElementalAreasExtension::class)) {
                $elementalClasses[] = $class;
            }
        }

        return $elementalClasses;
    }

    /**
     * @return DBHTMLText
     */
    public function forTemplate()
    {
        return $this->renderWith(static::class);
    }

    /**
     * @param ArrayList $elements
     * @return $this
     */
    public function setElementsCached(ArrayList $elements)
    {
        $this->cacheData['elements'] = $elements;

        return $this;
    }

    /**
     * @param DataObject $page
     * @return $this
     */
    public function setOwnerPageCached(DataObject $page)
    {
        $cacheKey = 'owner_page_'. Versioned::get_reading_mode();

        $this->cacheData[$cacheKey] = $page;

        return $this;
    }

    /**
     * A cache-aware accessor for the elements
     * @return ArrayList|HasManyList|BaseElement[]
     */
    public function Elements()
    {
        if (isset($this->cacheData['elements'])) {
            return $this->cacheData['elements'];
        }

        return parent::Elements();

The method Elements() does not exist on SilverStripe\ORM\DataObject. Are you sure you never get this type here, but always one of the subclasses?

    }

    /**
     * Necessary to display results in CMS site search.
     *
     * @return DBField
     */
    public function Breadcrumbs()
    {
        $ownerClassName = $this->OwnerClassName;

        if ($owner = $ownerClassName::get()->filter('ElementalAreaID', $this->ID)->first()) {
            return DBField::create_field('HTMLText', sprintf(
                '<a href="%s">%s</a>',
                $owner->CMSEditLink(),
                $owner->Title
            ));
        }

        return null;
    }

    /**
     * Used in template instead of {@link Elements()} to wrap each element in
     * its' controller, making it easier to access and process form logic and
     * actions stored in {@link ElementController}.
     *
     * @return ArrayList
     * @throws \Exception
     */
    public function ElementControllers()
    {
        // Don't try and process unsaved lists
        if ($this->Elements() instanceof UnsavedRelationList) {
            return ArrayList::create();
        }

        $controllers = ArrayList::create();
        $items = $this->Elements()->filterByCallback(function (BaseElement $item) {
            return $item->canView();
        });

        if (!is_null($items)) {
            foreach ($items as $element) {
                $controller = $element->getController();
                $controllers->push($controller);
            }
        }

        return $controllers;
    }

    /**
     * @return null|DataObject
     * @throws \Psr\Container\NotFoundExceptionInterface
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function getOwnerPage()
    {
        // You can't find the owner page of a area that hasn't been save yet
        if (!$this->isInDB()) {
            return null;
        }

        // Allow for repeated calls to read from cache
        $cacheKey = 'owner_page_'. Versioned::get_reading_mode();

        if (isset($this->cacheData[$cacheKey])) {
            return $this->cacheData[$cacheKey];
        }

        if ($this->OwnerClassName && ClassInfo::exists($this->OwnerClassName)) {
            $class = $this->OwnerClassName;
            $instance = Injector::inst()->get($class);
            if (!ClassInfo::hasMethod($instance, 'getElementalRelations')) {
                return null;
            }
            $elementalAreaRelations = $instance->getElementalRelations();

            foreach ($elementalAreaRelations as $eaRelationship) {
                $areaID = $eaRelationship . 'ID';

                $table = DataObject::getSchema()->tableForField($class, $areaID);
                $baseTable = DataObject::getSchema()->baseDataTable($class);
                $page = DataObject::get_one($class, [
                    "\"{$table}\".\"{$areaID}\" = ?" => $this->ID,
                    "\"{$baseTable}\".\"ClassName\" = ?" => $class
                ]);

                if ($page) {
                    $this->setOwnerPageCached($page);

                    return $page;
                }
            }
        }

        foreach ($this->supportedPageTypes() as $class) {
            $instance = Injector::inst()->get($class);
            if (!ClassInfo::hasMethod($instance, 'getElementalRelations')) {
                return null;
            }

            $areaIDFilters = [];
            foreach ($instance->getElementalRelations() as $eaRelationship) {
                $areaIDFilters[$eaRelationship . 'ID'] = $this->ID;
            }

            try {
                $page = DataObject::get($class)->filterAny($areaIDFilters)->first();
            } catch (\Exception $ex) {
                // Usually this is catching cases where test stubs from other modules are trying to be loaded
                // and failing in unit tests.
                if (in_array(TestOnly::class, class_implements($class))) {
                    continue;
                }
                // Continue as normal...
                throw $ex;
            }

            if ($page) {
                if ($this->OwnerClassName !== $class) {
                    $this->OwnerClassName = $class;

                    // Avoid recursion: only write if it's already in the database
                    if ($this->isInDB()) {
                        $this->write();
                    }
                }

                $this->setOwnerPageCached($page);

                return $page;
            }
        }

        return null;
    }

    /**
     * @param null $member

Are you sure the doc-type for parameter $member is correct as it would always require null to be passed?

     * @return bool
     * @throws \Psr\Container\NotFoundExceptionInterface
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function canEdit($member = null)
    {
        if (parent::canEdit($member)) {
            return true;
        }

        $ownerPage = $this->getOwnerPage();
        if ($ownerPage !== null) {
            return $this->getOwnerPage()->canEdit($member);
        }

        return false;
    }

    /**
     * @param null $member

Are you sure the doc-type for parameter $member is correct as it would always require null to be passed?

     * @return bool
     * @throws \Psr\Container\NotFoundExceptionInterface
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function canView($member = null)
    {
        if (parent::canEdit($member)) {
            return true;
        }

        $ownerPage = $this->getOwnerPage();
        if ($ownerPage !== null) {
            return $this->getOwnerPage()->canView($member);
        }

        return false;
    }
}