<?php

/**

* @link https://craftcms.com/

* @copyright Copyright (c) Pixel & Tonic, Inc.

* @license https://craftcms.github.io/license/

*/

namespace craft\services;

use Craft;

use craft\base\Element;

use craft\base\ElementActionInterface;

use craft\base\ElementExporterInterface;

use craft\base\ElementInterface;

use craft\base\ExpirableElementInterface;

use craft\base\FieldInterface;

use craft\base\NestedElementInterface;

use craft\behaviors\DraftBehavior;

use craft\behaviors\RevisionBehavior;

use craft\console\controllers\MigrateController;

use craft\console\controllers\UpController;

use craft\controllers\AppController;

use craft\db\Connection;

use craft\db\Query;

use craft\db\QueryAbortedException;

use craft\db\Table;

use craft\elements\Address;

use craft\elements\Asset;

use craft\elements\Category;

use craft\elements\db\EagerLoadInfo;

use craft\elements\db\EagerLoadPlan;

use craft\elements\db\ElementQuery;

use craft\elements\db\ElementQueryInterface;

use craft\elements\Entry;

use craft\elements\GlobalSet;

use craft\elements\Tag;

use craft\elements\User;

use craft\errors\ElementNotFoundException;

use craft\errors\InvalidElementException;

use craft\errors\OperationAbortedException;

use craft\errors\SiteNotFoundException;

use craft\errors\UnsupportedSiteException;

use craft\events\AuthorizationCheckEvent;

use craft\events\BulkOpEvent;

use craft\events\DeleteElementEvent;

use craft\events\EagerLoadElementsEvent;

use craft\events\ElementEvent;

use craft\events\ElementQueryEvent;

use craft\events\InvalidateElementCachesEvent;

use craft\events\MergeElementsEvent;

use craft\events\MultiElementActionEvent;

use craft\events\RegisterComponentTypesEvent;

use craft\fieldlayoutelements\CustomField;

use craft\helpers\ArrayHelper;

use craft\helpers\Component as ComponentHelper;

use craft\helpers\DateTimeHelper;

use craft\helpers\Db;

use craft\helpers\ElementHelper;

use craft\helpers\Html;

use craft\helpers\Json;

use craft\helpers\Queue;

use craft\helpers\StringHelper;

use craft\helpers\UrlHelper;

use craft\i18n\Translation;

use craft\models\ElementActivity;

use craft\models\Section;

use craft\queue\jobs\FindAndReplace;

use craft\queue\jobs\UpdateElementSlugsAndUris;

use craft\queue\jobs\UpdateSearchIndex;

use craft\records\Element as ElementRecord;

use craft\records\Element_SiteSettings as Element_SiteSettingsRecord;

use craft\records\StructureElement as StructureElementRecord;

use craft\validators\HandleValidator;

use craft\validators\SlugValidator;

use DateTime;

use Illuminate\Support\Collection;

use Throwable;

use UnitEnum;

use yii\base\Behavior;

use yii\base\Component;

use yii\base\Exception;

use yii\base\InvalidArgumentException;

use yii\base\InvalidCallException;

use yii\base\InvalidConfigException;

use yii\caching\TagDependency;

use yii\di\Instance;

/**

* The Elements service provides APIs for managing elements.

*

* An instance of the service is available via [[\craft\base\ApplicationTrait::getElements()|`Craft::$app->getElements()`]].

*

* @author Pixel & Tonic, Inc. <[email protected]>

* @since 3.0.0

*/

class Elements extends Component

