Sunnysideup\SimpleTemplateCaching\Extensions\DataObjectExtension

Complexity

Total Complexity

15

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	doUpdateCache()	0	5	3
A	onAfterPublish()	0	3	1
A	onAfterWriteToStage()	0	3	1
A	canUpdateCache()	0	9	2
A	onAfterArchive()	0	3	1
A	onAfterVersionedPublish()	0	3	1
A	onBeforeRollback()	0	3	1
A	onAfterUnpublish()	0	3	1
A	onAfterDelete()	0	3	1
A	onAfterWrite()	0	11	3

<?php

namespace Sunnysideup\SimpleTemplateCaching\Extensions;

use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Extension;
use SilverStripe\ORM\DataObject;
use SilverStripe\Versioned\Versioned;
use Sunnysideup\SimpleTemplateCaching\Model\ObjectsUpdated;

/**
 * Class \Sunnysideup\SimpleTemplateCaching\Extensions\DataObjectExtension.
 *
 * @property DataObject|DataObjectExtension $owner
 */
class DataObjectExtension extends Extension
{
    public function onAfterWrite()
    {
        $owner = $this->getOwner();

        // NB.
        // if the dataobject has the versioned extension then the cache should be invalidated onAfterPublish
        // hasStages function is part of the Versioned class so safe to check here
        if (! $owner->hasExtension(Versioned::class)) {
            $this->doUpdateCache();
        } elseif (! $owner->hasStages()) {
            $this->doUpdateCache();
        }
    }

    public function onAfterDelete()
    {
        $this->doUpdateCache();
    }

    //* this function needs further consideration as it is called many times on the front end */
    // public function updateManyManyComponents()
    // {
    //     $owner = $this->owner;
    //     $className = $owner->ClassName;

    //     if(!$owner->hasExtension(Versioned::class)){
    //         $this->doUpdateCache($className);
    //     }
    //     //if the dataobject has the versioned extension then the cache should be invalidated onAfterPublish
    //     else if (!$owner->hasStages()){
    //         $this->doUpdateCache($className);
    //     }
    // }

    public function onBeforeRollback()
    {
        $this->doUpdateCache();
    }

    public function onAfterPublish()
    {
        $this->doUpdateCache();
    }

    public function onAfterArchive()
    {
        $this->doUpdateCache();
    }

    public function onAfterUnpublish()
    {
        $this->doUpdateCache();
    }

    public function onAfterVersionedPublish()
    {
        $this->doUpdateCache();
    }

    public function onAfterWriteToStage($toStage)

The parameter $toStage is not used and could be removed.

    {
        $this->doUpdateCache();
    }

    private function doUpdateCache()
    {
        $className = (string) $this->getOwner()->ClassName;
        if ($className && $this->canUpdateCache($className)) {
            SimpleTemplateCachingSiteConfigExtension::update_cache_key($className);
        }
    }

    private function canUpdateCache($className): bool
    {
        // we want to always avoid this to avoid a loop.
        if (ObjectsUpdated::class === $className) {
            return false;
        }
        $excludedClasses = (array) Config::inst()->get(DataObjectExtension::class, 'excluded_classes_for_caching');

        return ! in_array($className, $excludedClasses, true);
    }
}