FieldtypeDynamicOptions.module

<?php namespace ProcessWire;

class FieldtypeDynamicOptions extends FieldtypeMulti implements Module {

	/**
	 * Module information
	 *
	 * @return array
	 */
	public static function getModuleInfo() {
		return array(
			'title' => 'Dynamic Options',
			'summary' => 'Fieldtype for dynamic options that are generated at runtime.',
			'version' => '0.1.8',
			'author' => 'Robin Sallis',
			'href' => 'https://github.com/Toutouwai/FieldtypeDynamicOptions',
			'icon' => 'list',
			'requires' => 'ProcessWire>=3.0.0, PHP>=5.4.0',
		);
	}

	/**
	 * Return class name of the Inputfield type for a Dynamic Options field
	 *
	 * @param Field $field Dynamic Options field
	 * @return string
	 */
	protected function getInputfieldClass(Field $field) {
		return $field->inputfield_class ?: 'InputfieldSelect';
	}

	/**
	 * Get instances of InputfieldSelect
	 *
	 * @return array
	 */
	protected function getInputfieldSelects() {
		$selects = [];
		$inputfield_modules = $this->wire()->modules->find('name^=Inputfield');
		foreach($inputfield_modules as $module) {
			if($module instanceof ModulePlaceholder) $module = $inputfield_modules->getModule($module->className(), ['noInit' => true]);
			if($module instanceof InputfieldSelect) {
				$label = str_replace('Inputfield', '', $module->className());
				$selects[$module->className()] = [
					'label' => $label,
					'single' => $module instanceof InputfieldSelectMultiple ? false : true,
				];
			}
		}
		return $selects;
	}

	/**
	 * Does this field allow only a single item?
	 *
	 * @param Field $field Dynamic Options field
	 * @return boolean
	 */
	protected function isSingle(Field $field, Page $page) {
		if($field->max_items === 1) {
			return true;
		} else {
			$selects = $this->getInputfieldSelects();
			$inputfield_class = $this->getInputfieldClass($field);
			return $selects[$inputfield_class]['single'];
		}
	}

	/**
	 * Get options for this field (intended to be hooked)
	 *
	 * @param Page $page
	 * @param Field $field
	 * @return array
	 */
	public function ___getSelectableOptions(Page $page, Field $field) {
		return [];
	}

	/**
	 * Get the Inputfield that provides input for this Fieldtype
	 *
	 * @param Page $page
	 * @param Field $field
	 * @return Inputfield
	 */
	public function getInputfield(Page $page, Field $field) {
		// Don't call hookable method when the process is ProcessField
		// because it supplies the home page as a dummy page instead of the expected edited page
		if($this->wire()->process instanceof ProcessField) {
			$options = [];
		} else {
			$options = $this->getSelectableOptions($page, $field);
		}
		$inputfield = $this->wire()->modules->get($this->getInputfieldClass($field));
		$inputfield->name = $field->name;
		foreach($options as $value => $label) {
			if(is_array($label)) {
				// Must include 'label' key
				if(!isset($label['label'])) continue;
				// Get attributes if any
				$attributes = [];
				if(isset($label['attributes']) && is_array($label['attributes'])) $attributes = $label['attributes'];
				$inputfield->addOption($value, $label['label'], $attributes);
			} else {
				$inputfield->addOption($value, $label);
			}
		}

		// If there is a max items limit
		if($this->wire()->process instanceof WirePageEditor && $field->max_items) {
			// Add limit as a data attribute (may be used by inputfield, e.g. InputfieldSelectImages)
			$inputfield->wrapAttr('data-max-items', $field->max_items);

			// Show warning if number of items exceeds maximum, but not when form is submitted
			if(!$this->wire()->input->is('post')) {
				$value = $page->getUnformatted($field->name);
				if($value) {
					$count = count($value);
					if($count > $field->max_items) {
						$field_context = $field->getContext($page);
						$inputfield->warning(sprintf($this->_('The number of items in field "%s" exceeds the limit of %d - please remove %d item(s).'), $field_context->label, $field->max_items, $count - $field->max_items));
					}
				}
			}
		}

		return $inputfield;
	}

	/**
	 * Per Fieldtype interface, return a blank value of this Fieldtype
	 *
	 * @param Page $page
	 * @param Field $field
	 * @return array
	 */
	public function getBlankValue(Page $page, Field $field) {
		return [];
	}

	/**
	 * Sanitize value for storage in a page
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param mixed $value
	 * @return array
	 */
	public function sanitizeValue(Page $page, Field $field, $value) {
		$value = (array) $value;
		$allowed_options = $this->getSelectableOptions($page, $field);
		foreach($value as $key => $item) {
			if(!isset($allowed_options[$item])) unset($value[$key]);
		}
		return $value;
	}

	/**
	 * Given an 'awake' value, as set by wakeupValue(), convert the value back to a basic type for storage in database.
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param array $value
	 * @return array
	 */
	public function ___sleepValue(Page $page, Field $field, $value) {
		// Apply max items limit if any
		if($field->max_items && count($value) > $field->max_items) {
			$value = array_slice($value, 0, $field->max_items);
			// Show warning notice in admin
			$field_context = $field->getContext($page);
			$this->wire()->warning(sprintf($this->_('Field "%s" was truncated to its limit of %d items.'), $field_context->label, $field->max_items));
		}
		return $value;
	}

