2022-03-08 15:55:41 +01:00
<?php namespace ProcessWire;
/**
* An Inputfield for handling relational Page inputs
*
* Delegates the actual input control to a user-defined Inputfield derived from InputfieldSelect
*
* @method PageArray|null getSelectablePages(Page $page)
* @method PageArray findPagesCode(Page $page)
*
* Can be accessed from $this or from $field:
*
* @property int $template_id
* @property array $template_ids
* @property int $parent_id
* @property string $inputfield Inputfield class used for input
* @property string $labelFieldName Field name to use for label (note: this will be "." if $labelFieldFormat is in use).
* @property string $labelFieldFormat Formatting string for $page->getMarkup() as alternative to $labelFieldName
* @property string $findPagesCode
* @property string $findPagesSelector
* @property string $findPagesSelect Same as findPageSelector, but configured interactively with InputfieldSelector .
* @property int|bool $addable
* @property int|bool $allowUnpub
* @property int $derefAsPage
* @property-read string $inputfieldClass Public property alias of protected getInputfieldClass() method
* @property array $inputfieldClasses
*
* @method string renderAddable()
* @method void processInputAddPages(WireInputData $input)
*
* @todo make findPagesCode disabled by default
*
*/
class InputfieldPage extends Inputfield implements ConfigurableModule {
public static function getModuleInfo() {
return array(
'title' => 'Page',
2022-11-05 18:32:48 +01:00
'version' => 108,
2022-03-08 15:55:41 +01:00
'summary' => 'Select one or more pages',
'permanent' => true,
);
}
/**
* @var Inputfield|null
*
*/
protected $inputfieldWidget = null;
/**
* Default options for Inputfield classes
*
* @var array
*
*/
protected static $defaultInputfieldClasses = array(
'InputfieldSelect',
'InputfieldSelectMultiple',
'InputfieldCheckboxes',
'InputfieldRadios',
'InputfieldAsmSelect',
'InputfieldPageListSelect',
'InputfieldPageAutocomplete',
'InputfieldTextTags',
);
/**
* Default configuration values
*
* @var array
*
*/
protected static $defaultConfig = array(
'parent_id' => 0,
'template_id' => 0,
'template_ids' => array(),
'inputfield' => '',
'labelFieldName' => '',
'labelFieldFormat' => '',
'findPagesCode' => '',
'findPagesSelect' => '',
'findPagesSelector' => '',
'derefAsPage' => 0,
'addable' => 0,
'allowUnpub' => 0, // This option configured by FieldtypePage:Advanced
);
/**
* Contains true when this module is in configuration state (via it's getConfigInputfields function)
*
*/
protected $configMode = false;
/**
* True when processInput is currently processing
*
*/
protected $processInputMode = false;
/**
* True when in renderValue mode
*
* @var bool
*
*/
protected $renderValueMode = false;
/**
* PageArray of pages that were added in the request
*
* @var PageArray|null
*
*/
protected $pagesAdded;
/**
* CSS class names added to the Inputfield (will be applied to delegate Inputfield)
*
* @var array
*
*/
protected $classesAdded = array();
/**
* Construct
*
*/
public function __construct() {
$this->set('inputfieldClasses', self::$defaultInputfieldClasses);
parent::__construct();
}
/**
* Init (populate default values)
*
*/
public function init() {
foreach(self::$defaultConfig as $key => $value) {
$this->set($key, $value);
}
2022-11-05 18:32:48 +01:00
$this->attr('value', $this->wire()->pages->newPageArray());
2022-03-08 15:55:41 +01:00
parent::init();
}
/**
* Add a CSS class name (extends Inputfield::addClass)
*
* @param array|string $class
* @param string $property
* @return InputfieldPage|Inputfield
*
*/
public function addClass($class, $property = 'class') {
if($property == 'class') {
$this->classesAdded[] = $class;
}
return parent::addClass($class, $property);
}
/**
* Set an input attribute
*
* Overrides Inputfield::setAttribute() to capture 'value' attribute
*
* @param array|string $key
* @param array|int|string $value
* @return InputfieldPage|Inputfield
*
*/
public function setAttribute($key, $value) {
if($key == 'value') {
$pages = $this->wire()->pages;
if(is_string($value) || is_int($value)) {
// setting the value attr from a string, whether 1234 or 123|446|789
if(ctype_digit("$value")) {
// i.e. "1234"
$a = $pages->newPageArray();
$page = $pages->get((int) $value);
if($page->id) $a->add($page);
$value = $a;
} else if(strpos($value, '|') !== false) {
// i.e. 123|456|789
$a = $pages->newPageArray();
foreach(explode('|', $value) as $id) {
if(!ctype_digit("$id")) continue;
$page = $pages->get((int) $id);
if($page->id) $a->add($page);
}
$value = $a;
} else {
// unrecognized format
}
}
}
return parent::setAttribute($key, $value);
}
/**
* Is the given $page valid for the given $field?
*
* Note that this validates all but findPagesCode (eval) based page selections.
* This is primarily for use by FieldtypePage, but kept here since the config options
* it uses to check are part of this module's config.
*
* If false is returned and given an $editPage, a reason for the false will be populated
* to the $editPage->_isValidPage property.
*
* @param Page $page
* @param Field|InputfieldPage|string|int $field Field instance of field name (string) or ID
* @param Page $editPage Page being edited
* @return bool
* @throws WireException
*
*/
public static function isValidPage(Page $page, $field, Page $editPage = null) {
$pages = $page->wire()->pages;
$user = $page->wire()->user;
if(!$field instanceof Field && !$field instanceof InputfieldPage) {
$field = $page->wire()->fields->get($field);
if(!$field instanceof Field) throw new WireException('isValidPage requires a valid Field or field name');
}
if($editPage && $editPage->id && $page->id == $editPage->id) {
$editPage->setQuietly('_isValidPage', "Page is referencing itself and circular page reference not allowed");
return false; // prevent circular reference
}
if($pages->cloning) {
return true; // bypass check when cloning is active
}
$valid = true;
$findPagesSelector = $field->get('findPagesSelector');
if(empty($findPagesSelector)) $findPagesSelector = $field->get('findPagesSelect');
if($findPagesSelector) {
$selector = $findPagesSelector;
if($editPage && $editPage->id) $selector = self::populateFindPagesSelector($editPage, $selector);
if(!$page->matches($selector)) {
// failed in-memory check, attempt $page->count() check...
$selector .= ", id=$page->id";
if($pages->count($selector)) {
// looks like its okay
} else {
// also fails $pages->cont() check, so definitely not valid
if($editPage) {
$editPage->setQuietly('_isValidPage',
"Page $page does not match " .
($user->isSuperuser() ? "findPagesSelector: $selector" : "required selector")
);
}
$valid = false;
}
}
}
// if($field->findPagesCode) { } // we don't currently validate these
$parent_id = $field->get('parent_id');
if($parent_id && $parent_id != $page->parent_id) {
$inputfieldClass = ltrim($field->get('inputfield'), '_');
if(empty($inputfieldClass)) $inputfieldClass = 'InputfieldSelect';
if(version_compare(PHP_VERSION, '5.3.8') >= 0) {
$interfaces = wireClassImplements($inputfieldClass);
if(in_array('InputfieldPageListSelection', $interfaces)) {
// parent_id represents a root parent
$rootParent = $pages->get($parent_id);
if(!$page->parents()->has($rootParent)) $valid = false;
} else {
// parent_id represents a direct parent
$valid = false;
}
if(!$valid && $editPage) {
$editPage->setQuietly('_isValidPage', "Page $page does not have required parent $parent_id");
}
} else {
// PHP version prior to 5.3.8
// @deprecated
$reflector = new \ReflectionClass($inputfieldClass);
$valid = $reflector->implementsInterface('InputfieldPageListSelection');
}
}
$hasRequiredTemplate = true;
$template_ids = FieldtypePage::getTemplateIDs($field);
if(!empty($template_ids)) {
$hasRequiredTemplate = in_array($page->template->id, $template_ids);
}
if(!$hasRequiredTemplate) {
$valid = false;
if($editPage) {
$editPage->setQuietly('_isValidPage', "Page $page does not have required template(s): " . implode(',', $template_ids));
}
}
return $valid;
}
/**
* Execute the findPagesCode
*
* @param Page $page The page being edited
* @return PageArray (hopefully)
* @deprecated Use hook to InputfieldPage::getSelectablePages() instead
*
*/
protected function ___findPagesCode(Page $page) {
2023-03-10 19:41:40 +01:00
$pages = $this->wire()->pages; // so that it is locally scoped to the eval
2022-03-08 15:55:41 +01:00
if(empty($this->findPagesCode)) return $pages->newPageArray();
return eval($this->findPagesCode);
}
public function has($key) {
// ensures it accepts any config value (like those for delegate inputfields)
return true;
}
public function getSetting($key) {
if($key === 'inputfieldClass') return $this->getInputfieldClass();
if($key === 'template_ids') return $this->getTemplateIDs();
$value = parent::getSetting($key);
if($key === 'template_id' && empty($value)) {
$templateIDs = $this->getTemplateIDs();
if(!empty($templateIDs)) $value = reset($templateIDs);
}
return $value;
}
/**
* Return PageArray of selectable pages for this input
*
* @param Page $page The Page being edited
* @return PageArray|null
*
*/
public function ___getSelectablePages(Page $page) {
$pages = $this->wire()->pages;
2022-11-05 18:32:48 +01:00
$lockedModes = array(Inputfield::collapsedNoLocked, Inputfield::collapsedYesLocked, Inputfield::collapsedBlankLocked);
2022-03-08 15:55:41 +01:00
$statusUnder = $this->allowUnpub ? Page::statusTrash : Page::statusUnpublished;
$children = null;
$templateIDs = $this->getTemplateIDs(true);
$findPagesSelector = $this->getSetting('findPagesSelector');
if(empty($findPagesSelector)) $findPagesSelector = $this->getSetting('findPagesSelect');
if($this->configMode) {
$children = $pages->newPageArray();
} else if($this->renderValueMode || in_array($this->getSetting('collapsed'), $lockedModes)) {
$children = $this->attr('value');
// convert to PageArray if not already
if($children instanceof Page) {
$children = $children->and();
} else if(!$children instanceof PageArray) {
$children = $pages->newPageArray();
}
} else if($findPagesSelector) {
// a find() selector
2022-11-05 18:32:48 +01:00
if($this->processInputMode) {
$instance = $this;
} else if(strpos($findPagesSelector, '=page.') || strpos($findPagesSelector, '=item.')) {
$instance = $this;
} else {
$instance = null;
}
2022-03-08 15:55:41 +01:00
$selector = self::populateFindPagesSelector($page, $findPagesSelector, $instance);
2024-04-04 14:37:20 +02:00
if($templateIDs) $selector = trim("$selector, templates_id=$templateIDs", ", ");
if($this->parent_id) $selector = trim("$selector, parent_id=$this->parent_id", ", ");
2022-03-08 15:55:41 +01:00
$children = $pages->find($selector);
} else if($this->findPagesCode) {
// php statement that returns a PageArray or a Page (to represent a parent)
$children = $this->findPagesCode($page);
if($children instanceof Page) $children = $children->children(); // @teppokoivula
} else if($this->parent_id) {
$parent = $pages->get($this->parent_id);
if($parent) {
if($templateIDs) {
$children = $parent->children("templates_id=$templateIDs, check_access=0, status<$statusUnder");
} else {
$children = $parent->children("check_access=0, status<$statusUnder");
}
}
} else if($templateIDs) {
$children = $pages->find("templates_id=$templateIDs, check_access=0, status<$statusUnder");
} else {
$children = $pages->newPageArray();
}
if($children && $children->has($page)) {
$children->remove($page); // don't allow page being edited to be selected
}
return $children;
}
/**
* Return array or string of configured template IDs
*
* @param bool $getString Specify true to return a 1|2|3 style string rather than an array
* @return array|string
*
*/
public function getTemplateIDs($getString = false) {
$templateIDs = parent::getSetting('template_ids');
$templateID = parent::getSetting('template_id');
return FieldtypePage::getTemplateIDs(array($templateIDs, $templateID), $getString);
}
/**
* Populate any variables in findPagesSelector
*
* @param Page $page
* @param string $selector
* @param Inputfield $inputfield
* @return string
*
*/
protected static function populateFindPagesSelector(Page $page, $selector, $inputfield = null) {
// find variables identified by: page.field or page.field.subfield
2022-11-05 18:32:48 +01:00
if(strpos($selector, '=page.') !== false || strpos($selector, '=item.') !== false) {
// if an $inputfield is passed in, then we want to retrieve dependent values directly
// from the form, rather than from the $page
$repeaterWrappers = array(); // 0, 1, or 2+ if nested repeaters
/** @var InputfieldWrapper $form */
if($inputfield) {
// locate the $form
$n = 0;
$form = $inputfield;
do {
if($form instanceof InputfieldWrapper && $form->hasClass('InputfieldRepeaterItem')) {
$repeaterWrappers[] = $form;
}
$f = $form->getParent();
if($f) $form = $f;
if(++$n > 10) break;
} while($f && !wireInstanceOf($f, 'InputfieldForm'));
} else {
$form = null;
}
preg_match_all('/=(page|item)\.([_.a-zA-Z0-9]+)/', $selector, $matches);
2022-03-08 15:55:41 +01:00
foreach($matches[0] as $key => $tag) {
2022-11-05 18:32:48 +01:00
$type = $matches[1][$key]; // page or item
$field = $matches[2][$key];
2022-03-08 15:55:41 +01:00
$subfield = '';
if(strpos($field, '.')) list($field, $subfield) = explode('.', $field);
$value = null;
if($form && (!$subfield || $subfield == 'id')) {
// attempt to get value from the form, to account for ajax changes that would not yet be reflected on the page
2022-11-05 18:32:48 +01:00
$in = $form instanceof InputfieldWrapper ? $form->getChildByName($field) : null;
if($type === 'item' && count($repeaterWrappers)) {
// fields in repeaters use a namespaced name attribute so match by hasField instead
foreach($repeaterWrappers as $repeaterWrapper) {
/** @var InputfieldWrapper $repeaterWrapper */
$value = null;
foreach($repeaterWrapper->getAll() as $in) {
2023-03-10 19:41:40 +01:00
/** @var Inputfield $in */
2022-11-05 18:32:48 +01:00
if("$in->hasField" !== $field) continue;
$value = $in->val();
break;
}
if($value !== null) break;
}
} else if($in) {
$value = $in->attr('value');
}
}
if(is_null($value)) {
if($type === 'page' && $page instanceof RepeaterPage) {
$value = $page->getForPageRoot()->get($field);
} else {
$value = $page->get($field);
}
2022-03-08 15:55:41 +01:00
}
if(is_object($value) && $subfield) $value = $value->$subfield;
if(is_array($value)) $value = implode('|', $value);
if(!strlen("$value") && (!$subfield || $subfield == 'id')) $value = '-1'; // force fail
$selector = str_replace($tag, "=$value", $selector);
}
}
return $selector;
}
/**
* Create a page finding selector from all configured properties
*
* @param array $options
* @return string|array
*
*/
public function createFindPagesSelector(array $options = array()) {
$defaults = array(
'page' => null, // optional $page for context (for selectors where it might matter)
'findRaw' => false, // include properties only recognized by $pages->findRaw()?
'getArray' => false, // return array rather than string?
);
$options = array_merge($defaults, $options);
$id = $this->getSetting('parent_id');
if($id) {
if(is_array($id)) $id = implode('|', $id);
$selector['parent_id'] = $id;
}
$ids = $this->getTemplateIDs();
if(count($ids)) {
$selector['templates_id'] = implode('|', $ids);
} else {
$id = $this->getSetting('template_id');
if(is_array($id)) $id = implode('|', $id);
if($id) $selector['templates_id'] = $id;
}
$findPagesCode = $this->getSetting('findPagesCode');
if(strlen($findPagesCode) && $options['page'] && empty($selector['parent_id'])) {
// via teppokoivula: use findPagesCode to return single parent page
$parent = $this->findPagesCode($options['page']);
if($parent instanceof Page) $selector['parent_id'] = $parent->id;
}
$s = $this->getSetting('findPagesSelector');
if(!strlen($s)) $s = $this->getSetting('findPagesSelect');
if(strlen($s)) {
if($options['page']) $s = self::populateFindPagesSelector($options['page'], $s, $this);
// @todo getstring vs getarray
$selector['selector'] = $s;
}
if($this->getSetting('allowUnpub')) {
$selector['include'] = 'unpublished';
} else {
$selector['include'] = 'hidden';
}
if($options['findRaw']) {
$labelFieldName = $this->getSetting('labelFieldName');
$labelFieldFormat = $this->getSetting('labelFieldFormat');
if(strlen($labelFieldFormat) && $labelFieldName === '.') {
// @todo find raw does not support labelFieldFormat
$selector['field'] = "$labelFieldFormat";
} else if($labelFieldName) {
$selector['field'] = $labelFieldName == '.' ? "name" : "$labelFieldName";
} else {
$selector['field'] = 'title';
}
}
if($options['getArray']) return $selector;
$a = array();
$operatorChars = Selectors::getOperatorChars();
foreach($selector as $key => $value) {
$v = substr($value, 0, 1);
$operator = strlen($v) && isset($operatorChars[$v]) ? '' : '='; // omit operator if already in $value
$a[] = "$key$operator$value";
}
return implode(', ', $a);
}
/**
* Get a label for the given page
*
* @param Page $page
* @param bool $allowMarkup Whether or not to allow markup in the label (default=false)
* @return string
*
*/
public function getPageLabel(Page $page, $allowMarkup = false) {
$label = '';
if(strlen($this->labelFieldFormat) && $this->labelFieldName == '.') {
$label = $page->getMarkup($this->labelFieldFormat);
} else if($this->labelFieldName === '.') {
// skip
} else if($this->labelFieldName) {
$label = $page->get($this->labelFieldName);
}
2023-03-10 19:41:40 +01:00
if(!strlen("$label")) $label = $page->name;
2022-03-08 15:55:41 +01:00
if($page->hasStatus(Page::statusUnpublished)) $label .= ' ' . $this->_('(unpublished)');
2023-03-10 19:41:40 +01:00
if(!$allowMarkup) $label = $this->wire()->sanitizer->markupToLine($label);
2022-03-08 15:55:41 +01:00
return $label;
}
/**
* Get the selected Inputfield class for input (adjuted version of $this->inputfield)
*
* @return string
*
*/
protected function getInputfieldClass() {
return ltrim($this->getSetting('inputfield'), '_');
}
/**
* Get delegate Inputfield for page selection
*
* @return Inputfield|null
* @throws WireException
*
*/
public function getInputfield() {
if($this->inputfieldWidget && ((string) $this->inputfieldWidget) == $this->getInputfieldClass()) {
return $this->inputfieldWidget;
}
/** @var Inputfield $inputfield */
$inputfield = $this->wire()->modules->get($this->getInputfieldClass());
if(!$inputfield) return null;
$inputfield->set('hasField', $this->hasField);
$inputfield->set('hasInputfield', $this);
$page = $this->page;
$input = $this->wire()->input;
$process = $this->wire()->process;
if($this->derefAsPage) $inputfield->set('maxSelectedItems', 1);
2023-03-10 19:41:40 +01:00
if($process instanceof WirePageEditor) $page = $process->getPage();
2022-03-08 15:55:41 +01:00
$inputfield->attr('name', $this->attr('name'));
$inputfield->attr('id', $this->attr('id'));
$keys = array('label', 'description', 'notes', 'detail');
foreach($keys as $key) {
$value = $this->getSetting($key);
if(strlen($value)) $inputfield->set($key, $value);
}
$collapsed = $this->getSetting('collapsed');
if($collapsed == Inputfield::collapsedYesAjax ||
($collapsed == Inputfield::collapsedBlankAjax && $this->isEmpty())) {
// quick exit when possible due to ajax field, and not being time to render or process it
if($this->getParent()) {
// limit only to inputfields that have a parent, to keep out of other form contexts like Lister
$renderInputfieldAjax = $input->get('renderInputfieldAjax');
$processInputfieldAjax = $input->post('processInputfieldAjax');
if(!is_array($processInputfieldAjax)) $processInputfieldAjax = array();
if($renderInputfieldAjax != $this->attr('id') && !in_array($this->attr('id'), $processInputfieldAjax)) {
$this->inputfieldWidget = $inputfield;
return $inputfield;
}
}
}
$value = $this->attr('value');
$valueArray = array();
if($value instanceof Page) {
$valueArray[$value->id] = $value;
} else if($value instanceof PageArray) {
foreach($value as $v) {
$valueArray[$v->id] = $v;
}
}
if($inputfield instanceof InputfieldSupportsPageSelector && $inputfield->setPageSelector('') !== false) {
// Inputfield has ability to find pages with a selector
$selector = $this->createFindPagesSelector(array('page' => $page));
$inputfield->setPageSelector($selector);
if($inputfield instanceof InputfieldHasSelectableOptions) {
foreach($valueArray as $p) {
$inputfield->addOption($p->id, $this->getPageLabel($p));
}
}
} else if(method_exists($inputfield, 'addOption') || $inputfield instanceof InputfieldHasSelectableOptions) {
// All selectable options types
2022-11-05 18:32:48 +01:00
if($this->hasPage && $this->hasPage->id != $page->id && wireInstanceOf($this->hasPage, 'RepeaterPage')) {
if($this->hasField && !$page->hasField($this->hasField) && $this->hasPage->hasField($this->hasField)) {
// replace page with RepeaterPage
$page = $this->hasPage;
$inputfield->set('hasPage', $page);
}
}
2022-03-08 15:55:41 +01:00
$children = $this->getSelectablePages($page);
if($children) {
foreach($children as $child) {
$label = $this->getPageLabel($child);
$inputfield->addOption($child->id, $label);
}
}
} else {
// InputfieldPageAutocomplete or similar (older style InputfieldSupportsPageSelector)
$parent_id = $this->getSetting('parent_id');
$template_id = $this->getSetting('template_id');
$template_ids = $this->getTemplateIDs();
$findPagesCode = $this->getSetting('findPagesCode');
$findPagesSelector = $this->getSetting('findPagesSelector');
$labelFieldName = $this->getSetting('labelFieldName');
$labelFieldFormat = $this->getSetting('labelFieldFormat');
if(empty($findPagesSelector)) $findPagesSelector = $this->getSetting('findPagesSelect');
if($parent_id) {
$inputfield->set('parent_id', $parent_id);
} else if($findPagesCode) {
// @teppokoivula: use findPagesCode to return single parent page
$child = $this->findPagesCode($page);
if($child instanceof Page) $inputfield->set('parent_id', $child->id);
}
if($template_id) $inputfield->set('template_id', $template_id);
if(!empty($template_ids)) $inputfield->set('template_ids', $template_ids);
if($findPagesSelector) {
2022-11-05 18:32:48 +01:00
$inputfield->set('findPagesSelector', self::populateFindPagesSelector($page, $findPagesSelector, $this));
2022-03-08 15:55:41 +01:00
}
if(strlen($labelFieldFormat) && $labelFieldName === '.') {
$inputfield->set('labelFieldName', $labelFieldFormat);
$inputfield->set('labelFieldFormat', $labelFieldFormat);
} else {
$inputfield->set('labelFieldName', $labelFieldName == '.' ? 'name' : $labelFieldName);
$inputfield->set('labelFieldFormat', '');
}
}
if($value instanceof Page) {
$inputfield->attr('value', $value->id); // derefAsPage
} else if($inputfield instanceof InputfieldPageListSelect) {
if($value instanceof PageArray) $value = $value->first();
$inputfield->attr('value', $value);
} else if($inputfield instanceof InputfieldHasArrayValue || $inputfield instanceof InputfieldSupportsArrayValue) {
$inputfield->attr('value', array_keys($valueArray));
} else {
$inputfield->attr('value', $value);
}
// pass along any relevant configuration items
foreach($this->data as $key => $value) {
if(in_array($key, array('value', 'collapsed')) || array_key_exists($key, self::$defaultConfig)) continue;
if($key == 'required' && empty($this->data['defaultValue'])) continue; // for default value support with InputfieldSelect
$inputfield->set($key, $value);
}
$inputfield->set('allowUnpub', $this->getSetting('allowUnpub'));
$this->inputfieldWidget = $inputfield;
return $inputfield;
}
/**
* Called before render()
*
* @param Inputfield $parent
* @param bool $renderValueMode
* @return bool
*
*/
public function renderReady(Inputfield $parent = null, $renderValueMode = false) {
$this->renderValueMode = $renderValueMode;
parent::renderReady($parent, $renderValueMode);
$inputfield = $this->getInputfield();
if(!$inputfield) {
$this->error($this->_('This field needs to be configured before it can be used.'));
return false;
}
$this->addClass('InputfieldNoFocus', 'wrapClass');
return $inputfield->renderReady($this, $renderValueMode);
}
/**
* Render
*
* @return string
* @throws WireException
*
*/
public function ___render() {
$inputfield = $this->getInputfield();
if(!$inputfield) return $this->attr('name');
$classes = InputfieldWrapper::getClasses();
$class = $inputfield->className();
if(isset($classes[$class]['item_content'])) $class .= " " . $classes[$class]['item_content'];
foreach($this->classesAdded as $addClass) {
$inputfield->addClass($addClass);
}
$out = "<div class='$class'>";
$out .= $inputfield->render();
$out .= $this->renderAddable();
$findPagesSelector = $this->getSetting('findPagesSelector');
if(empty($findPagesSelector)) $findPagesSelector = $this->getSetting('findPagesSelect');
$labelFieldFormat = $this->getSetting('labelFieldFormat');
$labelFieldName = $this->getSetting('labelFieldName');
if($findPagesSelector) {
$selector = $this->wire()->sanitizer->entities($findPagesSelector);
$formatName = '';
if($this->wire()->user->hasPermission('page-edit') && strlen($labelFieldFormat) && $labelFieldName === '.') {
/** @var ProcessPageSearch $pps */
$formatName = "page_" . $this->attr('name');
try {
/** @var ProcessPageSearch $pps */
$pps = $this->wire()->modules->get('ProcessPageSearch');
$pps->setDisplayFormat($formatName, $labelFieldFormat);
} catch(\Exception $e) {
// most likely user does not have access to ProcessPageSearch
}
}
$labelFieldName = $labelFieldName == '.' ? 'name' : $labelFieldName;
$out .= "<input " .
"type='hidden' " .
"class='findPagesSelector' " .
"data-formatname='$formatName' " .
"data-label='$labelFieldName' " .
"value='$selector' />";
}
$out .= "</div>";
return $out;
}
/**
* Render the add page(s) section
*
* @return string
* @throws WireException
*
*/
protected function ___renderAddable() {
2022-11-05 18:32:48 +01:00
$pages = $this->wire()->pages;
2022-03-08 15:55:41 +01:00
$parent_id = $this->getSetting('parent_id');
$template_id = $this->getSetting('template_id');
$labelFieldName = $this->getSetting('labelFieldName');
if(!$this->getSetting('addable') || !$parent_id || !$template_id) return '';
if($labelFieldName && $labelFieldName != 'title') return '';
2022-11-05 18:32:48 +01:00
$parent = $pages->get($parent_id);
2022-03-08 15:55:41 +01:00
2022-11-05 18:32:48 +01:00
$test = $pages->newPage($template_id);
2022-03-08 15:55:41 +01:00
$test->parent = $parent;
$test->id = -1; // prevents permissions check from failing
if(!$parent->addable($test)) return '';
if(!$test->publishable()) return '';
2022-11-05 18:32:48 +01:00
$inputfield = $this->wire()->modules->get($this->getInputfieldClass());
2022-03-08 15:55:41 +01:00
if(!$inputfield) return '';
2022-11-05 18:32:48 +01:00
2022-03-08 15:55:41 +01:00
$key = "_{$this->name}_add_items";
if($inputfield instanceof InputfieldHasArrayValue || $inputfield instanceof InputfieldSupportsArrayValue) {
// multi value
$description = $this->_('Enter the titles of the items you want to add, one per line. They will be created and added to your selection when you save the page.');
$input = "<textarea id='$key' name='$key' rows='5'></textarea>";
} else {
// single value
$description = $this->_('Enter the title of the item you want to add. It will become selected when you save the page.');
$input = "<input type='text' name='$key' id='$key' />";
}
$notes = sprintf($this->_('New pages will be added to %s'), $parent->path);
$label = wireIconMarkup('plus-circle', 'fw') . $this->_('Create New');
$out =
"<div class='InputfieldPageAdd'>" .
2022-11-05 18:32:48 +01:00
"<p class='InputfieldPageAddButton'><a href='#'>$label</a></p>" .
"<p class='InputfieldPageAddItems'>" .
"<label class='description' for='$key'>$description</label>" .
"$input" .
"<span class='detail'>$notes</span>" .
"</p>" .
2022-03-08 15:55:41 +01:00
"</div>";
return $out;
}
/**
* Render non-editable value
*
* @return string
*
*/
public function ___renderValue() {
if($this->labelFieldName == '.') {
$labelFieldFormat = $this->labelFieldFormat;
$labelFieldName = 'title|name';
} else {
$labelFieldFormat = '';
$labelFieldName = $this->labelFieldName ? $this->labelFieldName : 'title';
$labelFieldName .= "|name";
}
$value = $this->attr('value');
if(is_array($value) || $value instanceof PageArray) {
$out = '<ul class="PageArray pw-bullets">';
foreach($value as $p) {
$of = $p->of();
$p->of(true);
$v = $labelFieldFormat ? $p->getText($labelFieldFormat, true, true) : $p->get($labelFieldName);
2022-11-05 18:32:48 +01:00
if(!strlen("$v")) $v = (string) $p->get('name');
2022-03-08 15:55:41 +01:00
$out .= "<li>$v</li>";
$p->of($of);
}
$out .= "</ul>";
} else if($value instanceof Page) {
$of = $value->of();
$value->of(true);
$out = $labelFieldFormat ? $value->getText($labelFieldFormat, true, true) : $value->get($labelFieldName);
2022-11-05 18:32:48 +01:00
if(!strlen("$out")) $out = (string) $value->get('name');
2022-03-08 15:55:41 +01:00
$value->of($of);
} else {
$out = $value;
}
return $out;
}
/**
* Process input
*
* @param WireInputData $input
* @return $this|Inputfield
* @throws WireException
*
*/
public function ___processInput(WireInputData $input) {
2024-04-04 14:37:20 +02:00
$process = $this->wire()->process;
2022-03-08 15:55:41 +01:00
$pages = $this->wire()->pages;
$user = $this->wire()->user;
$this->processInputMode = true;
$inputfield = $this->getInputfield();
if(!$inputfield) return $this;
$inputfield->processInput($input);
$value = $this->attr('value');
$existingValueStr = $value ? "$value" : '';
$newValue = null;
2024-04-04 14:37:20 +02:00
// the $editPage is used when InputfieldPage used without FieldtypePage
if($process instanceof WirePageEditor) {
$editPage = $process->getPage();
} else if($this->hasPage) {
$editPage = $this->hasPage;
} else {
$editPage = new Page();
}
2022-03-08 15:55:41 +01:00
if($inputfield instanceof InputfieldSupportsArrayValue) {
$value = $inputfield->getArrayValue();
} else {
$value = $inputfield->attr('value');
}
if(is_array($value)) {
$newValue = $pages->newPageArray();
foreach($value as $v) {
$id = (int) $v;
if(!$id) continue;
if($id > 0) {
// existing page
$page = $pages->get($id);
2024-04-04 14:37:20 +02:00
if(!$this->hasFieldtype && !self::isValidPage($page, $this, $editPage)) {
2022-03-08 15:55:41 +01:00
// extra validation for usage without FieldtypePage
2024-04-04 14:37:20 +02:00
$error = $editPage->get('_isValidPage');
2022-03-08 15:55:41 +01:00
if($error) $this->error($error);
continue;
} else if($page->hasStatus(Page::statusUnpublished) && !$this->getSetting('allowUnpub')) {
// disallow unpublished
$warning = sprintf($this->_('Unpublished page %1$s is not allowed in field "%2$s"'), "$page->id", $this->label);
if($user->isSuperuser()) {
$warning .= ' ' . sprintf($this->_('To allow unpublished pages, edit the “%s” field and see the setting on the “Details” tab.'), $this->name);
}
$this->warning($warning);
continue;
}
} else {
// placeholder for new page, to be sorted later
$page = $pages->newNullPage();
}
$newValue->add($page);
}
} else if($value) {
$newValue = $pages->get((int) $value);
if($newValue->hasStatus(Page::statusUnpublished) && !$this->getSetting('allowUnpub')) {
$newValue = null; // disallow unpublished
} else if($newValue && $newValue->id && !$this->hasFieldtype) {
2024-04-04 14:37:20 +02:00
if(!self::isValidPage($newValue, $this, $editPage)) {
$error = $editPage->get('_isValidPage');
2022-03-08 15:55:41 +01:00
if($error) $this->error($error);
$newValue = null;
}
}
}
if($this->derefAsPage < 1 && $newValue instanceof Page) {
// i.e. value from a PageListSelect (single) when using PageArray value
$newValuePage = $newValue;
$newValue = $pages->newPageArray();
$newValue->add($newValuePage);
}
$this->setAttribute('value', $newValue);
$this->processInputAddPages($input);
// if pages were added, re-sort them in case they were dragged to a different order
// an example of this would be when used with the InputfieldPageAutocomplete
if(count($this->pagesAdded) && is_array($value)) {
$sortedValue = $pages->newPageArray();
foreach($newValue as $page) {
if($page->id < 1) $page = $this->pagesAdded->shift();
if($page->id && !$sortedValue->has($page)) $sortedValue->add($page);
}
$newValue = $sortedValue;
$this->setAttribute('value', $newValue);
}
if("$newValue" != "$existingValueStr") {
$this->trackChange('value');
}
$this->processInputMode = false;
return $this;
}
/**
* Check for the addable pages option and process if applicable
*
* @param WireInputData $input
*
*/
protected function ___processInputAddPages($input) {
2022-11-05 18:32:48 +01:00
$pages = $this->wire()->pages;
$sanitizer = $this->wire()->sanitizer;
$this->pagesAdded = $pages->newPageArray();
2022-03-08 15:55:41 +01:00
$parent_id = $this->getSetting('parent_id');
$template_id = $this->getSetting('template_id');
2022-11-05 18:32:48 +01:00
$template = $this->wire()->templates->get((int) $template_id);
2022-03-08 15:55:41 +01:00
if(!$this->getSetting('addable') || !$parent_id || !$template_id) return;
2023-03-10 19:41:40 +01:00
$user = $this->wire()->user;
2022-03-08 15:55:41 +01:00
$key = "_{$this->name}_add_items";
2024-04-04 14:37:20 +02:00
$value = trim((string) $input->$key);
2022-03-08 15:55:41 +01:00
if(empty($value)) return;
2022-11-05 18:32:48 +01:00
$parent = $pages->get($parent_id);
2022-03-08 15:55:41 +01:00
$sort = $parent->numChildren;
$titles = explode("\n", $value);
$n = 0;
foreach($titles as $title) {
// check if there is an existing page using this title
2022-11-05 18:32:48 +01:00
$selector = "include=all, templates_id=$template_id, title=" . $sanitizer->selectorValue($title);
2022-03-08 15:55:41 +01:00
$existingPage = $parent->child($selector);
2022-11-05 18:32:48 +01:00
2022-03-08 15:55:41 +01:00
if($existingPage->id) {
// use existing page
$this->pagesAdded->add($existingPage);
if($this->value instanceof PageArray) {
$this->value->add($existingPage);
continue;
} else {
$this->value = $existingPage;
break;
}
}
// create a new page
2022-11-05 18:32:48 +01:00
$page = $pages->newPage(array(
'template' => $template,
2022-03-08 15:55:41 +01:00
'parent' => $parent,
'title' => trim($title),
'sort' => $sort++,
'id' => -1, // prevents the permissions check from failing
));
// on first iteration perform a page-context access check
if(!$n && (!$parent->addable($page) || !$page->publishable())) {
$this->error("No access to add {$page->template} pages to {$parent->path}");
break;
}
$page->id = 0;
try {
$page->save();
$this->message(sprintf($this->_('Added page %s'), $page->path));
if($this->value instanceof PageArray) $this->value->add($page);
else $this->value = $page;
$this->pagesAdded->add($page);
$this->trackChange('value');
$n++;
} catch(\Exception $e) {
$error = sprintf($this->_('Error adding page "%s"'), $page->title);
if($user->isSuperuser()) $error .= " - " . $e->getMessage();
$this->error($error);
break;
}
if($this->value instanceof Page) break;
}
}
/**
* Does this Inputfield have an empty value?
*
* @return bool
*
*/
public function isEmpty() {
$value = $this->attr('value');
if($value instanceof Page) {
// derefAsPage
return $value->id < 1;
} else if($value instanceof PageArray) {
// derefAsPageArray
if(!count($value)) return true;
} else {
// null
return true;
}
return false;
}
/**
* Get field configuration Inputfields
*
* @return InputfieldWrapper
* @throws WireException
2022-11-05 18:32:48 +01:00
* @todo move to separate config.php file
2022-03-08 15:55:41 +01:00
*
*/
public function ___getConfigInputfields() {
2022-11-05 18:32:48 +01:00
$modules = $this->wire()->modules;
2022-03-08 15:55:41 +01:00
// let the module know it's being used for configuration purposes
$this->configMode = true;
$exampleLabel = $this->_('Example:') . ' ';
$defaultLabel = ' ' . $this->_('(default)');
$inputfields = new InputfieldWrapper();
$this->wire($inputfields);
2022-11-05 18:32:48 +01:00
/** @var InputfieldFieldset $fieldset */
$fieldset = $modules->get('InputfieldFieldset');
2022-03-08 15:55:41 +01:00
$fieldset->label = $this->_('Selectable pages');
$fieldset->attr('name', '_selectable_pages');
$fieldset->description = $this->_('Use at least one of the options below to determine which pages will be selectable with this field.');
$fieldset->icon = 'files-o';
$selectablePagesFieldset = $fieldset;
/** @var InputfieldPageListSelect $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldPageListSelect');
2022-03-08 15:55:41 +01:00
$field->setAttribute('name', 'parent_id');
$field->label = $this->_('Parent');
$field->attr('value', (int) $this->parent_id);
$field->description = $this->_('Select the parent of the pages that are selectable.');
$field->required = false;
$field->icon = 'folder-open-o';
$field->collapsed = Inputfield::collapsedBlank;
$fieldset->append($field);
/** @var InputfieldSelect $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldSelect');
2022-03-08 15:55:41 +01:00
$field->setAttribute('name', 'template_id');
$field->label = $this->_('Template');
$field->description = $this->_('Select the template of the pages that are selectable. May be used instead of, or in addition to, the parent above.'); // Description for Template of selectable pages
foreach($this->templates as $template) {
$field->addOption($template->id, $template->name);
}
$template_id = $this->getSetting('template_id');
$field->attr('value', $template_id);
$field->collapsed = Inputfield::collapsedBlank;
$field->icon = 'cube';
$fieldset->append($field);
$templateIDs = $this->getTemplateIDs();
$key = array_search($template_id, $templateIDs);
if(is_int($key)) unset($templateIDs[$key]);
2022-11-05 18:32:48 +01:00
2022-03-08 15:55:41 +01:00
/** @var InputfieldAsmSelect $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldAsmSelect');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'template_ids');
$field->label = $this->_('Additional templates');
$field->description = $this->_('If you need additional templates for selectable pages, select them here.');
// $field->description .= ' ' . $this->_('This may not be supported by all input types.');
$field->icon = 'cubes';
foreach($this->templates as $template) {
$field->addOption($template->id, $template->name);
}
$field->attr('value', $templateIDs);
$field->collapsed = Inputfield::collapsedBlank;
$field->showIf = 'template_id!=0';
if(count($templateIDs) == 1 && reset($templateIDs) == $this->getSetting('template_id')) {
$field->collapsed = Inputfield::collapsedYes;
}
$fieldset->append($field);
$extra = $this->_('While this overrides parent and template selections above, those selections (if present) are still used for validation.'); // Additional notes
/** @var InputfieldSelector $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldSelector');
2022-03-08 15:55:41 +01:00
$field->description = $this->_('Add one or more fields below to create a query that finds the pages you want to make selectable.');
$field->description .= ' ' . $this->_('This creates a selector that finds pages at runtime. If you prefer to enter this manually, use the “Selector string” option below instead.');
$field->description .= ' ' . $extra;
$field->attr('name', 'findPagesSelect');
$field->label = $this->_('Custom find');
$field->attr('value', $this->get('findPagesSelect'));
//$field->collapsed = Inputfield::collapsedBlank;
$field->icon = 'search-plus';
$field->addLabel = $this->_('Add field to query');
$field->allowSystemCustomFields = true;
$field->allowSystemTemplates = true;
$field->showFieldLabels = 1;
$field->collapsed = Inputfield::collapsedBlank;
$fieldset->append($field);
/** @var InputfieldText $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldText');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'findPagesSelector');
$field->label = $this->_('Selector string');
$field->attr('value', $this->findPagesSelector);
$field->description = $this->_('If you want to find selectable pages using a ProcessWire selector, enter the selector string to find the selectable pages. This selector will be passed to a `$pages->find("your selector");` call.'); // Description for Custom selector to find selectable pages
$field->description .= ' ' . $extra;
$field->notes = $exampleLabel . $this->_('parent=/products/, template=product, sort=name'); // Example of Custom selector to find selectable pages
$field->collapsed = Inputfield::collapsedBlank;
$field->icon = 'search';
$fieldset->append($field);
if($this->findPagesCode) {
// allow only if already present, as this option is deprecated
/** @var InputfieldTextarea $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldTextarea');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'findPagesCode');
$field->attr('value', $this->findPagesCode);
$field->attr('rows', 4);
$field->description = $this->_('If you want to find selectable pages using a PHP code snippet rather than selecting a parent page or template (above) then enter the code to find the selectable pages. This statement has access to the $page and $pages API variables, where $page refers to the page being edited.'); // Description for Custom PHP to find selectable pages 1
$field->description .= ' ' . $this->_('The snippet should return either a PageArray, Page or NULL. If it returns a Page, children of that Page are used as selectable pages. Using this is optional, and if used, it overrides the parent/template/selector fields above.'); // Description for Custom PHP to find selectable pages 2
$field->description .= ' ' . $extra;
$field->description .= ' ' . $this->_('NOTE: Not compatible with PageListSelect or Autocomplete input field types.'); // Description for Custom PHP to find selectable pages 3
$field->notes = $exampleLabel . $this->_('return $page->parent->parent->children("name=locations")->first()->children();'); // Example of Custom PHP code to find selectable pages
$field->collapsed = Inputfield::collapsedBlank;
} else {
2022-11-05 18:32:48 +01:00
/** @var InputfieldMarkup $field */
$field = $modules->get('InputfieldMarkup');
2022-03-08 15:55:41 +01:00
$field->attr('name', '_findPagesCode');
$field->collapsed = Inputfield::collapsedYes;
$if = "\$event->object->" .
($this->name ? "hasField == '<strong>$this->name</strong>'" : "name == '<strong>your_field_name</strong>'");
$field->value = '<p>' .
sprintf($this->_('Add the following hook to a %s file and modify per your needs. The hook should find and return selectable pages in a PageArray.'), '<u>/site/ready.php</u>') .
"</p><pre><code>" .
"\$wire->addHookAfter('InputfieldPage::getSelectablePages', function(\$event) {" .
"\n if($if) {" .
"\n \$event->return = \$event->pages->find('<strong>your selector here</strong>');" .
"\n }" .
"\n});" .
"</code></pre>" .
"<p>" .
sprintf($this->_('If you need to know the page being edited, it is accessible from: %s'),
"<code>\$event->arguments('page');</code>") .
"</p>";
}
$field->label = $this->_('Custom PHP code');
$field->icon = 'code';
$field->showIf = 'inputfield!=InputfieldPageAutocomplete|InputfieldPageListSelect|InputfieldPageListSelectMultiple';
$fieldset->append($field);
$inputfields->append($fieldset);
/** @var InputfieldSelect $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldSelect');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'labelFieldName');
$field->label = $this->_('Label field');
$field->required = true;
$field->icon = 'thumb-tack';
$field->description = $this->_('Select the page field that you want to be used in generating the labels for each selectable page.'); // Description for Label Field
$field->notes = $this->_('Select "Custom format" if you want to specify multiple fields, or other fields you do not see above.');
$field->addOption('.', $this->_('Custom format (multiple fields)' . ' ...'));
$field->columnWidth = 50;
2022-11-05 18:32:48 +01:00
if($this->wire()->fields->get('title')) {
2022-03-08 15:55:41 +01:00
$field->addOption('title', 'title' . $defaultLabel);
$field->addOption('name', 'name');
$titleIsDefault = true;
} else {
$field->addOption('name', 'name' . $defaultLabel);
$titleIsDefault = false;
}
$field->addOption('path', 'path');
2022-11-05 18:32:48 +01:00
foreach($this->wire()->fields as $f) {
2022-03-08 15:55:41 +01:00
if(!$f->type instanceof FieldtypeText) continue;
if($f->type instanceof FieldtypeTextarea) continue;
if($titleIsDefault && $f->name == 'title') continue;
$field->addOption($f->name);
}
if(!$this->labelFieldFormat) {
if($this->labelFieldName === '.') {
// they want a custom format, but they didn't provide one
$this->labelFieldName = $titleIsDefault ? 'title' : 'name';
}
}
if(!$this->labelFieldName) {
// no label field name means we fall back to default
$this->labelFieldName = $titleIsDefault ? 'title' : 'name';
}
$field->attr('value', $this->labelFieldName);
$inputfields->append($field);
/** @var InputfieldText $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldText');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'labelFieldFormat');
$field->attr('value', $this->labelFieldFormat);
$field->label = $this->_('Custom page label format');
$field->description = $this->_('Specify one or more field names surrounded by curly {brackets} along with any additional characters, spacing or punctuation.'); // Description for custom page label format
$field->notes = $this->_('Example: {parent.title} - {title}, {date}');
$field->columnWidth = 50;
$field->showIf = 'labelFieldName=.';
$field->required = true;
$field->requiredIf = 'labelFieldName=.';
$inputfields->add($field);
if(!$this->inputfield) $this->inputfield = 'InputfieldSelect';
/** @var InputfieldSelect $field */
2022-11-05 18:32:48 +01:00
$field = $modules->get('InputfieldSelect');
2022-03-08 15:55:41 +01:00
$field->setAttribute('name', 'inputfield');
$field->setAttribute('value', $this->inputfield);
$field->label = $this->_('Input field type');
$field->description = $this->_('The type of input field (Inputfield module) that will be used to select page(s) for this field.');
2022-11-05 18:32:48 +01:00
if($this->hasFieldtype !== false) {
$field->description .= ' ' . $this->_('Select one that is consistent with your “Value type” selection on the “Details” tab for single or multiple-page selection.');
}
2022-03-08 15:55:41 +01:00
$field->notes = $this->_('After selecting an input field type and saving changes, please note that additional configuration options specific to your selection may appear directly below this.');
$field->required = true;
$field->icon = 'plug';
$inputfieldSelection = $field;
2024-04-04 14:37:20 +02:00
$options = $this->getInputfieldOptions();
$pageListTypes = $options['pageListTypes'];
2022-03-08 15:55:41 +01:00
$multiLabel = $this->_('Multiple page selection');
2024-04-04 14:37:20 +02:00
$field->addOption($this->_('Single page selection'), $options['singles']);
$field->addOption($multiLabel, $options['multiples']);
$field->addOption($multiLabel . ' (' . $this->_('sortable') . ')', $options['sortables']);
2022-11-05 18:32:48 +01:00
$inputfields->insertBefore($field, $selectablePagesFieldset);
if($this->hasFieldtype === false) {
/** @var InputfieldRadios $field */
/*
$field = $modules->get('InputfieldRadios');
$field->attr('name', 'derefAsPage');
$field->label = $this->_('Value type');
$field->addOption(FieldtypePage::derefAsPageArray,
$this->_('PageArray') . ' ' .
'[span.detail] ' . $this->_('(works for all cases but required for multiple selection)') . ' [/span]'
);
$field->addOption(FieldtypePage::derefAsPageOrNullPage,
$this->_('Page') . ' ' .
'[span.detail] ' . $this->_('(optional for single page selection)') . ' [/span]'
);
$field->attr('value', (int) $this->derefAsPage);
$inputfields->add($field);
*/
} else {
2022-03-08 15:55:41 +01:00
/** @var InputfieldMarkup $f */
2022-11-05 18:32:48 +01:00
$f = $modules->get('InputfieldMarkup');
2022-03-08 15:55:41 +01:00
$f->label = $this->_('Regarding “Page List” input types');
$f->icon = 'warning';
$f->showIf = 'inputfield=' . implode('|', $pageListTypes);
$f->value = '<p>' .
$this->_('You have selected an input type that has specific requirements.') . ' ' .
$this->_('Specify only the “Parent” option below when configuring “Selectable pages”.') . ' ' .
$this->_('Note that the parent you specify implies the root of the tree of selectable pages.') . ' ' .
$this->_('If you want to make everything selectable, then specify nothing.') .
'</p>';
$inputfields->insertAfter($f, $field);
2022-11-05 18:32:48 +01:00
/** @var InputfieldCheckbox $field */
$field = $modules->get('InputfieldCheckbox');
2022-03-08 15:55:41 +01:00
$field->attr('name', 'addable');
$field->attr('value', 1);
$field->icon = 'lightbulb-o';
$field->label = $this->_('Allow new pages to be created from field?');
$field->description = $this->_('If checked, an option to add new page(s) will also be present if the indicated requirements are met.');
$field->notes =
$this->_('1. Both a parent and template must be specified in the “Selectable pages” section above.') . "\n" .
$this->_('2. The editing user must have access to create/publish these pages.') . "\n" .
$this->_('3. The “label field” must be set to “title (default)”.');
if($this->addable) {
$field->attr('checked', 'checked');
} else {
$field->collapsed = Inputfield::collapsedYes;
}
$inputfields->append($field);
}
foreach(parent::___getConfigInputfields() as $inputfield) {
$inputfields->add($inputfield);
}
$inputfield = $this->getInputfield();
if($inputfield) {
// tell it it's under control of a parent, regardless of whether this one is hasFieldtype true or not.
2022-11-05 18:32:48 +01:00
$info = $modules->getModuleInfo($inputfield);
2022-03-08 15:55:41 +01:00
$inputfield->hasFieldtype = $this->hasFieldtype ? $this->hasFieldtype : true;
$inputfield->hasInputfield = $this;
if($inputfield instanceof InputfieldSupportsPageSelector) {
$exampleSelector = $this->createFindPagesSelector();
$inputfield->setPageSelector($exampleSelector);
}
/** @var InputfieldFieldset $fieldset */
2022-11-05 18:32:48 +01:00
$fieldset = $modules->get('InputfieldFieldset');
2022-03-08 15:55:41 +01:00
$n = 0;
foreach($inputfield->___getConfigInputfields() as $f) {
if(in_array($f->name, array('required', 'requiredIf', 'showIf', 'collapsed', 'columnWidth'))) continue;
if(array_key_exists($f->name, self::$defaultConfig)) continue;
// if we already have the given field, skip over it to avoid duplication
if($f->name && $inputfields->getChildByName($f->name)) continue;
$fieldset->add($f);
$n++;
}
if($n) {
$fieldset->label = sprintf($this->_('Settings specific to “%s”'), $info['title']);
$fieldset->icon = 'gear';
$fieldset->collapsed = Inputfield::collapsedYes;
$inClass = $inputfield->className();
$fieldset->showIf = 'inputfield=' . $inClass;
if($inClass == 'InputfieldPageAutocomplete') $fieldset->showIf .= "|_$inClass";
$inputfields->insertAfter($fieldset, $inputfieldSelection);
}
}
$this->configMode = false; // reverse what was set at the top of this function
2022-11-05 18:32:48 +01:00
2022-03-08 15:55:41 +01:00
return $inputfields;
}
2024-04-04 14:37:20 +02:00
/**
* Get options available for page selection Inputfields
*
* @return array
* @since 3.0.213
*
*/
public function getInputfieldOptions() {
$modules = $this->wire()->modules;
$singles = array();
$multiples = array();
$sortables = array();
$pageListTypes = array();
$inputfieldClasses = $this->inputfieldClasses;
if($this->hasFieldtype) $inputfieldClasses = array_merge(self::$defaultInputfieldClasses, $inputfieldClasses);
foreach($inputfieldClasses as $class) {
$module = $modules->getModule($class, array('noInit' => true));
$info = $modules->getModuleInfo($module);
$label = ucfirst((string) $info['title']);
if($module instanceof InputfieldPageListSelection) {
$pageListTypes[] = $class;
}
if($module instanceof InputfieldHasSortableValue) {
$sortables[$class] = $label;
} else if($module instanceof InputfieldHasArrayValue || $module instanceof InputfieldSupportsArrayValue) {
$multiples[$class] = $label;
} else {
$singles[$class] = $label;
}
if($class == 'InputfieldPageAutocomplete') $singles["_$class"] = $label;
}
return array(
'singles' => $singles,
'multiples' => $multiples,
'sortables' => $sortables,
'pageListTypes' => $pageListTypes,
);
}
/**
* Get recommended setups for FieldtypePage/InputfieldPage
*
* @return array
* @since 3.0.213
*
*/
public function getFieldSetups() {
$setups = array();
$options = $this->getInputfieldOptions();
$singleLabel = $this->_('Single page:');
$multiLabel = $this->_('Multiple pages:');
$sortLabel = $this->_('Multiple sortable pages:');
foreach($options['singles'] as $class => $label) {
$name = str_replace('Inputfield', '', $class);
$setups[$name] = array(
'title' => "$singleLabel $label",
'derefAsPage' => FieldtypePage::derefAsPageOrNullPage,
'inputfield' => $class,
);
}
foreach(array_merge($options['multiples'], $options['sortables']) as $class => $label) {
$name = str_replace('Inputfield', '', $class);
$label = isset($options['sortables'][$class]) ? "$sortLabel $label" : "$multiLabel $label";
$setups[$name] = array(
'title' => $label,
'derefAsPage' => FieldtypePage::derefAsPageArray,
'inputfield' => $class,
);
}
return $setups;
}
2022-03-08 15:55:41 +01:00
/**
* Get module configuration Inputfields
*
* @param array $data
* @return InputfieldWrapper
*
*/
public function getModuleConfigInputfields(array $data) {
$name = 'inputfieldClasses';
if(!isset($data[$name]) || !is_array($data[$name])) $data[$name] = self::$defaultInputfieldClasses;
$fields = $this->wire(new InputfieldWrapper());
2023-03-10 19:41:40 +01:00
$this->wire($fields);
$modules = $this->wire()->modules;
2022-03-08 15:55:41 +01:00
/** @var InputfieldAsmSelect $field */
$field = $modules->get("InputfieldAsmSelect");
$field->attr('name', $name);
foreach($modules->findByPrefix('Inputfield') as $className) {
$field->addOption($className, str_replace('Inputfield', '', $className));
}
$field->attr('value', $data[$name]);
$field->label = $this->_('Inputfield modules available for page selection');
$field->description = $this->_('Select the Inputfield modules that may be used for page selection. These should generally be Inputfields that allow you to select one or more options.'); // Description
$fields->append($field);
return $fields;
}
}
