<?php

/**

* @link https://craftcms.com/

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

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

*/

namespace craft\elements;

use Craft;

use craft\base\Colorable;

use craft\base\Element;

use craft\base\ElementContainerFieldInterface;

use craft\base\ExpirableElementInterface;

use craft\base\Field;

use craft\base\FieldInterface;

use craft\base\Iconic;

use craft\base\NestedElementInterface;

use craft\base\NestedElementTrait;

use craft\behaviors\DraftBehavior;

use craft\controllers\ElementIndexesController;

use craft\db\Connection;

use craft\db\FixedOrderExpression;

use craft\db\Table;

use craft\elements\actions\Delete;

use craft\elements\actions\DeleteForSite;

use craft\elements\actions\Duplicate;

use craft\elements\actions\MoveToSection;

use craft\elements\actions\NewChild;

use craft\elements\actions\NewSiblingAfter;

use craft\elements\actions\NewSiblingBefore;

use craft\elements\actions\Restore;

use craft\elements\conditions\ElementConditionInterface;

use craft\elements\conditions\entries\EntryCondition;

use craft\elements\conditions\entries\SectionConditionRule;

use craft\elements\conditions\entries\TypeConditionRule;

use craft\elements\db\EagerLoadPlan;

use craft\elements\db\ElementQuery;

use craft\elements\db\ElementQueryInterface;

use craft\elements\db\EntryQuery;

use craft\enums\CmsEdition;

use craft\enums\Color;

use craft\enums\PropagationMethod;

use craft\events\DefineEntryTypesEvent;

use craft\events\ElementCriteriaEvent;

use craft\fieldlayoutelements\entries\EntryTitleField;

use craft\helpers\ArrayHelper;

use craft\helpers\Cp;

use craft\helpers\DateTimeHelper;

use craft\helpers\Db;

use craft\helpers\ElementHelper;

use craft\helpers\Html;

use craft\helpers\UrlHelper;

use craft\models\EntryType;

use craft\models\FieldLayout;

use craft\models\Section;

use craft\models\Section_SiteSettings;

use craft\models\Site;

use craft\records\Entry as EntryRecord;

use craft\services\ElementSources;

use craft\services\Structures;

use craft\validators\ArrayValidator;

use craft\validators\DateCompareValidator;

use craft\validators\DateTimeValidator;

use DateTime;

use Illuminate\Support\Arr;

use Illuminate\Support\Collection;

use Throwable;

use yii\base\Exception;

use yii\base\InvalidArgumentException;

use yii\base\InvalidConfigException;

use yii\db\Expression;

/**

* Entry represents an entry element.

*

* @property int $typeId the entry type’s ID

* @property EntryType $type the entry type

* @property Section|null $section the entry’s section

* @property User|null $author the primary entry author

* @property User[] $authors the entry authors

* @property int|null $authorId The primary entry author’s ID

* @property int[] $authorIds the entry authors’ IDs

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

* @since 3.0.0

*/

class Entry extends Element implements NestedElementInterface, ExpirableElementInterface, Iconic, Colorable

