CacheFlagService::invalidateFlaggedCachesByFlags() - Code Metrics - mmikkel/CacheFlag-Craft3 - Measure and Improve Code Quality continuously with Scrutinizer

CacheFlagService::invalidateFlaggedCachesByFlags() B
last analyzed 2025-06-16 17:20 UTC

↳ Parent: CacheFlagService

Complexity

Conditions	6
Paths	11

Size

Total Lines	40
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	20
c	1
b	0
f	0
nc	11
nop	1
dl	0
loc	40
rs	8.9777

<?php

namespace mmikkel\cacheflag\services;

use Craft;
use craft\base\Component;
use craft\base\ElementInterface;
filter:
    dependency_paths: ["lib/*"]
use craft\db\Query;
use craft\db\Table;
use craft\elements\Asset;
use craft\elements\Category;
use craft\elements\Entry;
use craft\elements\GlobalSet;
use craft\elements\Tag;
use craft\helpers\Db;
use craft\helpers\StringHelper;

use yii\caching\TagDependency;

use mmikkel\cacheflag\events\FlaggedTemplateCachesEvent;
use mmikkel\cacheflag\records\Flags;


/**
 * @author    Mats Mikkel Rummelhoff
 * @package   CacheFlag
 * @since     1.0.0
 */
class CacheFlagService extends Component
{

    /**
     * @event Event The event that is triggered before flagged template caches are deleted.
     */
    const EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES = 'beforeInvalidateFlaggedCaches';

    /**
     * @event Event The event that is triggered after flagged template caches are invalidated.
     */
    const EVENT_AFTER_INVALIDATE_FLAGGED_CACHES = 'afterInvalidateFlaggedCaches';

    /**
     * @return array
     */
    public function getAllFlags(): array
    {
        return (new Query())
            ->select('*')
            ->from([Flags::tableName()])
            ->all();
    }

    /**
     * @param string|string[]|null $flags
     * @param string $sourceColumn
     * @param string $sourceValue
     * @throws \Throwable
     * @throws \yii\db\Exception
     */
    public function saveFlags(string|array|null $flags, string $sourceColumn, string $sourceValue): void
    {

        if (empty($flags)) {
            return;
        }

        if (is_array($flags)) {

            $flags = implode(',', $flags);
        }

        $uid = (new Query())
            ->select(['uid'])
            ->from(Flags::tableName())
            ->where([$sourceColumn => $sourceValue])
            ->scalar();

        $isNew = !$uid;
        if ($isNew) {
            $uid = StringHelper::UUID();
        }

        switch ($sourceColumn) {
            case 'sectionId':
                $sourceKey = 'section';
                $sourceValue = Db::uidById(Table::SECTIONS, (int)$sourceValue);
                break;
            case 'categoryGroupId':
                $sourceKey = 'categoryGroup';
                $sourceValue = Db::uidById(Table::CATEGORYGROUPS, (int)$sourceValue);
                break;
            case 'tagGroupId':
                $sourceKey = 'tagGroup';
                $sourceValue = Db::uidById(Table::TAGGROUPS, (int)$sourceValue);
                break;
            case 'userGroupId':
                $sourceKey = 'userGroup';
                $sourceValue = Db::uidById(Table::USERGROUPS, (int)$sourceValue);
                break;
            case 'volumeId':
                $sourceKey = 'volume';
                $sourceValue = Db::uidById(Table::VOLUMES, (int)$sourceValue);
                break;
            case 'globalSetId':
                $sourceKey = 'globalSet';
                $sourceValue = Db::uidById(Table::GLOBALSETS, (int)$sourceValue);
                break;
            case 'elementType':
                $sourceKey = 'elementType';
                break;
            default:
                return;
        }

        if (!$sourceValue) {
            return;
        }

        // Save it to the project config
        $path = "cacheFlags.{$uid}";
        Craft::$app->getProjectConfig()->set($path, [
            'source' => "$sourceKey:$sourceValue",
            'flags' => $flags,
        ]);
    }

    /**
     * @param string $sourceColumn
     * @param string $sourceValue
     * @return false|void
     */
    public function deleteFlagsBySource(string $sourceColumn, string $sourceValue)
    {

        $uid = (new Query())
            ->select(['uid'])
            ->from(Flags::tableName())
            ->where([$sourceColumn => $sourceValue])
            ->scalar();

        if (!$uid) {
            return false;
        }

        // Remove it from the project config
        $path = "cacheFlags.{$uid}";
        Craft::$app->getProjectConfig()->remove($path);
    }

    /**
     * Invalidate all flagged template caches
     */
    public function invalidateAllFlaggedCaches()
    {
        TagDependency::invalidate(Craft::$app->getCache(), 'cacheflag');
    }

