DNADesign\Elemental\TopPage\SiteTreeExtension

Complexity

Total Complexity

28

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	onBeforeDuplicate()	0	3	1
A	getDuplicatedPageKey()	0	9	2
A	setTopPageForElementalArea()	0	25	5
A	addDuplicatedObject()	0	19	4
A	processDuplicationFromOriginal()	0	16	3
A	processDuplication()	0	13	2
A	onAfterWrite()	0	4	1
A	writeDuplication()	0	22	4
A	getDuplicationKey()	0	9	2
A	initDuplication()	0	14	3
A	onAfterDuplicate()	0	3	1

<?php

namespace DNADesign\Elemental\TopPage;

use DNADesign\Elemental\Extensions\ElementalPageExtension;
use DNADesign\Elemental\Models\ElementalArea;
use Page;

The type Page was not found. Maybe you did not declare it correctly or list all dependencies?

use SilverStripe\CMS\Model\SiteTreeExtension as BaseSiteTreeExtension;
use SilverStripe\ORM\DataObject;

/**
 * Class SiteTreeExtension
 *
 * This extension is mandatory for any pages that need to support top page functionality
 * it is safe to apply this extension directly to Page as the functionality detects presence of elemental area
 * alternatively, this extension can be applied to top level block page or all block pages individually
 * in case no common parent exists
 *
 * @property Page|$this $owner
 * @package DNADesign\Elemental\TopPage
 */
class SiteTreeExtension extends BaseSiteTreeExtension
{
    /**
     * List of pages currently undergoing duplication
     *
     * @var array
     */
    protected $duplicatedPages = [];

    /**
     * List of objects that need to udate their top page reference
     *
     * @var array
     */
    protected $duplicatedObjects = [];

    /**
     * Exension point in @see DataObject::onAfterWrite()
     */
    public function onAfterWrite(): void
    {
        $this->setTopPageForElementalArea();
        $this->processDuplicationFromOriginal();
    }

    /**
     * Exension point in @see DataObject::duplicate()
     *
     * @param Page $original
     */
    public function onBeforeDuplicate(Page $original): void
    {
        $this->initDuplication($original);
    }

    /**
     * Exension point in @see DataObject::duplicate()
     *
     * @param Page $original
     * @param bool $doWrite
     */
    public function onAfterDuplicate(Page $original, $doWrite): void
    {
        $this->processDuplication($original, (bool) $doWrite);
    }

    public function getDuplicationKey(): ?string
    {
        $owner = $this->owner;

        if (!$owner->isInDB()) {

The method isInDB() does not exist on DNADesign\Elemental\TopPage\SiteTreeExtension.

            return null;
        }

        return sprintf('%s-%d', $owner->ClassName, $owner->ID);

The property ClassName does not exist on DNADesign\Elemental\TopPage\SiteTreeExtension. Did you maybe forget to declare it?

The property ID does not exist on DNADesign\Elemental\TopPage\SiteTreeExtension. Did you maybe forget to declare it?

    }

    /**
     * This is a very roundabout way on how to update top page reference for data objects
     * the main reason why we're doing it like this is the fact that duplication process goes top-down
     * when it comes to model creation, but it goes bottom-up when it comes to writes
     * as a consequence the relations are not available when model is written
     *
     * Instead of updating the page reference during model write, we will simply push the object into a list
     * and update the reference later when page is available
     *
     * note that when going top-down on the relationship tree the models are not written yet so we can't use
     * page IDs as identifiers
     * instead we use IDs of the original objects that we are cloning from
     *
     * Additionally, the duplication process has to support nested pages which makes things more complicated
     * this is handled by using a stack like data structure to keep track on multiple pages
     * each with it's own duplication list
     *
     * @param DataObject $object
     */
    public function addDuplicatedObject(DataObject $object): void
    {
        if (!$object->hasExtension(DataExtension::class)) {
            return;
        }

        $key = $this->getDuplicatedPageKey();

        if ($key === null) {
            return;
        }

        if (array_key_exists($key, $this->duplicatedObjects)) {
            array_unshift($this->duplicatedObjects[$key], $object);

            return;
        }

        $this->duplicatedObjects[$key] = [$object];
    }

    /**
     * Find currently duplicated page
     * note: this doesn't change any stored data
     *
     * @return string|null
     */
    protected function getDuplicatedPageKey(): ?string
    {
        $pages = $this->duplicatedPages;

        if (count($pages) === 0) {
            return null;
        }

        return array_shift($pages);
    }

    /**
     * @param Page|SiteTreeExtension $original
     */
    protected function initDuplication(Page $original): void
    {
        $key = $original->getDuplicationKey();

        if ($key === null) {
            return;
        }

        if (in_array($key, $this->duplicatedPages)) {
            // this should never happen as it would indicate a duplication loop
            return;
        }

        array_unshift($this->duplicatedPages, $key);
    }

    protected function processDuplication(Page $original, bool $written): void
    {
        if ($written) {
            $this->writeDuplication($original);

            return;
        }


        // write may not be triggered as the page maybe have come up via relation
        // in this case we have to delay the processing until the page is written
        // store the origin reference on the object (in memory only) so we can pick it up later
        $this->owner->duplicationOriginal = $original;

The property duplicationOriginal does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * Relevant only for duplicated object that were not written at the time of duplication
     */
    protected function processDuplicationFromOriginal(): void
    {
        $owner = $this->owner;

        if (!isset($owner->duplicationOriginal)) {
            return;
        }

        $original = $owner->duplicationOriginal;

        if (!$original instanceof Page) {
            return;
        }

        unset($owner->duplicationOriginal);
        $this->writeDuplication($original);
    }

    /**
     * @param Page|SiteTreeExtension $original
     */
    protected function writeDuplication(Page $original): void
    {
        $key = $original->getDuplicationKey();
        $currentKey = $this->getDuplicatedPageKey();

        if ($key !== $currentKey) {
            // should never happen but it indicates that the nesting hierarchy was incorrect
            return;
        }

        if (array_key_exists($key, $this->duplicatedObjects)) {
            $objects = $this->duplicatedObjects[$key];

            /** @var DataObject|DataExtension $object */
            foreach ($objects as $object) {
                // attach current page ID to the object
                $object->setTopPage($this->owner);
            }
        }

        // mark page as processed
        array_shift($this->duplicatedPages);
    }

    /**
     * Elemental area is created before related page is written so we have to set top page explicitly
     * after page is written and the relations are available
     */
    protected function setTopPageForElementalArea(): void
    {
        /** @var Page|ElementalPageExtension $owner */
        $owner = $this->owner;

        if (!$owner->hasExtension(ElementalPageExtension::class)) {
            return;
        }

        if (!$owner->ElementalAreaID) {
            return;
        }

        /** @var ElementalArea|DataExtension $area */
        $area = $owner->ElementalArea();

        if (!$area->exists()) {

The method exists() does not exist on DNADesign\Elemental\TopPage\DataExtension.

            return;
        }

        if (!$area->hasExtension(DataExtension::class)) {

The method hasExtension() does not exist on DNADesign\Elemental\TopPage\DataExtension.

            return;
        }

        $area->setTopPage($owner);

The method setTopPage() does not exist on DNADesign\Elemental\Models\ElementalArea. Since you implemented __call, consider adding a @method annotation.

    }
}