	/**
	 * Format the given value for output
	 *
	 * @param Page $page Page that the value lives on
	 * @param Field $field Field that represents the value
	 * @param array $value The value to format
	 * @return string|array
	 */
	public function ___formatValue(Page $page, Field $field, $value) {
		if($field->format_as_pagefiles) {
			// Get PagefilesManager for home page
			$pm = $this->wire()->pages->get(1)->filesManager;
			foreach($value as $key => $item) {
				$pagefile = $pm->getFile($item);
				// Remove any invalid values that don't convert to a Pagefile
				if(!$pagefile) {
					unset($value[$key]);
					continue;
				}
				$value[$key] = $pagefile;
			}
		}
		// Apply max items limit if any
		if($field->max_items && count($value) > $field->max_items) {
			$value = array_slice($value, 0, $field->max_items);
		}
		// If field is "single" then the formatted value is a string
		if($this->isSingle($field, $page)) $value = reset($value);
		return $value;
	}

	/**
	 * Get Fieldtypes that are known compatible with this one
	 *
	 * @param Field $field
	 * @return Fieldtypes
	 */
	public function ___getCompatibleFieldtypes(Field $field) {
		$fieldtypes = $this->wire(new Fieldtypes());
		foreach($this->fieldtypes as $fieldtype) {
			if($fieldtype instanceof FieldtypeDynamicOptions) $fieldtypes->add($fieldtype);
		}
		return $fieldtypes;
	}

	/**
	 * Return database schema
	 *
	 * @param Field $field
	 * @return array
	 */
	public function getDatabaseSchema(Field $field) {
		$schema = parent::getDatabaseSchema($field);
		$schema['data'] = 'TEXT NOT NULL';
		$schema['keys']['data'] = 'FULLTEXT KEY data (data)';
		return $schema;
	}

	/**
	 * Method called when the field is database-queried from a selector
	 *
	 * @param DatabaseQuerySelect $query
	 * @param string $table
	 * @param string $subfield
	 * @param string $operator
	 * @param mixed $value
	 * @return DatabaseQuery|DatabaseQuerySelect
	 *
	 */
	public function getMatchQuery($query, $table, $subfield, $operator, $value) {
		if(empty($subfield) || $subfield === 'data') {
			/** @var DatabaseQuerySelectFulltext $ft */
			$ft = $this->wire(new DatabaseQuerySelectFulltext($query));
			$ft->match($table, $subfield, $operator, $value);
			return $query;
		}
		return parent::getMatchQuery($query, $table, $subfield, $operator, $value);
	}

	/**
	 * Get Inputfields needed to configure this Fieldtype
	 *
	 * @param Field $field
	 * @return InputfieldWrapper
	 */
	public function ___getConfigInputfields(Field $field) {
		/* @var InputfieldWrapper $inputfields */
		$inputfields = parent::___getConfigInputfields($field);
		$modules = $this->wire()->modules;

		/** @var InputfieldSelect $f */
		$f = $modules->get('InputfieldSelect');
		$f->name = 'inputfield_class';
		$f->label = $this->_('Inputfield type');
		$f->description = $this->_('The type of input field (Inputfield module) that will be used to select option(s) for this field.');
		$f->icon = 'plug';
		$singles = [];
		$multiples = [];
		foreach($this->getInputfieldSelects() as $class => $info) {
			if($info['single']) {
				$singles[$class] = $info['label'];
			} else {
				$multiples[$class] = $info['label'];
			}
		}
		$f->addOption($this->_('Single item selection'), $singles);
		$f->addOption($this->_('Multiple item selection'), $multiples);
		$f->value = $this->getInputfieldClass($field);
		$inputfields->add($f);

		/** @var InputfieldInteger $f */
		$f = $modules->get('InputfieldInteger');
		$f_name = 'max_items';
		$f->name = $f_name;
		$f->label = $this->_('Maximum number of items');
		$f->appendMarkup = "&nbsp; <span class='description'>" . $this->_('(a value of 0 means no limit)') . "</span>";
		$f->inputType = 'number';
		$f->defaultValue = 0;
		if($field->$f_name) {
			$f->value = $field->$f_name;
		} else {
			$f->collapsed = Inputfield::collapsedYes;
		}
		$inputfields->add($f);

		/** @var InputfieldCheckbox $f */
		$f = $modules->get('InputfieldCheckbox');
		$f_name = 'format_as_pagefiles';
		$f->name = $f_name;
		$f->label = $this->_('Format as Pagefile/Pageimage object(s)');
		$f->description = $this->_('If this field stores paths/URLs to Pagefiles/Pageimages then you can enable this option to have the formatted value be a Pagefile/Pageimage object for "single" fields or an array of Pagefile/Pageimage objects for "multiple" fields.');
		$f->collapsed = Inputfield::collapsedBlank;
		$f->checked = $field->$f_name === 1 ? 'checked' : '';
		$inputfields->add($f);

		/* @var InputfieldMarkup */
		$f = $modules->get('InputfieldMarkup');
		$f->label = $this->_('Selectable options');
		$f->description = sprintf($this->_("Add the following hook to a %s file and modify according to your needs. The hook should return an array of options as 'value' => 'label'."), '**/site/ready.php**');
		$f->value = "<pre><code>\$wire-&gt;addHookAfter('FieldtypeDynamicOptions::getSelectableOptions', function(HookEvent \$event) {
    // The page being edited
    \$page = \$event-&gtarguments(0);
    // The Dynamic Options field
    \$field = \$event-&gtarguments(1);
    if(\$field-&gtname === '$field->name') {
        // Your selectable options as 'value' => 'label'
        \$event-&gtreturn = [
            'red' =&gt 'Red',
            'green' =&gt 'Green',
            'blue' =&gt 'Blue',
        ];
    }
});</code></pre>";
		$inputfields->add($f);

		return $inputfields;
	}

}