{

/**

* @event RegisterComponentTypesEvent The event that is triggered when registering element types.

*

* Element types must implement [[ElementInterface]]. [[Element]] provides a base implementation.

*

* See [Element Types](https://craftcms.com/docs/5.x/extend/element-types.html) for documentation on creating element types.

* ---

* ```php

* use craft\events\RegisterComponentTypesEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(Elements::class,

* Elements::EVENT_REGISTER_ELEMENT_TYPES,

* function(RegisterComponentTypesEvent $event) {

* $event->types[] = MyElementType::class;

* }

* );

* ```

*/

public const EVENT_REGISTER_ELEMENT_TYPES = 'registerElementTypes';

/**

* @event EagerLoadElementsEvent The event that is triggered before elements are eager-loaded.

* @since 3.5.0

*/

public const EVENT_BEFORE_EAGER_LOAD_ELEMENTS = 'beforeEagerLoadElements';

/**

* @event BulkOpEvent The event that is triggered before a bulk element operation has started.

*

* Note that this won’t necessarily fire from the same request as [[EVENT_AFTER_BULK_OP]].

*

* @since 5.0.0

*/

public const EVENT_BEFORE_BULK_OP = 'beforeBulkOp';

/**

* @event BulkOpEvent The event that is triggered after a bulk element operation is completed.

*

* Note that this won’t necessarily fire from the same request as [[EVENT_BEFORE_BULK_OP]].

*

* @since 5.0.0

*/

public const EVENT_AFTER_BULK_OP = 'afterBulkOp';

/**

* @event MergeElementsEvent The event that is triggered after two elements are merged together.

*/

public const EVENT_AFTER_MERGE_ELEMENTS = 'afterMergeElements';

/**

* @event DeleteElementEvent The event that is triggered before an element is deleted.

*/

public const EVENT_BEFORE_DELETE_ELEMENT = 'beforeDeleteElement';

/**

* @event ElementEvent The event that is triggered after an element is deleted.

*/

public const EVENT_AFTER_DELETE_ELEMENT = 'afterDeleteElement';

/**

* @event ElementEvent The event that is triggered before an element is restored.

* @since 3.1.0

*/

public const EVENT_BEFORE_RESTORE_ELEMENT = 'beforeRestoreElement';

/**

* @event ElementEvent The event that is triggered after an element is restored.

* @since 3.1.0

*/

public const EVENT_AFTER_RESTORE_ELEMENT = 'afterRestoreElement';

/**

* @event ElementEvent The event that is triggered before an element is saved.

*

* If you want to ignore events for drafts or revisions, call [[\craft\helpers\ElementHelper::isDraftOrRevision()]]

* from your event handler:

*

* ```php

* use craft\events\ElementEvent;

* use craft\helpers\ElementHelper;

* use craft\services\Elements;

*

* Craft::$app->elements->on(Elements::EVENT_BEFORE_SAVE_ELEMENT, function(ElementEvent $e) {

* if (ElementHelper::isDraftOrRevision($e->element)) {

* return;

* }

*

* // ...

* });

* ```

*/

public const EVENT_BEFORE_SAVE_ELEMENT = 'beforeSaveElement';

/**

* @event ElementEvent The event that is triggered after an element is saved.

*

* If you want to ignore events for drafts or revisions, call [[\craft\helpers\ElementHelper::isDraftOrRevision()]]

* from your event handler:

*

* ```php

* use craft\events\ElementEvent;

* use craft\helpers\ElementHelper;

* use craft\services\Elements;

*

* Craft::$app->elements->on(Elements::EVENT_AFTER_SAVE_ELEMENT, function(ElementEvent $e) {

* if (ElementHelper::isDraftOrRevision($e->element)) {

* return;

* }

*

* // ...

* });

* ```

*/

public const EVENT_AFTER_SAVE_ELEMENT = 'afterSaveElement';

/**

* @event ElementEvent The event that is triggered when setting a unique URI on an element.

*

* Event handlers must set `$event->handled` to `true` for their change to take effect.

*

* @see setElementUri()

* @since 4.6.0

*/

public const EVENT_SET_ELEMENT_URI = 'setElementUri';

/**

* @event ElementEvent The event that is triggered before indexing an element’s search keywords,

* or queuing the element’s search keywords to be updated.

*

* You may set [[\craft\events\CancelableEvent::$isValid]] to `false` to prevent the search index from being updated.

*

* @since 3.7.12

*/

public const EVENT_BEFORE_UPDATE_SEARCH_INDEX = 'beforeUpdateSearchIndex';

/**

* @event ElementQueryEvent The event that is triggered before resaving a batch of elements.

*/

public const EVENT_BEFORE_RESAVE_ELEMENTS = 'beforeResaveElements';

/**

* @event ElementQueryEvent The event that is triggered after resaving a batch of elements.

*/

public const EVENT_AFTER_RESAVE_ELEMENTS = 'afterResaveElements';

/**

* @event MultiElementActionEvent The event that is triggered before an element is resaved.

*/

public const EVENT_BEFORE_RESAVE_ELEMENT = 'beforeResaveElement';

/**

* @event MultiElementActionEvent The event that is triggered after an element is resaved.

*/

public const EVENT_AFTER_RESAVE_ELEMENT = 'afterResaveElement';

/**

* @event ElementQueryEvent The event that is triggered before propagating a batch of elements.

*/

public const EVENT_BEFORE_PROPAGATE_ELEMENTS = 'beforePropagateElements';

/**

* @event ElementQueryEvent The event that is triggered after propagating a batch of elements.

*/

public const EVENT_AFTER_PROPAGATE_ELEMENTS = 'afterPropagateElements';

/**

* @event MultiElementActionEvent The event that is triggered before an element is propagated.

*/

public const EVENT_BEFORE_PROPAGATE_ELEMENT = 'beforePropagateElement';

/**

* @event MultiElementActionEvent The event that is triggered after an element is propagated.

*/

public const EVENT_AFTER_PROPAGATE_ELEMENT = 'afterPropagateElement';

/**

* @event ElementEvent The event that is triggered before an element’s slug and URI are updated, usually following a Structure move.

*/

public const EVENT_BEFORE_UPDATE_SLUG_AND_URI = 'beforeUpdateSlugAndUri';

/**

* @event ElementEvent The event that is triggered after an element’s slug and URI are updated, usually following a Structure move.

*/

public const EVENT_AFTER_UPDATE_SLUG_AND_URI = 'afterUpdateSlugAndUri';

/**

* @event \craft\events\ElementActionEvent The event that is triggered before an element action is performed.

*

* You may set [[\craft\events\CancelableEvent::$isValid]] to `false` to prevent the action from being performed.

*/

public const EVENT_BEFORE_PERFORM_ACTION = 'beforePerformAction';

/**

* @event \craft\events\ElementActionEvent The event that is triggered after an element action is performed.

*/

public const EVENT_AFTER_PERFORM_ACTION = 'afterPerformAction';

/**

* @event ElementEvent The event that is triggered before canonical element changes are merged into a derivative.

* @since 3.7.0

*/

public const EVENT_BEFORE_MERGE_CANONICAL_CHANGES = 'beforeMergeCanonical';

/**

* @event ElementEvent The event that is triggered after canonical element changes are merged into a derivative.

* @since 3.7.0

*/

public const EVENT_AFTER_MERGE_CANONICAL_CHANGES = 'afterMergeCanonical';

/**

* @event InvalidateElementCachesEvent The event that is triggered when element caches are invalidated.

* @since 4.2.0

*/

public const EVENT_INVALIDATE_CACHES = 'invalidateCaches';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to view an element’s edit page.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_VIEW,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canView()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_VIEW = 'authorizeView';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to save an element in its current state.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_SAVE,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canSave()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_SAVE = 'authorizeSave';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to create drafts for an element.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_CREATE_DRAFTS,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canCreateDrafts()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_CREATE_DRAFTS = 'authorizeCreateDrafts';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to duplicate an element.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_DUPLICATE,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canDuplicate()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_DUPLICATE = 'authorizeDuplicate';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to

* duplicate an element as an unpublished draft.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_DUPLICATE,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canDuplicateAsDraft()

* @since 5.0.0

*/

public const EVENT_AUTHORIZE_DUPLICATE_AS_DRAFT = 'authorizeDuplicateAsDraft';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to delete an element.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_DELETE,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canDelete()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_DELETE = 'authorizeDelete';

/**

* @event AuthorizationCheckEvent The event that is triggered when determining whether a user is authorized to delete an element for its current site.

*

* To authorize the user, set [[AuthorizationCheckEvent::$authorized]] to `true`.

*

* ```php

* use craft\events\AuthorizationCheckEvent;

* use craft\services\Elements;

* use yii\base\Event;

*

* Event::on(

* Elements::class,

* Elements::EVENT_AUTHORIZE_DELETE_FOR_SITE,

* function(AuthorizationCheckEvent $event) {

* $event->authorized = true;

* }

* );

* ```

*

* @see canDeleteForSite()

* @since 4.3.0

*/

public const EVENT_AUTHORIZE_DELETE_FOR_SITE = 'authorizeDeleteForSite';

/**

* @event ElementEvent The event that is triggered before deleting an element for a single site.

* @see deleteElementForSite()

* @see deleteElementsForSite()

* @since 4.4.0

*/

public const EVENT_BEFORE_DELETE_FOR_SITE = 'beforeDeleteForSite';

/**

* @event ElementEvent The event that is triggered after deleting an element for a single site.

* @see deleteElementForSite()

* @see deleteElementsForSite()

* @since 4.4.0

*/

public const EVENT_AFTER_DELETE_FOR_SITE = 'afterDeleteForSite';

/**

* @var array|null

*/

private ?array $_placeholderElements = null;

/**

* @var array

* @see setPlaceholderElement()

* @see getElementByUri()

*/

private array $_placeholderUris;

/**

* @var string[]

*/

private array $_elementTypesByRefHandle = [];

/**

* @var bool|null Whether we should be updating search indexes for elements if not told explicitly.

* @since 3.1.2

*/

private ?bool $_updateSearchIndex = null;

/**

* @inheritdoc

*/

public function init()

{

parent::init();

$this->bulkOpDb = Instance::ensure($this->bulkOpDb, Connection::class);

}

/**

* Creates an element with a given config.

*

* @template T of ElementInterface

* @param class-string<T>|array $config The element’s class name, or its config, with a `type` value

* @phpstan-param class-string<T>|array{type:class-string<T>} $config

* @return T The element

*/

public function createElement(mixed $config): ElementInterface

{

if (is_string($config)) {

$config = ['type' => $config];

}

return ComponentHelper::createComponent($config, ElementInterface::class);

}

/**

* Creates an element query for a given element type.

*

* @param class-string<ElementInterface> $elementType The element class

* @return ElementQueryInterface The element query

* @throws InvalidArgumentException if $elementType is not a valid element

* @since 3.5.0

*/

public function createElementQuery(string $elementType): ElementQueryInterface

{

if (!is_subclass_of($elementType, ElementInterface::class)) {

throw new InvalidArgumentException("$elementType is not a valid element.");

}

return $elementType::find();

}

/**

* @var Connection|array|string the DB connection object or the application component ID of the DB connection

* that should be used to store element bulk op records.

* @since 5.3.0

*/

public Connection|array|string $bulkOpDb = 'db2';

// Element caches

// -------------------------------------------------------------------------

/**

* @var array[]

*/

private array $_cacheTagBuffers = [];

/**

* @var string[]|null

*/

private ?array $_cacheTags = null;

/**

* @var array

* @phpstan-var array<int|null>

*/

private array $_cacheDurationBuffers = [];

private ?int $_cacheDuration = null;

/**

* Returns whether we are currently collecting element cache invalidation info.

*

* @return bool

* @see startCollectingCacheInfo()

* @see stopCollectingCacheInfo()

* @since 4.3.0

*/

public function getIsCollectingCacheInfo(): bool

{

return isset($this->_cacheTags);

}

/**

* Returns whether we are currently collecting element cache invalidation tags.

*

* @return bool

* @since 3.5.0

* @deprecated in 4.3.0. [[getIsCollectingCacheInfo()]] should be used instead.

*/

public function getIsCollectingCacheTags(): bool

{

return $this->getIsCollectingCacheInfo();

}

/**

* Starts collecting element cache invalidation info.

*

* @since 4.3.0

*/

public function startCollectingCacheInfo(): void

{

// Save any currently-collected info into new buffers

if (isset($this->_cacheTags)) {

$this->_cacheTagBuffers[] = $this->_cacheTags;

$this->_cacheDurationBuffers[] = $this->_cacheDuration;

}

$this->_cacheTags = [];

$this->_cacheDuration = null;

}

/**

* Starts collecting element cache invalidation tags.

*

* @since 3.5.0

* @deprecated in 4.3.0. [[startCollectingCacheInfo()]] should be used instead.

*/

public function startCollectingCacheTags(): void

{

$this->startCollectingCacheInfo();

}

/**

* Adds element cache invalidation tags to the current collection.

*

* @param string[] $tags

* @since 3.5.0

*/

public function collectCacheTags(array $tags): void

{

// Ignore if we're not currently collecting tags

if (!isset($this->_cacheTags)) {

return;

}

// Element query tags

foreach ($tags as $tag) {

$this->_cacheTags[$tag] = true;

}

}

/**

* Sets a possible cache expiration date that [[stopCollectingCacheInfo()]] should return.

*

* The value will only be used if it is less than the currently stored expiration date.

*

* @param DateTime $expiryDate

* @since 4.3.0

*/

public function setCacheExpiryDate(DateTime $expiryDate): void

{

if (!isset($this->_cacheTags)) {

return;

}

$duration = $expiryDate->getTimestamp() - DateTimeHelper::currentTimeStamp();

if ($duration > 0 && (!$this->_cacheDuration || $duration < $this->_cacheDuration)) {

$this->_cacheDuration = $duration;

}

}

/**

** Stores cache invalidation info for a given element.

*

* @param ElementInterface $element

* @since 4.5.0

*/

public function collectCacheInfoForElement(ElementInterface $element): void

{

// Ignore if we're not currently collecting tags

if (!isset($this->_cacheTags)) {

return;

}

$class = get_class($element);

$this->collectCacheTags([

'element',

"element::$class",

"element::$element->id",

]);

// If the element is expirable, register its expiry date

if (

$element instanceof ExpirableElementInterface &&

($expiryDate = $element->getExpiryDate()) !== null

) {

$this->setCacheExpiryDate($expiryDate);

}

}

/**

* Stops collecting element invalidation info, and returns a [[TagDependency]] and recommended max cache duration

* that should be used when saving the cache data.

*

* If no cache tags were registered, `[null, null]` will be returned.

*

* @return array

* @phpstan-return array{TagDependency|null,int|null}

* @since 4.3.0

*/

public function stopCollectingCacheInfo(): array

{

if (!isset($this->_cacheTags)) {

throw new InvalidCallException('Element cache invalidation tags are not currently being collected.');

}

$tags = $this->_cacheTags;

$duration = $this->_cacheDuration;

// Was there another active collection?

if (!empty($this->_cacheTagBuffers)) {

$this->_cacheTags = array_merge(array_pop($this->_cacheTagBuffers), $tags);

// Override the parent duration if ours is shorter

$this->_cacheDuration = array_pop($this->_cacheDurationBuffers);

if ($duration && $duration < $this->_cacheDuration) {

$this->_cacheDuration = $duration;

}

} else {

$this->_cacheTags = null;

$this->_cacheDuration = null;

}

if (empty($tags)) {

return [null, null];

}

// Only use the duration if it's less than the cacheDuration config setting

$generalConfig = Craft::$app->getConfig()->getGeneral();

if ($generalConfig->cacheDuration) {

if ($duration) {

$duration = min($duration, $generalConfig->cacheDuration);

} else {

$duration = $generalConfig->cacheDuration;

}

}

$dep = new TagDependency([

'tags' => array_keys($tags),

]);

return [$dep, $duration];

}

/**

* Stops collecting element cache invalidation tags, and returns a cache dependency object.

*

* @return TagDependency

* @since 3.5.0

* @deprecated in 4.3.0. [[stopCollectingCacheInfo()]] should be used instead.

*/

public function stopCollectingCacheTags(): TagDependency

{

[$dep] = $this->stopCollectingCacheInfo();

return $dep ?? new TagDependency();

}

/**

* Invalidates all element caches.

*

* @since 3.5.0

*/

public function invalidateAllCaches(): void

{

$tags = ['element'];

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

// Fire a 'invalidateCaches' event

if ($this->hasEventHandlers(self::EVENT_INVALIDATE_CACHES)) {

$this->trigger(self::EVENT_INVALIDATE_CACHES, new InvalidateElementCachesEvent([

'tags' => $tags,

]));

}

}

/**

* Invalidates caches for the given element type.

*

* @param class-string<ElementInterface> $elementType

* @since 3.5.0

*/

public function invalidateCachesForElementType(string $elementType): void

{

$tags = ["element::$elementType"];

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

// Fire a 'invalidateCaches' event

if ($this->hasEventHandlers(self::EVENT_INVALIDATE_CACHES)) {

$this->trigger(self::EVENT_INVALIDATE_CACHES, new InvalidateElementCachesEvent([

'tags' => $tags,

]));

}

}

/**

* Invalidates caches for the given element.

*

* @param ElementInterface $element

* @since 3.5.0

*/

public function invalidateCachesForElement(ElementInterface $element): void

{

$tags = [

sprintf('element::%s::*', $element::class),

sprintf('element::%s', $element->id),

];

$rootElement = $element;

if ($element instanceof NestedElementInterface) {

try {

$owner = $element->getOwner();

} catch (InvalidConfigException) {

$owner = null;

}

if ($owner) {

$tags[] = sprintf('element::%s', $owner->id);

try {

$rootElement = ElementHelper::rootElement($owner);

} catch (Throwable) {

$rootElement = $owner;

}

}

}

if ($rootElement->getIsDraft()) {

$tags[] = sprintf('element::%s::drafts', $element::class);

} elseif ($rootElement->getIsRevision()) {

$tags[] = sprintf('element::%s::revisions', $element::class);

} else {

foreach ($element->getCacheTags() as $tag) {

// tags can be provided fully-formed, or relative to the element type

if (!str_starts_with($tag, 'element::')) {

$tag = sprintf('element::%s::%s', $element::class, $tag);

}

$tags[] = $tag;

}

}

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

// Fire a 'invalidateCaches' event

if ($this->hasEventHandlers(self::EVENT_INVALIDATE_CACHES)) {

$this->trigger(self::EVENT_INVALIDATE_CACHES, new InvalidateElementCachesEvent([

'tags' => $tags,

'element' => $element,

]));

}

}

// Finding Elements

// -------------------------------------------------------------------------

/**

* Returns an element by its ID.

*

* If no element type is provided, the method will first have to run a DB query to determine what type of element

* the $id is, so you should definitely pass it if it’s known.

* The element’s status will not be a factor when using this method.

*

* @template T of ElementInterface

* @param int $elementId The element’s ID.

* @param class-string<T>|null $elementType The element class.

* @param int|string|int[]|null $siteId The site(s) to fetch the element in.

* Defaults to the current site.

* @param array $criteria

* @return T|null The matching element, or `null`.

*/

public function getElementById(int $elementId, ?string $elementType = null, array|int|string $siteId = null, array $criteria = []): ?ElementInterface

{

return $this->_elementById('id', $elementId, $elementType, $siteId, $criteria);

}

/**

* Returns an element by its UID.

*

* If no element type is provided, the method will first have to run a DB query to determine what type of element

* the $uid is, so you should definitely pass it if it’s known.

* The element’s status will not be a factor when using this method.

*

* @template T of ElementInterface

* @param string $uid The element’s UID.

* @param class-string<T>|null $elementType The element class.

* @param int|string|int[]|null $siteId The site(s) to fetch the element in.

* Defaults to the current site.

* @param array $criteria

* @return T|null The matching element, or `null`.

* @since 3.5.13

*/

public function getElementByUid(string $uid, ?string $elementType = null, array|int|string $siteId = null, array $criteria = []): ?ElementInterface

{

return $this->_elementById('uid', $uid, $elementType, $siteId, $criteria);

}

/**

* Returns an element by its ID or UID.

*

* @template T of ElementInterface

* @param string $property Either `id` or `uid`

* @param int|string $elementId The element’s ID/UID

* @param class-string<T>|null $elementType The element class.

* @param int|string|int[]|null $siteId The site(s) to fetch the element in.

* Defaults to the current site.

* @param array $criteria

* @return T|null The matching element, or `null`.

*/

private function _elementById(string $property, int|string $elementId, ?string $elementType = null, array|int|string $siteId = null, array $criteria = []): ?ElementInterface

{

if (!$elementId) {

return null;

}

if ($elementType === null) {

$elementType = $this->_elementTypeById($property, $elementId);

}

if ($elementType === null || !class_exists($elementType)) {

return null;

}

$query = $this->createElementQuery($elementType)

->siteId($siteId)

->status(null)

->drafts(null)

->provisionalDrafts(null)

->revisions(null);

$query->$property = $elementId;

Craft::configure($query, $criteria);

return $query->one();

}

/**

* Returns an element by its URI.

*

* @param string $uri The element’s URI.

* @param int|null $siteId The site to look for the URI in, and to return the element in.

* Defaults to the current site.

* @param bool $enabledOnly Whether to only look for an enabled element. Defaults to `false`.

* @return ElementInterface|null The matching element, or `null`.

*/

public function getElementByUri(string $uri, ?int $siteId = null, bool $enabledOnly = false): ?ElementInterface

{

if ($uri === '') {

$uri = Element::HOMEPAGE_URI;

}

if ($siteId === null) {

/** @noinspection PhpUnhandledExceptionInspection */

$siteId = Craft::$app->getSites()->getCurrentSite()->id;

}

// See if we already have a placeholder for this element URI

if (isset($this->_placeholderUris[$uri][$siteId])) {

return $this->_placeholderUris[$uri][$siteId];

}

// First get the element ID and type

$query = (new Query())

->select(['elements.id', 'elements.type'])

->from(['elements' => Table::ELEMENTS])

->innerJoin(['elements_sites' => Table::ELEMENTS_SITES], '[[elements_sites.elementId]] = [[elements.id]]')

->where([

'elements.draftId' => null,

'elements.revisionId' => null,

'elements.dateDeleted' => null,

'elements_sites.siteId' => $siteId,

]);

if (Craft::$app->getDb()->getIsMysql()) {

$query->andWhere([

'elements_sites.uri' => $uri,