    /**
     * @param ElementInterface $element
     * @return bool
     */
    public function invalidateFlaggedCachesByElement(ElementInterface $element): bool
    {
        // Collect all flags for this element
        $query = (new Query())
            ->select(['flags'])
            ->from(Flags::tableName());

        $elementType = \get_class($element);
        $dynamicFlags = ["element:$element->id", "element:$element->uid"];

        switch ($elementType) {
            case 'craft\elements\Asset':
                /** @var Asset $element */
                $query->orWhere([
                    'volumeId' => $element->volumeId,
                ]);
                $dynamicFlags[] = "asset:$element->id";
                $dynamicFlags[] = "asset:$element->uid";
                break;
            case 'craft\elements\Category':
                /** @var Category $element */
                $query->orWhere([
                    'categoryGroupId' => $element->groupId,
                ]);
                $dynamicFlags[] = "category:$element->id";
                $dynamicFlags[] = "category:$element->uid";
                break;
            case 'craft\elements\Entry':
                /** @var Entry $element */
                $query->orWhere([
                    'sectionId' => $element->sectionId,
                ]);
                $dynamicFlags[] = "entry:$element->id";
                $dynamicFlags[] = "entry:$element->uid";
                break;
            case 'craft\elements\GlobalSet':
                /** @var GlobalSet $element */
                $query->orWhere([
                    'globalSetId' => $element->id,
                ]);
                $dynamicFlags[] = "globalSet:$element->id";
                $dynamicFlags[] = "globalSet:$element->uid";
                break;
            case 'craft\elements\Tag':
                /** @var Tag $element */
                $query->orWhere([
                    'tagGroupId' => $element->groupId,
                ]);
                $dynamicFlags[] = "tag:$element->id";
                $dynamicFlags[] = "tag:$element->uid";
                break;
            case 'craft\elements\User':
                /** @var User $element */
                foreach ($element->getGroups() as $userGroup) {
                    $query->orWhere([
                        'userGroupId' => $userGroup->id,
                    ]);
                }
                $dynamicFlags[] = "user:$element->id";
                $dynamicFlags[] = "user:$element->uid";
                break;
        }

        $query->orWhere([
            'elementType' => $elementType,
        ]);

        $flags = \array_unique(\array_merge($query->column(), $dynamicFlags));

        return $this->invalidateFlaggedCachesByFlags($flags);
    }

    /**
     * @param string|string[]|null $flags
     * @return bool
     */
    public function invalidateFlaggedCachesByFlags(string|array|null $flags): bool
    {

        if (empty($flags)) {
            return false;
        }

        if (is_array($flags)) {

            $flags = $this->implodeFlagsArray($flags);
        } else {
            $flags = preg_replace('/\s+/', '', $flags);
        }

        $flags = array_values(\array_unique(\explode(',', $flags)));

        if (empty($flags)) {
            return false;
        }

        // Fire a `beforeInvalidateFlaggedCaches` event
        if ($this->hasEventHandlers(self::EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES)) {
            $this->trigger(self::EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES, new FlaggedTemplateCachesEvent([
                'flags' => $flags,
            ]));
        }

        $flagTags = array_map(function (string $flag) {
            return "cacheflag::$flag";
        }, $flags);

        TagDependency::invalidate(Craft::$app->getCache(), $flagTags);

        // Fire a 'afterInvalidateFlaggedCaches' event
        if ($this->hasEventHandlers(self::EVENT_AFTER_INVALIDATE_FLAGGED_CACHES)) {
            $this->trigger(self::EVENT_AFTER_INVALIDATE_FLAGGED_CACHES, new FlaggedTemplateCachesEvent([
                'flags' => $flags,
            ]));
        }

        return true;
    }

    /**
     * @param array $flagsArray
     * @return string
     */
    protected function implodeFlagsArray(array $flagsArray): string
    {

        $flags = '';

        foreach ($flagsArray as $item) {
            if (is_array($item)) {
                $flags .= "{$this->implodeFlagsArray($item)},";
            } else {
                $flags .= preg_replace('/\s+/', '', $item) . ',';
            }
        }

        return substr($flags, 0, 0 - strlen(','));
    }
}


1			<?php
2
3			namespace mmikkel\cacheflag\services;
4
5			use Craft;
6			use craft\base\Component;
7			use craft\base\ElementInterface;
			0 ignored issues – show Bug introduced 2024-03-28 13:16 UTC by Report Bug Copy Issue Report The type `craft\base\ElementInterface` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