{

use NestedElementTrait {

eagerLoadingMap as traitEagerLoadingMap;

attributes as traitAttributes;

extraFields as traitExtraFields;

setEagerLoadedElements as traitSetEagerLoadedElements;

}

public const STATUS_LIVE = 'live';

public const STATUS_PENDING = 'pending';

public const STATUS_EXPIRED = 'expired';

/**

* @event DefineEntryTypesEvent The event that is triggered when defining the available entry types for the entry

* @see getAvailableEntryTypes()

* @since 3.6.0

*/

public const EVENT_DEFINE_ENTRY_TYPES = 'defineEntryTypes';

/**

* @event ElementCriteriaEvent The event that is triggered when defining the parent selection criteria.

* @see _parentOptionCriteria()

* @since 4.4.0

*/

public const EVENT_DEFINE_PARENT_SELECTION_CRITERIA = 'defineParentSelectionCriteria';

/**

* @inheritdoc

*/

public static function displayName(): string

{

return Craft::t('app', 'Entry');

}

/**

* @inheritdoc

*/

public static function lowerDisplayName(): string

{

return Craft::t('app', 'entry');

}

/**

* @inheritdoc

*/

public static function pluralDisplayName(): string

{

return Craft::t('app', 'Entries');

}

/**

* @inheritdoc

*/

public static function pluralLowerDisplayName(): string

{

return Craft::t('app', 'entries');

}

/**

* @inheritdoc

*/

public static function refHandle(): ?string

{

return 'entry';

}

/**

* @inheritdoc

*/

public static function hasDrafts(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function trackChanges(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function hasTitles(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function hasUris(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function isLocalized(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function hasStatuses(): bool

{

return true;

}

/**

* @inheritdoc

*/

public static function statuses(): array

{

return [

self::STATUS_LIVE => Craft::t('app', 'Live'),

self::STATUS_PENDING => Craft::t('app', 'Pending'),

self::STATUS_EXPIRED => Craft::t('app', 'Expired'),

self::STATUS_DISABLED => Craft::t('app', 'Disabled'),

];

}

/**

* @inheritdoc

* @return EntryQuery The newly created [[EntryQuery]] instance.

*/

public static function find(): EntryQuery

{

return new EntryQuery(static::class);

}

/**

* @inheritdoc

* @return EntryCondition

*/

public static function createCondition(): ElementConditionInterface

{

return Craft::createObject(EntryCondition::class, [static::class]);

}

/**

* @inheritdoc

*/

protected static function defineSources(string $context): array

{

if ($context === ElementSources::CONTEXT_INDEX) {

$sections = Craft::$app->getEntries()->getEditableSections();

$editable = true;

} else {

$sections = Craft::$app->getEntries()->getAllSections();

$editable = null;

}

$sectionIds = [];

$singleSectionIds = [];

$sectionsByType = [];

foreach ($sections as $section) {

$sectionIds[] = $section->id;

if ($section->type == Section::TYPE_SINGLE) {

$singleSectionIds[] = $section->id;

} else {

$sectionsByType[$section->type][] = $section;

}

}

$sources = [

[

'key' => '*',

'label' => Craft::t('app', 'All entries'),

'criteria' => [

'sectionId' => $sectionIds,

'editable' => $editable,

],

'defaultSort' => ['postDate', 'desc'],

],

];

if (!empty($singleSectionIds)) {

$sources[] = [

'key' => 'singles',

'label' => Craft::t('app', 'Singles'),

'criteria' => [

'sectionId' => $singleSectionIds,

'editable' => $editable,

],

'defaultSort' => ['title', 'asc'],

];

}

$sectionTypes = [

Section::TYPE_CHANNEL => Craft::t('app', 'Channels'),

Section::TYPE_STRUCTURE => Craft::t('app', 'Structures'),

];

$user = Craft::$app->getUser()->getIdentity();

foreach ($sectionTypes as $type => $heading) {

if (!empty($sectionsByType[$type])) {

$sources[] = ['heading' => $heading];

foreach ($sectionsByType[$type] as $section) {

/** @var Section $section */

$source = [

'key' => 'section:' . $section->uid,

'label' => Craft::t('site', $section->name),

'sites' => $section->getSiteIds(),

'data' => [

'type' => $type,

'handle' => $section->handle,

],

'criteria' => [

'sectionId' => $section->id,

'editable' => $editable,

],

];

if ($type == Section::TYPE_STRUCTURE) {

$source['defaultSort'] = ['structure', 'asc'];

$source['structureId'] = $section->structureId;

$source['structureEditable'] = $user && $user->can("saveEntries:$section->uid");

} else {

$source['defaultSort'] = ['postDate', 'desc'];

}

$sources[] = $source;

}

}

}

return $sources;

}

/**

* @inheritdoc

*/

public static function modifyCustomSource(array $config): array

{

if (empty($config['condition']['conditionRules'])) {

return $config;

}

// see if it's limited to one section

/** @var SectionConditionRule|null $sectionRule */

$sectionRule = ArrayHelper::firstWhere(

$config['condition']['conditionRules'],

fn(array $rule) => $rule['class'] === SectionConditionRule::class,

);

$sectionOptions = $sectionRule['values'] ?? null;

if ($sectionOptions && count($sectionOptions) === 1) {

$section = Craft::$app->getEntries()->getSectionByUid(reset($sectionOptions));

if ($section) {

$config['data']['handle'] = $section->handle;

}

}

// see if it specifies any entry types

/** @var TypeConditionRule|null $entryTypeRule */

$entryTypeRule = ArrayHelper::firstWhere(

$config['condition']['conditionRules'],

fn(array $rule) => $rule['class'] === TypeConditionRule::class,

);

$entryTypeOptions = $entryTypeRule['values'] ?? null;

if ($entryTypeOptions) {

$entryType = Craft::$app->getEntries()->getEntryTypeByUid(reset($entryTypeOptions));

if ($entryType) {

$config['data']['entry-type'] = $entryType->handle;

}

}

return $config;

}

/**

* @inheritdoc

*/

protected static function defineFieldLayouts(?string $source): array

{

if ($source === '*') {

$sections = Craft::$app->getEntries()->getAllSections();

} elseif ($source === 'singles') {

$sections = Craft::$app->getEntries()->getSectionsByType(Section::TYPE_SINGLE);

} elseif ($source !== null && preg_match('/^section:(.+)$/', $source, $matches)) {

$sections = array_filter([

Craft::$app->getEntries()->getSectionByUid($matches[1]),

]);

}

if (isset($sections)) {

$entryTypes = array_values(array_unique(array_merge(

...array_map(fn(Section $section) => $section->getEntryTypes(), $sections),

)));

} else {

// get all entry types, including those which may only be used by Matrix fields

$entryTypes = Craft::$app->getEntries()->getAllEntryTypes();

}

return array_map(fn(EntryType $entryType) => $entryType->getFieldLayout(), $entryTypes);

}

/**

* @inheritdoc

*/

protected static function defineActions(string $source): array

{

// Get the selected site

$controller = Craft::$app->controller;

if ($controller instanceof ElementIndexesController) {

/** @var ElementQuery $elementQuery */

$elementQuery = $controller->getElementQuery();

} else {

$elementQuery = null;

}

$site = $elementQuery && $elementQuery->siteId

? Craft::$app->getSites()->getSiteById($elementQuery->siteId)

: Craft::$app->getSites()->getCurrentSite();

// Get the section we need to check permissions on

if (preg_match('/^section:(\d+)$/', $source, $matches)) {

$section = Craft::$app->getEntries()->getSectionById((int)$matches[1]);

} elseif (preg_match('/^section:(.+)$/', $source, $matches)) {

$section = Craft::$app->getEntries()->getSectionByUid($matches[1]);

} else {

$section = null;

}

// Now figure out what we can do with these

$actions = [];

$elementsService = Craft::$app->getElements();

if ($section) {

$user = Craft::$app->getUser()->getIdentity();

if (

$section->type == Section::TYPE_STRUCTURE &&

$user->can('createEntries:' . $section->uid)

) {

$newEntryUrl = 'entries/' . $section->handle . '/new';

if (Craft::$app->getIsMultiSite()) {

$newEntryUrl .= '?site=' . $site->handle;

}

$actions[] = $elementsService->createAction([

'type' => NewSiblingBefore::class,

'newSiblingUrl' => $newEntryUrl,

]);

$actions[] = $elementsService->createAction([

'type' => NewSiblingAfter::class,

'newSiblingUrl' => $newEntryUrl,

]);

if ($section->maxLevels != 1) {

$actions[] = $elementsService->createAction([

'type' => NewChild::class,

'maxLevels' => $section->maxLevels,

'newChildUrl' => $newEntryUrl,

]);

}

}

// Duplicate

if (

$user->can("createEntries:$section->uid") &&

$user->can("saveEntries:$section->uid")

) {

$actions[] = Duplicate::class;

if ($section->type === Section::TYPE_STRUCTURE && $section->maxLevels != 1) {

$actions[] = [

'type' => Duplicate::class,

'deep' => true,

];

}

$actions[] = MoveToSection::class;

}

// Delete?

$actions[] = Delete::class;

if ($user->can("deleteEntries:$section->uid")) {

if (

$section->type === Section::TYPE_STRUCTURE &&

$section->maxLevels != 1 &&

$user->can("deletePeerEntries:$section->uid")

) {

$actions[] = [

'type' => Delete::class,

'withDescendants' => true,

];

}

if ($section->propagationMethod === PropagationMethod::Custom && $section->getHasMultiSiteEntries()) {

$actions[] = DeleteForSite::class;

}

}

}

// Restore

$actions[] = Restore::class;

return $actions;

}

/**

* @inheritdoc

*/

protected static function includeSetStatusAction(): bool

{

return true;

}

/**

* @inheritdoc

*/

protected static function defineSortOptions(): array

{

return [

'title' => Craft::t('app', 'Title'),

'slug' => Craft::t('app', 'Slug'),

'uri' => Craft::t('app', 'URI'),

[

'label' => Craft::t('app', 'Section'),

'orderBy' => function(int $dir, Connection $db) {

$sectionIds = Collection::make(Craft::$app->getEntries()->getAllSections())

->sort(fn(Section $a, Section $b) => $dir === SORT_ASC

? $a->name <=> $b->name

: $b->name <=> $a->name)

->map(fn(Section $section) => $section->id)

->all();

return new FixedOrderExpression('entries.sectionId', $sectionIds, $db);

},

'attribute' => 'section',

],

[

'label' => Craft::t('app', 'Entry Type'),

'orderBy' => function(int $dir, Connection $db) {

$entryTypeIds = Collection::make(Craft::$app->getEntries()->getAllEntryTypes())

->sort(fn(EntryType $a, EntryType $b) => $dir === SORT_ASC

? $a->name <=> $b->name

: $b->name <=> $a->name)

->map(fn(EntryType $type) => $type->id)

->all();

return new FixedOrderExpression('entries.typeId', $entryTypeIds, $db);

},

'attribute' => 'type',

],

[

'label' => Craft::t('app', 'Post Date'),

'orderBy' => function(int $dir) {

if ($dir === SORT_ASC) {

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

return new Expression('[[postDate]] IS NOT NULL DESC, [[postDate]] ASC');

} else {

return new Expression('[[postDate]] ASC NULLS LAST');

}

}

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

return new Expression('[[postDate]] IS NULL DESC, [[postDate]] DESC');

} else {

return new Expression('[[postDate]] DESC NULLS FIRST');

}

},

'attribute' => 'postDate',

'defaultDir' => 'desc',

],

[

'label' => Craft::t('app', 'Expiry Date'),

'orderBy' => 'expiryDate',

'defaultDir' => 'desc',

],

[

'label' => Craft::t('app', 'Date Created'),

'orderBy' => 'dateCreated',

'defaultDir' => 'desc',

],

[

'label' => Craft::t('app', 'Date Updated'),

'orderBy' => 'dateUpdated',

'defaultDir' => 'desc',

],

];

}

/**

* @inheritdoc

*/

protected static function defineTableAttributes(): array

{

$attributes = array_merge(parent::defineTableAttributes(), [

'section' => ['label' => Craft::t('app', 'Section')],

'type' => ['label' => Craft::t('app', 'Entry Type')],

'authors' => ['label' => Craft::t('app', 'Authors')],

'ancestors' => ['label' => Craft::t('app', 'Ancestors')],

'parent' => ['label' => Craft::t('app', 'Parent')],

'postDate' => ['label' => Craft::t('app', 'Post Date')],

'expiryDate' => ['label' => Craft::t('app', 'Expiry Date')],

'revisionNotes' => ['label' => Craft::t('app', 'Revision Notes')],

'revisionCreator' => ['label' => Craft::t('app', 'Last Edited By')],

'drafts' => ['label' => Craft::t('app', 'Drafts')],

]);

// Hide Author & Last Edited By from Craft Solo

if (Craft::$app->edition === CmsEdition::Solo) {

unset($attributes['authors'], $attributes['revisionCreator']);

}

return $attributes;

}

/**

* @inheritdoc

*/

protected static function defineDefaultTableAttributes(string $source): array

{

$attributes = ['status'];

if ($source === '*') {

$attributes[] = 'section';

}

if ($source !== 'singles') {

$attributes[] = 'postDate';

$attributes[] = 'expiryDate';

$attributes[] = 'authors';

}

$attributes[] = 'link';

return $attributes;

}

/**

* @inheritdoc

*/

protected static function defineCardAttributes(): array

{

$currentUser = Craft::$app->getUser()->getIdentity();

$attributes = array_merge(parent::defineCardAttributes(), [

'section' => [

'label' => Craft::t('app', 'Section'),

'placeholder' => fn() => Craft::t('app', 'Section'),

],

'type' => [

'label' => Craft::t('app', 'Entry Type'),

'placeholder' => fn() => Craft::t('app', 'Entry Type'),

],

'authors' => [

'label' => Craft::t('app', 'Authors'),

'placeholder' => fn() => $currentUser ? Cp::elementChipHtml($currentUser) : '',

],

'parent' => [

'label' => Craft::t('app', 'Parent'),

'placeholder' => fn() => Html::tag(

'span',

Craft::t('app', 'Parent {type} Title', ['type' => self::displayName()]),

['class' => 'card-placeholder'],

),

],

'postDate' => [

'label' => Craft::t('app', 'Post Date'),

'placeholder' => fn() => (new \DateTime())->sub(new \DateInterval('P15D')),

],

'expiryDate' => [

'label' => Craft::t('app', 'Expiry Date'),

'placeholder' => fn() => (new \DateTime())->add(new \DateInterval('P15D')),

],

'revisionNotes' => [

'label' => Craft::t('app', 'Revision Notes'),

'placeholder' => fn() => Craft::t('app', 'Revision Notes'),

],

'revisionCreator' => [

'label' => Craft::t('app', 'Last Edited By'),

'placeholder' => fn() => $currentUser ? Cp::elementChipHtml($currentUser) : '',

],

'drafts' => [

'label' => Craft::t('app', 'Drafts'),

'placeholder' => fn() => Html::tag(

'span',

Craft::t('app', 'Draft {num}', ['num' => 1]),

['class' => 'card-placeholder'],

),

],

]);

// Hide Author & Last Edited By from Craft Solo

if (Craft::$app->edition === CmsEdition::Solo) {

unset($attributes['authors'], $attributes['revisionCreator']);

}

return $attributes;

}

/**

* @inheritdoc

*/

public static function attributePreviewHtml(array $attribute): mixed

{

return match ($attribute['value']) {

'authors', 'parent', 'revisionCreator', 'drafts' => $attribute['placeholder'],

default => parent::attributePreviewHtml($attribute),

};

}

/**

* @inheritdoc

*/

public static function eagerLoadingMap(array $sourceElements, string $handle): array|null|false

{

switch ($handle) {

case 'author':

case 'authors':

$map = [];

/** @var self[] $sourceElements */

foreach ($sourceElements as $entry) {

foreach ($entry->getAuthorIds() as $authorId) {

$map[] = [

'source' => $entry->id,

'target' => $authorId,

];

}

}

return [

'elementType' => User::class,

'map' => $map,

'criteria' => [

'status' => null,

],

];

default:

return self::traitEagerLoadingMap($sourceElements, $handle);

}

}

/**

* Returns the GraphQL type name that entries should use, based on their entry type.

*

* @since 5.0.0

*/

public static function gqlTypeName(EntryType $entryType): string

{

// Don't use override data

$entryType = $entryType->original ?? $entryType;

return sprintf('%s_Entry', $entryType->handle);

}

/**

* @inheritdoc

*/

public static function gqlScopesByContext(mixed $context): array

{

/** @var Section $section */

$section = $context['section'];

return [

"sections.$section->uid",

];

}

/**

* @inheritdoc

*/

protected static function prepElementQueryForTableAttribute(ElementQueryInterface $elementQuery, string $attribute): void

{

switch ($attribute) {

case 'authors':

$elementQuery->andWith(['authors', ['status' => null]]);

break;

default:

parent::prepElementQueryForTableAttribute($elementQuery, $attribute);

}

}

/**

* @var int|null Section ID

* ---

* ```php

* echo $entry->sectionId;

* ```

* ```twig

* {{ entry.sectionId }}

* ```

*/

public ?int $sectionId = null;

/**

* @var bool Collapsed

* @since 5.0.0

*/

public bool $collapsed = false;

/**

* @var DateTime|null Post date

* ---

* ```php

* echo Craft::$app->formatter->asDate($entry->postDate, 'short');

* ```

* ```twig

* {{ entry.postDate|date('short') }}

* ```

*/

public ?DateTime $postDate = null;

/**

* @var DateTime|null Expiry date

* ---

* ```php

* if ($entry->expiryDate) {

* echo Craft::$app->formatter->asDate($entry->expiryDate, 'short');

* }

* ```

* ```twig

* {% if entry.expiryDate %}

* {{ entry.expiryDate|date('short') }}

* {% endif %}

* ```

*/

public ?DateTime $expiryDate = null;

/**

* @var bool Whether the entry was deleted along with its entry type

* @see beforeDelete()

* @internal

*/

public bool $deletedWithEntryType = false;

/**

* @var bool Whether the entry was deleted along with its section

* @see beforeDelete()

* @internal

*/

public bool $deletedWithSection = false;

/**

* @var int[] Entry author IDs

* @see getAuthorIds()

* @see setAuthorIds()

*/

private array $_authorIds;

/**

* @var int[] Original entry author IDs

* @see setAuthorIds()

*/

private array $_oldAuthorIds;

/**

* @var User[]|null Entry authors

* @see getAuthors()

* @see setAuthors()

*/

private ?array $_authors = null;

/**

* @var int|null Type ID

* @see getType()

*/

private ?int $_typeId = null;

/**

* @var int|null

*/

private ?int $_oldTypeId = null;

/**

* @var EntryType|null Entry Type

* @see getType()

*/

private ?EntryType $_type = null;

/**

* @inheritdoc

* @since 3.5.0

*/

public function init(): void

{

parent::init();

$this->_oldTypeId = $this->_typeId;

}

/**

* @inheritdoc

*/

public function attributes(): array

{

$names = array_flip($this->traitAttributes());

unset($names['deletedWithEntryType']);

unset($names['deletedWithSection']);

$names['authorId'] = true;

$names['authorIds'] = true;

$names['typeId'] = true;

return array_keys($names);

}

/**

* @inheritdoc

*/

public function extraFields(): array

{

$names = $this->traitExtraFields();

$names[] = 'author';

$names[] = 'authors';

$names[] = 'section';

$names[] = 'type';

return $names;

}

/**

* @inheritdoc

*/

public function attributeLabels(): array

{

return array_merge(parent::attributeLabels(), [

'authorIds' => Craft::t('app', '{max, plural, =1{Author} other {Authors}}', [

'max' => $this->getSection()?->maxAuthors ?? 1,

]),

'postDate' => Craft::t('app', 'Post Date'),

'expiryDate' => Craft::t('app', 'Expiry Date'),

]);

}

/**

* @inheritdoc

*/

protected function defineRules(): array

{

$rules = parent::defineRules();

$rules[] = [['sectionId', 'fieldId', 'ownerId', 'primaryOwnerId', 'typeId', 'sortOrder'], 'number', 'integerOnly' => true];

$rules[] = [['authorIds'], 'each', 'rule' => ['number', 'integerOnly' => true]];

$rules[] = [

['sectionId'],

'required',

'when' => fn() => !isset($this->fieldId),

];

$rules[] = [

['typeId'],

function(string $attribute) {

if (!$this->isEntryTypeAllowed()) {

$this->addError($attribute, Craft::t('app', '{type} entries are no longer allowed in this section. Please choose a different entry type.', [

'type' => $this->getType()->getUiLabel(),

]));

}

},

'skipOnEmpty' => false,

'when' => fn() => $this->getIsCanonical(),

'on' => self::SCENARIO_LIVE,

];

$rules[] = [['fieldId'], function(string $attribute) {

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

$this->addError($attribute, Craft::t('app', '`sectionId` and `fieldId` cannot both be set on an entry.'));

}

}];

$rules[] = [['postDate', 'expiryDate'], DateTimeValidator::class];

$rules[] = [['postDate', 'expiryDate'], DateTimeValidator::class];

$rules[] = [

['postDate'],

DateCompareValidator::class,

'operator' => '<',

'compareAttribute' => 'expiryDate',

'when' => fn() => $this->postDate && $this->expiryDate,

'on' => self::SCENARIO_LIVE,

];

$section = $this->getSection();

if ($section && $section->type !== Section::TYPE_SINGLE) {

$rules[] = [['authorIds'], 'required', 'on' => self::SCENARIO_LIVE];

$rules[] = [

['authorIds'],

ArrayValidator::class,

'max' => $section->maxAuthors,

'tooMany' => Craft::t('app', '{num, plural, =1{Only one author is} other{Up to {num, number} authors are}} allowed.', [

'num' => $section->maxAuthors,

]),

];

}

return $rules;

}

/**

* @inheritdoc

*/

public function setAttributesFromRequest(array $values): void

{

parent::setAttributesFromRequest($values);

// Did the entry type just change?

if (isset($this->_typeId, $this->_oldTypeId) && $this->_typeId !== $this->_oldTypeId) {

$this->handleChangedTypeId();

}

}

/**

* @inheritdoc

*/

protected function shouldValidateTitle(): bool

{

$entryType = $this->getType();

if (!$entryType->hasTitleField) {