Pages

MMO\editor\cms · 1 symbole · générée le 27 Oct 2026

class

Pages

The pages built from sections: what the backoffice does with them, whoever asks (its routes,

class MMO\editor\cms\Pages extends MMO\core\classes\aModule

Espace de noms: MMO\editor\cms
Étend: aModule
Voir: PagesController, or the application's code).

The methods taking a client first act **for** it, and check its rights: the `editor.pages` scopes of mmo.oauth, `#edit` to change a page's draft (and make or delete a page), `#publish` to publish it, take it offline or roll it back. A page's own scope narrows them: `editor.pages.{id}#edit`. A client without the right gets [`eForbidden`](https://mmoframework.fr/fr/documentation/mmo.editor/php/exceptions/eForbidden.md#eforbidden). Configuration: ```json "MMO\\editor\\cms\\Pages": { "repositories": {"main": {"$": "#repository"}}, "templates": ["{root}/templates/cms"], "revisions": 20 } ``` with the repository holding `pages` ([`Page`](https://mmoframework.fr/fr/documentation/mmo.editor/php/cms/Page.md#page)) and `pageRevisions` ([`PageRevision`](https://mmoframework.fr/fr/documentation/mmo.editor/php/cms/PageRevision.md#pagerevision)) collections. The `templates` folders hold the application's `layouts.phtml` and `sections.{phtml,schema.json}`, before mmo.editor's own (`templates/`, [`TEMPLATES`](https://mmoframework.fr/fr/documentation/mmo.editor/php/cms/Pages.md#pages-templates)).

$pages = Pages::Shared(); $page = $pages->createPage($user, ['slug' => 'home', 'title' => 'Home', 'sections' => [$pages->newSection('hero')]]); $pages->publish($user, $page);

Index

	EDIT	the right to change a page's draft, make a page, delete one
	FIELDS	the fields of a page a client sends
	PUBLISH	the right to publish a page, take it offline, roll it back
	TEMPLATES	mmo.editor's own layouts and sections, after the application's
	VERSION	the fields of a version of a page: what is published, kept as a revision, rendered (`Page::exportDraft`)
	repositories
	revisions
	scope
	templates
	types
	typesFolder
	typesScope
	authorOf($client)
	can($client, $action, $page)
	canEditTypes($client)
	check($client, $action, $page)
	checkTypes($client)
	cleanDraft($input, $page, $whole)	What a client sent for a page, made what the page holds: the html sanitized, every section checked against its type -- or nothing at all.
	cleanTranslations($languages, $sections, $translations, $errors)	What a client sent of a page's translations, made what the page holds: one per language but the default one, only their texts (`Translations::Strip`), the html sanitized, each section translated…
	cleanVersion($page, $version)	A version of a page that is not saved (a preview's), made what a draft would hold: the html sanitized, every section checked against its type.
	collection($class)
	commit($entity)	Save the changes, and make sure $entity was: a commit only says what it did not save
	createPage($client, $input)	Make a page, for $client (who needs `EDIT` on every page): its draft only, until it is published.
	deletePage($client, $page)	Delete $page and its revisions, for $client (who needs `EDIT` and `PUBLISH` on it)
	getPage($id)
	getPageBySlug($slug)
	getPageCollection()
	getPages()
	getRevisionCollection()
	getRevisions($page)
	getSectionTypes()
	getTypesFolder()
	newSection($type)
	onScopes($request)	The rights of the pages, for the screens granting scopes
	pruneRevisions($page, $new)	Keep the last `$revisions` revisions of $page, $new included: the others go, with the next commit
	publish($client, $page)	Publish the draft of $page, for $client: it becomes what visitors see, and a revision of the page.
	remove($entity)
	render($version, $mode, $document, $language)	Render a version of a page (`Page::exportDraft`, or a page's `published`)
	resetSectionTypes()	Read the types again: one was written, or removed (`SectionTypeStore`)
	rollback($client, $page, $number)	Copy the revision $number of $page into its draft, for $client (who needs `PUBLISH`): the draft it replaces is lost, what visitors see is unchanged until it is published.
	saveDraft($client, $page, $input)	Change the draft of $page, for $client: only the fields given, and only when all of them are valid.
	setRepositories($repositories)
	unpublish($client, $page)	Take $page offline, for $client: visitors no longer see it, its draft and its revisions stay

Constantes5

EDIT

the right to change a page's draft, make a page, delete one

const EDIT = 'edit'

FIELDS

the fields of a page a client sends

const FIELDS = […7 items]

PUBLISH

the right to publish a page, take it offline, roll it back

const PUBLISH = 'publish'

TEMPLATES

mmo.editor's own layouts and sections, after the application's

const TEMPLATES = '{mmo.editor}/templates'

VERSION

the fields of a version of a page: what is published, kept as a revision, rendered (Page::exportDraft)

const VERSION = ['title', 'layout', 'seo', 'sections', 'languages', 'translations']

Propriétés7

repositories

#[MMO\core\attributes\Serialize(unserialize: 'setRepositories')] protected array $repositories = []

Type: array

revisions

int $revisions = 20

Type: int

scope

string $scope = 'editor.pages'

Type: string

templates

array $templates = []

Type: array

types

#[MMO\core\attributes\Serialize(false)] protected ?MMO\editor\cms\SectionTypes $types = null

Type: null | SectionTypes

typesFolder

?string $typesFolder = null

Type: null | string

typesScope

string $typesScope = 'editor.sections'

Type: string

Méthodes31

authorOf($client)

Pages.php:443

protected function authorOf(?MMO\oauth\interfaces\iClient $client): string

$client	null \| iClient
retourne	string	what a revision says of who published it

can($client, $action, $page)

Pages.php:94

function can( ?MMO\oauth\interfaces\iClient $client, string $action, ?MMO\editor\cms\Page $page = null ): bool

$client	null \| iClient
$action	string
$page = null	null \| Page
retourne	bool	whether $client may do $action (`EDIT`, `PUBLISH`) with $page, or with every page

canEditTypes($client)

Pages.php:254

function canEditTypes(?MMO\oauth\interfaces\iClient $client): bool

$client	null \| iClient
retourne	bool	whether $client may write the site's section types (`$typesScope`)

check($client, $action, $page)

Pages.php:101

function check( ?MMO\oauth\interfaces\iClient $client, string $action, ?MMO\editor\cms\Page $page = null ): void

$client	null \| iClient
$action	string
$page = null	null \| Page
retourne	void
lève		unless $client may do $action with $page

checkTypes($client)

Pages.php:259

function checkTypes(?MMO\oauth\interfaces\iClient $client): void

$client	null \| iClient
retourne	void
lève		unless $client may write the site's section types

cleanDraft($input, $page, $whole)

Pages.php:307

What a client sent for a page, made what the page holds: the html sanitized, every section checked against its type -- or nothing at all.

protected function cleanDraft(array $input, ?MMO\editor\cms\Page $page = null, bool $whole = false): array

$input	array
$page = null	null \| Page	the page it changes, null for a new one
$whole = false	bool	true when $input is a whole version (one being published)
retourne	array	mixed>
lève		with what is wrong, field by field

cleanTranslations($languages, $sections, $translations, $errors)

Pages.php:402

What a client sent of a page's translations, made what the page holds: one per language but the default one, only their texts (Translations::Strip), the html sanitized, each section translated checked against its type.

protected function cleanTranslations(array $languages, array $sections, array $translations, array &$errors): array

$languages	array	the page's, the default one first
$sections	array
$translations	array
$errors	array
retourne	array	array<string, mixed>>

cleanVersion($page, $version)

Pages.php:292

A version of a page that is not saved (a preview's), made what a draft would hold: the html sanitized, every section checked against its type.

function cleanVersion(MMO\editor\cms\Page $page, array $version): array

$page	Page	the page it is a version of
$version	array
retourne	array	mixed>
lève		with what is wrong

collection($class)

Pages.php:460

protected function collection(string $class): MMO\core\entities\Collection

$class	string
retourne	Collection

commit($entity)

Pages.php:467

Save the changes, and make sure $entity was: a commit only says what it did not save

protected function commit(MMO\core\interfaces\iEntity $entity): void

$entity	iEntity
retourne	void

createPage($client, $input)

Pages.php:151

Make a page, for $client (who needs EDIT on every page): its draft only, until it is published.

function createPage(?MMO\oauth\interfaces\iClient $client, array $input): MMO\editor\cms\Page

$client	null \| iClient
$input	array
retourne	Page
lève		with what is wrong

deletePage($client, $page)

Pages.php:226

Delete $page and its revisions, for $client (who needs EDIT and PUBLISH on it)

function deletePage(?MMO\oauth\interfaces\iClient $client, MMO\editor\cms\Page $page): void

$client	null \| iClient
$page	Page
retourne	void

getPage($id)

Pages.php:131

function getPage(mixed $id): ?MMO\editor\cms\Page

$id	mixed
retourne	null \| Page

getPageBySlug($slug)

Pages.php:136

function getPageBySlug(string $slug): ?MMO\editor\cms\Page

$slug	string
retourne	null \| Page

getPageCollection()

Pages.php:122

function getPageCollection(): MMO\core\entities\Collection

retourne

Collection

getPages()

Pages.php:142

function getPages(): array

retourne

array

every page, by slug

getRevisionCollection()

Pages.php:127

function getRevisionCollection(): MMO\core\entities\Collection

retourne

Collection

getRevisions($page)

Pages.php:203

function getRevisions(MMO\editor\cms\Page $page): array

$page	Page
retourne	array	the revisions kept of $page, the last one first

getSectionTypes()

Pages.php:238

function getSectionTypes(): MMO\editor\cms\SectionTypes

retourne

SectionTypes

getTypesFolder()

Pages.php:248

function getTypesFolder(): ?string

retourne null | string the folder the section-type editor writes in ($typesFolder), null when there is none

newSection($type)

Pages.php:267

function newSection(string $type): array

$type	string
retourne	array	string, type: string, data: array<string, mixed>} a new section of $type, with its defaults
lève		when there is no such type

onScopes($request)

Pages.php:109

The rights of the pages, for the screens granting scopes

#[MMO\core\attributes\Listen('MMO\\oauth\\events\\ScopesList')] function onScopes(MMO\oauth\events\ScopesList $request): void

$request	ScopesList
retourne	void

pruneRevisions($page, $new)

Pages.php:437

Keep the last $revisions revisions of $page, $new included: the others go, with the next commit

protected function pruneRevisions(MMO\editor\cms\Page $page, MMO\editor\cms\PageRevision $new): void

$page	Page
$new	PageRevision
retourne	void

publish($client, $page)

Pages.php:180

Publish the draft of $page, for $client: it becomes what visitors see, and a revision of the page.

function publish(?MMO\oauth\interfaces\iClient $client, MMO\editor\cms\Page $page): MMO\editor\cms\PageRevision

$client	null \| iClient
$page	Page
retourne	PageRevision
lève		when the draft is no longer valid (a section type that went away...)

remove($entity)

Pages.php:448

protected function remove(MMO\core\interfaces\iEntity $entity): void

$entity	iEntity
retourne	void

render($version, $mode, $document, $language)

Pages.php:279

Render a version of a page (Page::exportDraft, or a page's published)

function render( array $version, string $mode = MMO\editor\cms\PageRenderer::PUBLIC, ?MMO\core\documents\HtmlDocument $document = null, ?string $language = null ): MMO\core\documents\HtmlDocument

$version	array
$mode = MMO\editor\cms\PageRenderer::PUBLIC	string	`PageRenderer::PUBLIC`, PREVIEW, EDIT
$document = null	null \| HtmlDocument
$language = null	null \| string	one of the version's `languages`: its texts translated, the default language's where they are not (`Translations::Version`); null: the default language
retourne	HtmlDocument

resetSectionTypes()

Pages.php:243

Read the types again: one was written, or removed (SectionTypeStore)

function resetSectionTypes(): void

retourne

void

rollback($client, $page, $number)

Pages.php:212

Copy the revision $number of $page into its draft, for $client (who needs PUBLISH): the draft it replaces is lost, what visitors see is unchanged until it is published.

function rollback( ?MMO\oauth\interfaces\iClient $client, MMO\editor\cms\Page $page, int $number ): MMO\editor\cms\Page

$client	null \| iClient
$page	Page
$number	int
retourne	Page
lève		(404) when the page has no such revision (any more)

saveDraft($client, $page, $input)

Pages.php:168

Change the draft of $page, for $client: only the fields given, and only when all of them are valid. The html of the sections is sanitized, the sections without an id get one.

function saveDraft( ?MMO\oauth\interfaces\iClient $client, MMO\editor\cms\Page $page, array $input ): MMO\editor\cms\Page

$client	null \| iClient
$page	Page
$input	array
retourne	Page
lève		with what is wrong, leaving the page as it was

setRepositories($repositories)

Pages.php:84

function setRepositories(array $repositories): void

$repositories	array
retourne	void

unpublish($client, $page)

Pages.php:195

Take $page offline, for $client: visitors no longer see it, its draft and its revisions stay

function unpublish(?MMO\oauth\interfaces\iClient $client, MMO\editor\cms\Page $page): MMO\editor\cms\Page

$client	null \| iClient
$page	Page
retourne	Page

Membres hérités (48)

Constantes	Déclaré par	Description
`ALERT`	iLogLevel	Alert: Action must be taken immediately.
`ALL`	iLogLevel	Mask for all
`ALL_PLUS`	iLogLevel	debug everything
`BACKTRACE`	iLogLevel
`CRITICAL`	iLogLevel	Critical: Critical conditions.
`DEBUG`	iLogLevel	Debug: Detailed debug information.
`DEEP`	iLogLevel	debug everything with arguments
`EMERGENCY`	iLogLevel	Emergency: System is unusable.
`ERROR`	iLogLevel	Error: Runtime errors that do not require immediate action but should typically be logged and monitored.
`ERROR_PLUS`	iLogLevel	Mask for all error
`FATAL`	iLogLevel	Mask for all fatal error
`INFO`	iLogLevel	Info: Interesting events.
`INFO_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`MEMORY`	iLogLevel	include backtrace object
`NOTICE`	iLogLevel	Notice: Normal but significant events.
`NOTICE_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`TRACE`	iLogLevel	include backtrace as origins
`WARNING`	iLogLevel	Warning: Exceptional occurrences that are not errors.
`WARNING_PLUS`	iLogLevel	Mask for all errors and warnings

	Propriétés	Déclaré par	Description
	`verbosity`	aModule

Méthodes	Déclaré par	Description
`alert($message, $context)`	aModule	Action must be taken immediately.
`backtraces($message, $context)`	aModule	Force-log a message at INFO level together with a full stack trace/memory snapshot (`iLogLevel::BACKTRACE`), bypassing the verbosity mask entirely (any non-zero verbosity is enough to trigger it).
`Configure($config)`	aModule	Merge $config into this module's configuration in the shared `Configuration`.
`critical($message, $context)`	aModule	Critical conditions. No-op if CRITICAL is currently filtered out by the verbosity mask.
`debug($message, $context)`	aModule	Detailed debug information.
`debugName()`	aModule	Human-readable identifier used as the default `{origin}` in this instance's log messages.
`DefaultConfig()`	aModule	The config a module starts from before anything loaded via `Configuration` is merged in.
`emergency($message, $context)`	aModule	System is unusable. No-op if EMERGENCY is currently filtered out by the verbosity mask.
`error($message, $context)`	aModule	Runtime errors that do not require immediate action but should typically be logged and monitored.
`getVerbosity()`	aModule
`info($message, $context)`	aModule	Interesting events. No-op if INFO is currently filtered out by the verbosity mask.
`Instantiate($config)`	aModule	(Re)create the shared instance immediately, configured with $config merged into the class's existing config.
`IsShared()`	aModule
`log($level, $message, $context)`	aModule	Logs with an arbitrary level.
`notice($message, $context)`	aModule	Normal but significant events.
`offsetExists($key)`	aModule	\ArrayAccess::offsetExists -- tells whether $key is a declared property at all, regardless of whether it is currently readable/writable through array access.
`offsetGet($key)`	aModule	\ArrayAccess::offsetGet -- reads a property directly, unless it has a `#[Serialize(serialize: 'methodName')]` attribute, in which case that zero-argument method is called instead (e.g.
`offsetSet($key, $value)`	aModule	\ArrayAccess::offsetSet -- sets a property directly, unless it has a `#[Serialize(unserialize: 'methodName')]` attribute, in which case that method is called with $value instead (e.g.
`offsetUnset($key)`	aModule	\ArrayAccess::offsetUnset -- equivalent to `$module[$key] = null`.
`serialize($path, $serializer)`	aModule	\MMO\core\interfaces\iSerializable::serialize -- exports every property (via
`setVerbosity($verb)`	aModule	Set the current verbosity mask, replacing whatever it was before.
`Shared()`	aModule	Get the shared instance, creating (and configuring) it on first call.
`testVerbosity($level)`	aModule	Test whether a given level (or set of levels) is currently enabled by this instance's verbosity mask.
`traitUnshare($serialize)`	aModule	Remove the shared instance, so the next `Shared()` call creates a fresh one.
`unserialize($data, $path, $instances)`	aModule	\MMO\core\interfaces\iSerializable::unserialize -- merges $data onto `DefaultConfig`, runs it through the (possibly overridden) constructor, then applies each resulting value to its property (via
`Unshare($serialize)`	aModule	Like `tSingleton::Unshare`, but also disconnects this module's instance from every event it was listening to (via `Event::DisconnectListeners`) before dropping it.
`warning($message, $context)`	aModule	Exceptional occurrences that are not errors.
`__construct($config)`	aModule	protected constructor, so it is not possible to do `new Module(...)` called by the serialization process just before being injected with data.