8			use craft\db\Query;
9			use craft\db\Table;
10			use craft\elements\Asset;
11			use craft\elements\Category;
12			use craft\elements\Entry;
13			use craft\elements\GlobalSet;
14			use craft\elements\Tag;
15			use craft\helpers\Db;
16			use craft\helpers\StringHelper;
17
18			use yii\caching\TagDependency;
19
20			use mmikkel\cacheflag\events\FlaggedTemplateCachesEvent;
21			use mmikkel\cacheflag\records\Flags;
22
23
24			/**
25			* @author Mats Mikkel Rummelhoff
26			* @package CacheFlag
27			* @since 1.0.0
28			*/
29			class CacheFlagService extends Component
30			{
31
32			/**
33			* @event Event The event that is triggered before flagged template caches are deleted.
34			*/
35			const EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES = 'beforeInvalidateFlaggedCaches';
36
37			/**
38			* @event Event The event that is triggered after flagged template caches are invalidated.
39			*/
40			const EVENT_AFTER_INVALIDATE_FLAGGED_CACHES = 'afterInvalidateFlaggedCaches';
41
42			/**
43			* @return array
44			*/
45			public function getAllFlags(): array
46			{
47			return (new Query())
48			->select('*')
49			->from([Flags::tableName()])
50			->all();
51			}
52
53			/**
54			* @param string\|string[]\|null $flags
55			* @param string $sourceColumn
56			* @param string $sourceValue
57			* @throws \Throwable
58			* @throws \yii\db\Exception
59			*/
60			public function saveFlags(string\|array\|null $flags, string $sourceColumn, string $sourceValue): void
61			{
62
63			if (empty($flags)) {
64			return;
65			}
66
67			if (is_array($flags)) {
			0 ignored issues – show introduced 2024-03-28 13:48 UTC by Report Bug Copy Issue Report The condition `is_array($flags)` is always `true`. Loading history...
68			$flags = implode(',', $flags);
69			}
70
71			$uid = (new Query())
72			->select(['uid'])
73			->from(Flags::tableName())
74			->where([$sourceColumn => $sourceValue])
75			->scalar();
76
77			$isNew = !$uid;
78			if ($isNew) {
79			$uid = StringHelper::UUID();
80			}
81
82			switch ($sourceColumn) {
83			case 'sectionId':
84			$sourceKey = 'section';
85			$sourceValue = Db::uidById(Table::SECTIONS, (int)$sourceValue);
86			break;
87			case 'categoryGroupId':
88			$sourceKey = 'categoryGroup';
89			$sourceValue = Db::uidById(Table::CATEGORYGROUPS, (int)$sourceValue);
90			break;
91			case 'tagGroupId':
92			$sourceKey = 'tagGroup';
93			$sourceValue = Db::uidById(Table::TAGGROUPS, (int)$sourceValue);
94			break;
95			case 'userGroupId':
96			$sourceKey = 'userGroup';
97			$sourceValue = Db::uidById(Table::USERGROUPS, (int)$sourceValue);
98			break;
99			case 'volumeId':
100			$sourceKey = 'volume';
101			$sourceValue = Db::uidById(Table::VOLUMES, (int)$sourceValue);
102			break;
103			case 'globalSetId':
104			$sourceKey = 'globalSet';
105			$sourceValue = Db::uidById(Table::GLOBALSETS, (int)$sourceValue);
106			break;
107			case 'elementType':
108			$sourceKey = 'elementType';
109			break;
110			default:
111			return;
112			}
113
114			if (!$sourceValue) {
115			return;
116			}
117
118			// Save it to the project config
119			$path = "cacheFlags.{$uid}";
120			Craft::$app->getProjectConfig()->set($path, [
121			'source' => "$sourceKey:$sourceValue",
122			'flags' => $flags,
123			]);
124			}
125
126			/**
127			* @param string $sourceColumn
128			* @param string $sourceValue
129			* @return false\|void
130			*/
131			public function deleteFlagsBySource(string $sourceColumn, string $sourceValue)
132			{
133
134			$uid = (new Query())
135			->select(['uid'])
136			->from(Flags::tableName())
137			->where([$sourceColumn => $sourceValue])
138			->scalar();
139
140			if (!$uid) {
141			return false;
142			}
143
144			// Remove it from the project config
145			$path = "cacheFlags.{$uid}";
146			Craft::$app->getProjectConfig()->remove($path);
147			}
148
149			/**
150			* Invalidate all flagged template caches
151			*/
152			public function invalidateAllFlaggedCaches()
153			{
154			TagDependency::invalidate(Craft::$app->getCache(), 'cacheflag');
155			}
156
157			/**
158			* @param ElementInterface $element
159			* @return bool
160			*/
161			public function invalidateFlaggedCachesByElement(ElementInterface $element): bool
162			{
163			// Collect all flags for this element
164			$query = (new Query())
165			->select(['flags'])
166			->from(Flags::tableName());
167
168			$elementType = \get_class($element);
169			$dynamicFlags = ["element:$element->id", "element:$element->uid"];
170
171			switch ($elementType) {
172			case 'craft\elements\Asset':
173			/** @var Asset $element */
174			$query->orWhere([
175			'volumeId' => $element->volumeId,
176			]);
177			$dynamicFlags[] = "asset:$element->id";
178			$dynamicFlags[] = "asset:$element->uid";
179			break;
180			case 'craft\elements\Category':
181			/** @var Category $element */
182			$query->orWhere([
183			'categoryGroupId' => $element->groupId,
184			]);
185			$dynamicFlags[] = "category:$element->id";
186			$dynamicFlags[] = "category:$element->uid";
187			break;
188			case 'craft\elements\Entry':
189			/** @var Entry $element */
190			$query->orWhere([
191			'sectionId' => $element->sectionId,
192			]);
193			$dynamicFlags[] = "entry:$element->id";
194			$dynamicFlags[] = "entry:$element->uid";
195			break;
196			case 'craft\elements\GlobalSet':
197			/** @var GlobalSet $element */
198			$query->orWhere([
199			'globalSetId' => $element->id,
200			]);
201			$dynamicFlags[] = "globalSet:$element->id";
202			$dynamicFlags[] = "globalSet:$element->uid";
203			break;
204			case 'craft\elements\Tag':
205			/** @var Tag $element */
206			$query->orWhere([
207			'tagGroupId' => $element->groupId,
208			]);
209			$dynamicFlags[] = "tag:$element->id";
210			$dynamicFlags[] = "tag:$element->uid";
211			break;
212			case 'craft\elements\User':
213			/** @var User $element */
214			foreach ($element->getGroups() as $userGroup) {
215			$query->orWhere([
216			'userGroupId' => $userGroup->id,
217			]);
218			}
219			$dynamicFlags[] = "user:$element->id";
220			$dynamicFlags[] = "user:$element->uid";
221			break;
222			}
223
224			$query->orWhere([
225			'elementType' => $elementType,
226			]);
227
228			$flags = \array_unique(\array_merge($query->column(), $dynamicFlags));
229
230			return $this->invalidateFlaggedCachesByFlags($flags);
231			}
232
233			/**
234			* @param string\|string[]\|null $flags
235			* @return bool
236			*/
237			public function invalidateFlaggedCachesByFlags(string\|array\|null $flags): bool
238			{
239
240			if (empty($flags)) {
241			return false;
242			}
243
244			if (is_array($flags)) {
			0 ignored issues – show introduced 2024-03-28 13:16 UTC by Report Bug Copy Issue Report The condition `is_array($flags)` is always `true`. Loading history...
245			$flags = $this->implodeFlagsArray($flags);
246			} else {
247			$flags = preg_replace('/\s+/', '', $flags);
248			}
249
250			$flags = array_values(\array_unique(\explode(',', $flags)));
251
252			if (empty($flags)) {
253			return false;
254			}
255
256			// Fire a `beforeInvalidateFlaggedCaches` event
257			if ($this->hasEventHandlers(self::EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES)) {
258			$this->trigger(self::EVENT_BEFORE_INVALIDATE_FLAGGED_CACHES, new FlaggedTemplateCachesEvent([
259			'flags' => $flags,
260			]));
261			}
262
263			$flagTags = array_map(function (string $flag) {
264			return "cacheflag::$flag";
265			}, $flags);
266
267			TagDependency::invalidate(Craft::$app->getCache(), $flagTags);
268
269			// Fire a 'afterInvalidateFlaggedCaches' event
270			if ($this->hasEventHandlers(self::EVENT_AFTER_INVALIDATE_FLAGGED_CACHES)) {
271			$this->trigger(self::EVENT_AFTER_INVALIDATE_FLAGGED_CACHES, new FlaggedTemplateCachesEvent([
272			'flags' => $flags,
273			]));
274			}
275
276			return true;
277			}
278
279			/**
280			* @param array $flagsArray
281			* @return string
282			*/
283			protected function implodeFlagsArray(array $flagsArray): string
284			{
285
286			$flags = '';
287
288			foreach ($flagsArray as $item) {
289			if (is_array($item)) {
290			$flags .= "{$this->implodeFlagsArray($item)},";
291			} else {
292			$flags .= preg_replace('/\s+/', '', $item) . ',';
293			}
294			}
295
296			return substr($flags, 0, 0 - strlen(','));
297			}
298			}
299

mmikkel / CacheFlag-Craft3

CacheFlagService::invalidateFlaggedCachesByFlags() B last analyzed 2025-06-16 17:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CacheFlagService::invalidateFlaggedCachesByFlags() B
last analyzed 2025-06-16 17:20 UTC