Template

$template->getLabel($language)

Return the template label for the current (or specified) language. Falls back to $template->name when no label is set.

• Arguments: getLabel(Language|string|int|null $language = null)
• Returns: string

echo $template->getLabel(); // current language label or template name
echo $template->getLabel('spanish'); 

$template->setLabel($label, $language)

Set the template label for the default (or specified) language.

• Arguments: setLabel(string $label, Language|string|int|null $language = null)
• Returns: self
• Note: If no language is specified, the language named default is used.

$template->setLabel('Basic Page'); // default language (not necessarily current)
$template->setLabel('Página básica', 'spanish'); 

$template->getIcon($prefix)

Return the icon name used by this template, as stored in pageLabelField.

• Arguments: getIcon(bool $prefix = false)
• Returns: string — FontAwesome icon name without fa- prefix by default

$icon = $template->getIcon(); // e.g. "star"
$icon = $template->getIcon(true); // e.g. "fa-star"

$template->setIcon($icon)

Set the icon for this template. The icon is stored as part of pageLabelField.

• Arguments: setIcon(string $icon)
• Returns: $this

$template->setIcon('star'); // font-awesome icon name
$template->save();

$template->getNumPages()

Return the number of pages using this template.

• Returns: int

echo $template->getNumPages();

$template->getPageClass($withNamespace)

Get the PHP class name used for pages with this template. May differ from $template->pageClass when a custom class is auto-detected at runtime (e.g. BlogPostPage for template blog-post).

• Arguments: getPageClass(bool $withNamespace = true)
• Returns: string
• Available 3.0.152.

$class = $template->getPageClass(); // e.g. "ProcessWire\BlogPostPage"
$class = $template->getPageClass(false); // e.g. "BlogPostPage"

To create a page class that the template will use:

1. Ensure that $config->usePageClasses = true; in /site/config.php.
2. Create a PHP class file in /site/classes/ using the template name in Pascal Case followed by the word Page, e.g. template blog-post would use BlogPostPage.php
3. Create the class in the file you created above:

   <?php namespace ProcessWire;  
   class BlogPostPage extends Page {}

4. Pages using the template blog-post will now use class BlogPostPage rather than Page.

$template->editUrl($http)

Return the admin URL to edit this template's settings.

• Arguments: editUrl(bool $http = false)
• Returns: string

echo $template->editUrl(); // /processwire/setup/template/edit?id=12

Access control is enabled per-template by setting $template->useRoles = 1 and then assigning roles. When useRoles is 0 (the default), the template inherits access from the closest parent page with a template that defines access control.

$template->getRoles($type)

Return a PageArray of roles assigned to this template for the given access type.

• Arguments: getRoles(string $type = 'view')
• Returns: PageArray
• $type may be 'view' (default), 'edit', 'create', or 'add'.

$viewRoles = $template->getRoles(); // view roles
$editRoles = $template->getRoles('edit');

$template->hasRole($role, $type)

Return true if this template has the given role for the specified access type.

• Arguments: hasRole(Role|string|int $role, string $type = 'view')
• Returns: bool

if($template->hasRole('guest')) {
    // guest can view pages using this template
}
if($template->hasRole('editor', 'edit')) {
    // editors can edit
}

$template->addRole($role, $type)

Add a role to this template for the given access type. Save the template afterward.

• Arguments: addRole(Role|int|string $role, string $type = 'view')
• Returns: $this

$template->addRole('guest'); // add view access for guest
$template->addRole('editor', 'edit'); // add edit access for editor
$template->save();

$template->removeRole($role, $type)

Remove a role from this template for the given access type. Specify 'all' for $type to remove the role from every access type at once.

• Arguments: removeRole(Role|int|string $role, string $type = 'view')
• Returns: $this

$template->removeRole('editor', 'edit');
$template->removeRole('old-role', 'all'); // remove from all access types
$template->save();

$template->addPermissionByRole($permission, $role, $test)

Add a permission override that applies to users with a specific role on pages using this template. Does not affect access to the page-view or page-edit permissions managed through addRole()/removeRole() — this is for custom permission overrides.

• Arguments: addPermissionByRole(Permission|int|string $permission, Role|int|string $role, bool $test = false)
• Returns: bool — true if an update was (or would be) made, false if not.
• Specify true for $test to only test if an update would be made (see return value), without changing anything.

$template->addPermissionByRole('page-publish', 'editor');
$template->save();

$template->revokePermissionByRole($permission, $role, $test)

Revoke a permission for users with a specific role.

• Arguments: revokePermissionByRole(Permission|int|string $permission, Role|int|string $role, bool $test = false)
• Returns: bool
• Specify true for $test to only test if an update would be made (see return value), without changing anything.

Family settings control the parent/child relationships between pages.

$template->childTemplates($setValue)

Get or set the templates allowed for children of pages using this template.

• Arguments: childTemplates(array|TemplatesArray|null $setValue = null)
• Returns: TemplatesArray
• Applies only if the noChildren setting is 0 (children allowed).
• Available 3.0.153.

