silverstripe-tagfield/src/StringTagField.php

373 lines
8.2 KiB
PHP
Raw Normal View History

2015-05-15 12:29:17 +02:00
<?php
namespace SilverStripe\TagField;
use Iterator;
use SilverStripe\Control\Controller;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\Validator;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DataObjectInterface;
use SilverStripe\ORM\SS_List;
use SilverStripe\View\ArrayData;
use SilverStripe\View\Requirements;
2015-05-15 12:29:17 +02:00
/**
* Provides a tagging interface, storing comma-delimited tags in a DataObject string field.
*
* This is intended bridge the gap between 1.x and 2.x, and when possible TagField should be used
* instead.
*
* @package tagfield
2015-05-15 12:29:17 +02:00
* @subpackage fields
*/
2015-11-18 05:05:38 +01:00
class StringTagField extends DropdownField
{
/**
* @var array
*/
private static $allowed_actions = [
'suggest',
];
2015-11-18 05:05:38 +01:00
/**
* @var bool Triggers a write call within the saveInto function if enabled
*
* @deprecated 3.0.0
*/
private static $immediate_write_enabled = true;
2015-11-18 05:05:38 +01:00
/**
* @var bool
*/
protected $shouldLazyLoad = false;
/**
* @var int
*/
protected $lazyLoadItemLimit = 10;
/**
* @var bool
*/
protected $canCreate = true;
2015-11-18 05:05:38 +01:00
/**
* @var null|DataObject
*/
protected $record;
/**
* @var bool
*/
protected $isMultiple = true;
/** @skipUpgrade */
protected $schemaComponent = 'TagField';
2015-11-18 05:05:38 +01:00
/**
* @return bool
*/
public function getShouldLazyLoad()
{
return $this->shouldLazyLoad;
}
/**
* @param bool $shouldLazyLoad
* @return $this
2015-11-18 05:05:38 +01:00
*/
public function setShouldLazyLoad($shouldLazyLoad)
{
$this->shouldLazyLoad = $shouldLazyLoad;
return $this;
}
/**
* @return int
*/
public function getLazyLoadItemLimit()
{
return $this->lazyLoadItemLimit;
}
/**
* @param int $lazyLoadItemLimit
* @return $this
2015-11-18 05:05:38 +01:00
*/
public function setLazyLoadItemLimit($lazyLoadItemLimit)
{
$this->lazyLoadItemLimit = $lazyLoadItemLimit;
return $this;
}
2015-05-15 12:29:17 +02:00
/**
2015-11-18 05:05:38 +01:00
* @return bool
*/
public function getIsMultiple()
{
return $this->isMultiple;
}
/**
* @param bool $isMultiple
* @return $this
2015-11-18 05:05:38 +01:00
*/
public function setIsMultiple($isMultiple)
{
$this->isMultiple = $isMultiple;
return $this;
}
/**
* @return null|DataObject
*/
public function getRecord()
{
if ($this->record) {
return $this->record;
}
if ($form = $this->getForm()) {
return $form->getRecord();
}
return null;
}
/**
* @param DataObject $record
* @return $this
*/
public function setRecord(DataObject $record)
{
$this->record = $record;
return $this;
}
public function Field($properties = [])
2015-11-18 05:05:38 +01:00
{
$this->addExtraClass('ss-tag-field entwine');
2015-05-15 12:29:17 +02:00
return $this
->customise($properties)
->renderWith(TagField::class);
}
2015-11-18 05:05:38 +01:00
/**
* Provide TagField data to the JSON schema for the frontend component
*
* @return array
*/
public function getSchemaDataDefaults()
{
$schema = array_merge(
parent::getSchemaDataDefaults(),
[
'name' => $this->getName() . '[]',
'lazyLoad' => $this->getShouldLazyLoad(),
'creatable' => $this->getCanCreate(),
'multi' => $this->getIsMultiple(),
'value' => $this->formatOptions($this->Value()),
'disabled' => $this->isDisabled() || $this->isReadonly(),
]
);
if (!$this->getShouldLazyLoad()) {
$schema['options'] = $this->getOptions()->toNestedArray();
2015-11-18 05:05:38 +01:00
} else {
$schema['optionUrl'] = $this->getSuggestURL();
}
return $schema;
}
protected function formatOptions($fieldValue)
{
if (empty($fieldValue)) {
return [];
}
$formattedValue = [];
foreach ($fieldValue as $value) {
$formattedValue[] = [
'Title' => $value,
'Value' => $value,
];
}
return $formattedValue;
}
/**
* When not used in a React form factory context, this adds the schema data to SilverStripe template
* rendered attributes lists
*
* @return array
*/
public function getAttributes()
{
$attributes = parent::getAttributes();
$attributes['data-schema'] = json_encode($this->getSchemaData());
return $attributes;
2015-11-18 05:05:38 +01:00
}
/**
* @return string
*/
protected function getSuggestURL()
{
return Controller::join_links($this->Link(), 'suggest');
}
2015-11-18 05:05:38 +01:00
/**
* @return ArrayList
*/
protected function getOptions()
{
$options = ArrayList::create();
$source = $this->getSource();
if ($source instanceof Iterator) {
$source = iterator_to_array($source);
}
foreach ($source as $value) {
$options->push(
ArrayData::create([
2015-11-18 05:05:38 +01:00
'Title' => $value,
'Value' => $value,
])
2015-11-18 05:05:38 +01:00
);
}
return $options;
}
public function setValue($value, $source = null)
{
if (is_string($value)) {
2022-04-13 03:50:19 +02:00
$value = explode(',', $value ?? '');
2015-11-18 05:05:38 +01:00
}
if ($source instanceof DataObject) {
$name = $this->getName();
2022-04-13 03:50:19 +02:00
$value = explode(',', $source->$name ?? '');
2015-11-18 05:05:38 +01:00
}
if ($source instanceof SS_List) {
$value = $source->column('ID');
}
if ($value === null) {
$value = [];
}
2022-04-13 03:50:19 +02:00
return parent::setValue(array_filter($value ?? []));
2015-11-18 05:05:38 +01:00
}
public function saveInto(DataObjectInterface $record)
{
parent::saveInto($record);
$name = $this->getName();
$record->$name = $this->dataValue();
if (self::config()->get('immediate_write_enabled')) {
$record->write();
}
2015-11-18 05:05:38 +01:00
}
/**
* Ensure that arrays are imploded before being saved
*
* @return mixed|string
*/
public function dataValue()
{
return implode(',', $this->value);
}
2015-11-18 05:05:38 +01:00
/**
* Returns a JSON string of tags, for lazy loading.
*
* @param HTTPRequest $request
* @return HTTPResponse
2015-11-18 05:05:38 +01:00
*/
public function suggest(HTTPRequest $request)
2015-11-18 05:05:38 +01:00
{
$responseBody = json_encode(
['items' => $this->getTags($request->getVar('term'))]
2015-11-18 05:05:38 +01:00
);
$response = HTTPResponse::create();
2015-11-18 05:05:38 +01:00
$response->addHeader('Content-Type', 'application/json');
$response->setBody($responseBody);
return $response;
}
/**
* Returns array of arrays representing tags that partially match the given search term
2015-11-18 05:05:38 +01:00
*
* @param string $term
* @return array
*/
protected function getTags($term)
{
$items = [];
foreach ($this->getOptions() as $i => $tag) {
/** @var ArrayData $tag */
$tagValue = $tag->Value;
// Map into a distinct list (prevent duplicates)
2022-04-13 03:50:19 +02:00
if (stripos($tagValue ?? '', $term ?? '') !== false && !array_key_exists($tagValue, $items ?? [])) {
$items[$tagValue] = [
'id' => $tag->Title,
'text' => $tag->Value,
];
2015-11-18 05:05:38 +01:00
}
}
// @todo do we actually need lazy loading limits for StringTagField?
2022-04-13 03:50:19 +02:00
return array_slice(array_values($items ?? []), 0, $this->getLazyLoadItemLimit());
2015-11-18 05:05:38 +01:00
}
/**
* DropdownField assumes value will be a scalar so we must
* override validate. This only applies to Silverstripe 3.2+
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
return true;
}
/**
* @return bool
*/
public function getCanCreate()
{
return $this->canCreate;
}
/**
* @param bool $canCreate
* @return $this
*/
public function setCanCreate($canCreate)
{
$this->canCreate = $canCreate;
return $this;
}
2015-05-15 12:29:17 +02:00
}