// Get child templates
$allowed = $template->childTemplates();
foreach($allowed as $t) echo $t->name . "\n";

// Set child templates (by name, ID, or Template object)
$template->childTemplates(['blog-post', 'event']);
$template->save();

// Allow any template for children (clear restrictions)
$template->childTemplates([]);
$template->save();

$template->parentTemplates($setValue)

Get or set the templates allowed for parents of pages using this template.

• Arguments: parentTemplates(array|TemplatesArray|null $setValue = null)
• Returns: TemplatesArray
• Applies only if the noParents setting is 0 or -1.
• Available 3.0.153.

$template->parentTemplates(['blog']); // only pages with 'blog' template may be parents
$template->save();

$template->allowNewPages()

Return true if new pages using this template may be created, based on noParents.

• Returns: bool

if($template->allowNewPages()) {
    // safe to create a new page with this template
}

$template->getParentPage($checkAccess)

Return the defined parent page for new pages using this template (based on family settings). Returns null if no parent is defined, NullPage if multiple parents match.

• Arguments: getParentPage(bool $checkAccess = false)
• Returns: Page|NullPage|null

$parent = $template->getParentPage();
if($parent && $parent->id) {
    echo "New pages go under: $parent->path";
}

$template->getParentPages($checkAccess)

Return all defined parent pages for this template.

• Arguments: getParentPages(bool $checkAccess = false)
• Returns: PageArray

$template->urlSegments($value)

Get or set the URL segments setting.

• Arguments: urlSegments(array|int|bool|string $value = '~')
• Returns: array|int — array of specific allowed segments, or 0 if disabled, or 1 if any allowed
• Omit the argument to get the current value.
• Pass an array of specific allowed segments, true/1 to allow all, or 0/false to disable.
• Segment strings may be literal or include 'regex:your-pattern' entries.

// Allow any URL segments
$template->urlSegments(1);

// Only allow specific segments
$template->urlSegments(['archive', 'feed', 'regex:[0-9]{4}']);

// Disable URL segments
$template->urlSegments(0);

$template->save();

$template->isValidUrlSegmentStr($urlSegmentStr)

Check whether a URL segment string is valid for this template's settings.

• Arguments: isValidUrlSegmentStr(string $urlSegmentStr)
• Returns: bool
• Available 3.0.186.

if($template->isValidUrlSegmentStr('foo/bar/baz')) {
    // URL segment string is permitted
}

$template->filename($filename)

Get or set the template filename. When getting, it auto-generates the path from the template name if not already set, and also detects file modifications and namespace.

• Arguments: filename(string|null $filename = null)
• Returns: string — full path to the template file
• You may pass a basename (e.g. 'home.php') or a full path. Available for setting 3.0.143.

$file = $template->filename(); // full path, e.g. /site/templates/basic-page.php
$template->filename('custom-file.php'); // use /site/templates/custom-file.php

$template->filenameExists()

Return true if the template file exists on disk.

• Returns: bool

if($template->filenameExists()) {
    // template has a PHP file
}

Template caching stores rendered page output for a specified time. A cacheTime of 0 disables caching. Negative values are reserved for external caching engines (e.g. ProCache).

Cache expiration constants

$template->cacheTime = 3600; // cache for 1 hour
$template->useCacheForUsers = 1; // cache for all users
$template->cacheExpire = Template::cacheExpireSite; // expire full cache on save
$template->save();

For a more complete page caching solution see ProCache.

Boolean-style settings that govern page behavior. All are 0 (off) by default unless noted.

$template->noTrash = 1; // pages using this template cannot be trashed
$template->noMove = 1; // pages cannot be moved
$template->noLang = 1; // single-language only, even if LanguageSupport active
$template->save();

Note: the compile option applies only if $config->templateCompile is true.

Settings that affect the admin page editor for pages using this template.

$template->getTabLabel($tab, $language)

Return the overridden label for a page editor tab, or blank if not overridden.

• Arguments: getTabLabel(string $tab, Language|string|int|null $language = null)
• Returns: string
• $tab should be 'content' or 'children'.

$label = $template->getTabLabel('content'); // blank if not overridden

$template->setTabLabel($tab, $label, $language)

Set label for a page editor tab, optionally for a specific language.

• Arguments: setTabLabel(string $tab, string $label, Language|string|int|null $language = null)
• Returns: self
• $tab should be 'content' or 'children'.

$template->setTabLabel('content', 'Main');

$template->getNameLabel($language)

Return the overridden page name input label, or blank if not overridden.

• Arguments: getNameLabel(Language|string|int|null $language = null)
• Returns: string

$template->setNameLabel($label, $language)

Set the page name input label, optionally for a specific language.

• Arguments: setNameLabel(string $label, Language|string|int|null $language = null)
• Returns: self

To remove the system flag from a template:

$template->flags = $template->flags | Template::flagSystemOverride;
$template->flags = $template->flags & ~Template::flagSystem;
$template->flags = $template->flags & ~Template::flagSystemOverride;
$template->save();