silverstripe-framework/forms/gridfield/GridField.php

961 lines
24 KiB
PHP
Raw Normal View History

<?php
2015-04-17 02:07:51 +02:00
/**
* Displays a {@link SS_List} in a grid format.
2015-04-17 02:07:51 +02:00
*
* GridField is a field that takes an SS_List and displays it in an table with rows
* and columns. It reminds of the old TableFields but works with SS_List types
* and only loads the necessary rows from the list.
2015-04-17 02:07:51 +02:00
*
* The minimum configuration is to pass in name and title of the field and a
* SS_List.
2015-04-17 02:07:51 +02:00
*
* <code>
* $gridField = new GridField('ExampleGrid', 'Example grid', new DataList('Page'));
* </code>
2015-04-17 02:07:51 +02:00
*
* @see SS_List
2015-04-17 02:07:51 +02:00
*
* @package forms
* @subpackage fields-gridfield
*/
class GridField extends FormField {
2015-04-17 02:07:51 +02:00
/**
*
* @var array
*/
private static $allowed_actions = array(
'index',
'gridFieldAlterAction'
);
2015-04-17 02:07:51 +02:00
/**
* The datasource
2015-04-17 02:07:51 +02:00
*
* @var SS_List
*/
protected $list = null;
/**
* The classname of the DataObject that the GridField will display. Defaults to the value of $this->list->dataClass
2015-04-17 02:07:51 +02:00
*
* @var string
*/
protected $modelClassName = '';
/**
* the current state of the GridField
2015-04-17 02:07:51 +02:00
*
* @var GridState
*/
protected $state = null;
2015-04-17 02:07:51 +02:00
/**
*
* @var GridFieldConfig
*/
protected $config = null;
2015-04-17 02:07:51 +02:00
/**
* The components list
*
* @var array
*/
protected $components = array();
2015-04-17 02:07:51 +02:00
/**
* Internal dispatcher for column handlers.
* Keys are column names and values are GridField_ColumnProvider objects
2015-04-17 02:07:51 +02:00
*
* @var array
*/
protected $columnDispatch = null;
2015-04-17 02:07:51 +02:00
/**
* Map of callbacks for custom data fields
*
* @var array
*/
protected $customDataFields = array();
/**
* @var string
*/
protected $name = '';
/**
* Creates a new GridField field
*
* @param string $name
* @param string $title
* @param SS_List $dataList
* @param GridFieldConfig $config
*/
public function __construct($name, $title = null, SS_List $dataList = null, GridFieldConfig $config = null) {
parent::__construct($name, $title, null);
$this->name = $name;
if($dataList) {
$this->setList($dataList);
}
$this->setConfig($config ?: GridFieldConfig_Base::create());
$this->config->addComponent(new GridState_Component());
2015-04-17 02:07:51 +02:00
$this->state = new GridState($this);
$this->addExtraClass('ss-gridfield');
}
public function index($request) {
return $this->gridFieldAlterAction(array(), $this->getForm(), $request);
}
2015-04-17 02:07:51 +02:00
/**
* Set the modelClass (dataobject) that this field will get it column headers from.
* If no $displayFields has been set, the displayfields will be fetched from
* this modelclass $summary_fields
2015-04-17 02:07:51 +02:00
*
* @param string $modelClassName
2015-04-17 02:07:51 +02:00
*
* @see GridFieldDataColumns::getDisplayFields()
*/
public function setModelClass($modelClassName) {
$this->modelClassName = $modelClassName;
return $this;
}
2015-04-17 02:07:51 +02:00
/**
* Returns a dataclass that is a DataObject type that this GridField should look like.
2015-04-17 02:07:51 +02:00
*
* @throws Exception
* @return string
*/
public function getModelClass() {
2015-04-17 02:07:51 +02:00
if($this->modelClassName) return $this->modelClassName;
if($this->list && method_exists($this->list, 'dataClass')) {
$class = $this->list->dataClass();
if($class) return $class;
}
throw new LogicException('GridField doesn\'t have a modelClassName,'
. ' so it doesn\'t know the columns of this grid.');
}
/**
* Get the GridFieldConfig
*
* @return GridFieldConfig
*/
public function getConfig() {
return $this->config;
}
/**
* @param GridFieldConfig $config
2015-04-17 02:07:51 +02:00
*
* @return GridField
*/
public function setConfig(GridFieldConfig $config) {
$this->config = $config;
return $this;
}
public function getComponents() {
return $this->config->getComponents();
}
2015-04-17 02:07:51 +02:00
/**
* Cast a arbitrary value with the help of a castingDefintion
2015-04-17 02:07:51 +02:00
*
* @param $value
* @param $castingDefinition
2015-04-17 02:07:51 +02:00
*
* @todo refactor this into GridFieldComponent
*/
public function getCastedValue($value, $castingDefinition) {
if(is_array($castingDefinition)) {
$castingParams = $castingDefinition;
array_shift($castingParams);
$castingDefinition = array_shift($castingDefinition);
} else {
$castingParams = array();
}
2015-04-17 02:07:51 +02:00
if(strpos($castingDefinition, '->') === false) {
$castingFieldType = $castingDefinition;
$castingField = DBField::create_field($castingFieldType, $value);
2015-04-17 02:07:51 +02:00
$value = call_user_func_array(array($castingField, 'XML'), $castingParams);
} else {
$fieldTypeParts = explode('->', $castingDefinition);
2015-04-17 02:07:51 +02:00
$castingFieldType = $fieldTypeParts[0];
$castingMethod = $fieldTypeParts[1];
$castingField = DBField::create_field($castingFieldType, $value);
2015-04-17 02:07:51 +02:00
$value = call_user_func_array(array($castingField, $castingMethod), $castingParams);
}
2015-04-17 02:07:51 +02:00
return $value;
2015-04-17 02:07:51 +02:00
}
/**
* Set the datasource
*
* @param SS_List $list
*/
public function setList(SS_List $list) {
$this->list = $list;
return $this;
}
/**
* Get the datasource
*
* @return SS_List
*/
public function getList() {
return $this->list;
}
/**
* Get the datasource after applying the {@link GridField_DataManipulator}s to it.
*
* @return SS_List
*/
public function getManipulatedList() {
$list = $this->getList();
foreach($this->getComponents() as $item) {
if($item instanceof GridField_DataManipulator) {
$list = $item->getManipulatedData($this, $list);
}
}
return $list;
}
2015-04-17 02:07:51 +02:00
/**
* Get the current GridState_Data or the GridState
*
* @param bool $getData - flag for returning the GridState_Data or the GridState
*
* @return GridState_data|GridState
*/
public function getState($getData = true) {
if($getData) {
return $this->state->getData();
}
return $this->state;
}
/**
* Returns the whole gridfield rendered with all the attached components
*
* @return string
*/
public function FieldHolder($properties = array()) {
Requirements::css(THIRDPARTY_DIR . '/jquery-ui-themes/smoothness/jquery-ui.css');
Requirements::css(FRAMEWORK_DIR . '/css/GridField.css');
Requirements::javascript(THIRDPARTY_DIR . '/jquery/jquery.js');
Requirements::javascript(FRAMEWORK_DIR . '/thirdparty/jquery-ui/jquery-ui.js');
Requirements::javascript(THIRDPARTY_DIR . '/json-js/json2.js');
Requirements::javascript(FRAMEWORK_DIR . '/javascript/i18n.js');
Requirements::add_i18n_javascript(FRAMEWORK_DIR . '/javascript/lang');
Requirements::javascript(THIRDPARTY_DIR . '/jquery-entwine/dist/jquery.entwine-dist.js');
Requirements::javascript(FRAMEWORK_DIR . '/javascript/GridField.js');
// Get columns
$columns = $this->getColumns();
// Get data
$list = $this->getManipulatedList();
2015-04-17 02:07:51 +02:00
// Render headers, footers, etc
$content = array(
"before" => "",
"after" => "",
"header" => "",
"footer" => "",
);
2015-04-17 02:07:51 +02:00
foreach($this->getComponents() as $item) {
if($item instanceof GridField_HTMLProvider) {
$fragments = $item->getHTMLFragments($this);
if($fragments) foreach($fragments as $k => $v) {
$k = strtolower($k);
if(!isset($content[$k])) $content[$k] = "";
$content[$k] .= $v . "\n";
}
}
}
foreach($content as $k => $v) {
$content[$k] = trim($v);
}
// Replace custom fragments and check which fragments are defined
// Nested dependencies are handled by deferring the rendering of any content item that
// Circular dependencies are detected by disallowing any item to be deferred more than 5 times
// It's a fairly crude algorithm but it works
2015-04-17 02:07:51 +02:00
$fragmentDefined = array('header' => true, 'footer' => true, 'before' => true, 'after' => true);
reset($content);
2015-04-17 02:07:51 +02:00
while(list($k, $v) = each($content)) {
if(preg_match_all('/\$DefineFragment\(([a-z0-9\-_]+)\)/i', $v, $matches)) {
foreach($matches[1] as $match) {
$fragmentName = strtolower($match);
$fragmentDefined[$fragmentName] = true;
$fragment = isset($content[$fragmentName]) ? $content[$fragmentName] : "";
// If the fragment still has a fragment definition in it, when we should defer this item until
// later.
if(preg_match('/\$DefineFragment\(([a-z0-9\-_]+)\)/i', $fragment, $matches)) {
// If we've already deferred this fragment, then we have a circular dependency
if(isset($fragmentDeferred[$k]) && $fragmentDeferred[$k] > 5) {
2015-04-17 02:07:51 +02:00
throw new LogicException("GridField HTML fragment '$fragmentName' and '$matches[1]' " .
"appear to have a circular dependency.");
}
2015-04-17 02:07:51 +02:00
// Otherwise we can push to the end of the content array
unset($content[$k]);
$content[$k] = $v;
if(!isset($fragmentDeferred[$k])) {
$fragmentDeferred[$k] = 1;
} else {
$fragmentDeferred[$k]++;
}
break;
} else {
$content[$k] = preg_replace('/\$DefineFragment\(' . $fragmentName . '\)/i', $fragment,
$content[$k]);
}
}
}
}
// Check for any undefined fragments, and if so throw an exception
// While we're at it, trim whitespace off the elements
foreach($content as $k => $v) {
if(empty($fragmentDefined[$k])) {
throw new LogicException("GridField HTML fragment '$k' was given content,"
2015-04-17 02:07:51 +02:00
. " but not defined. Perhaps there is a supporting GridField component you need to add?");
}
}
$total = count($list);
if($total > 0) {
$rows = array();
foreach($list as $idx => $record) {
if($record->hasMethod('canView') && !$record->canView()) {
continue;
}
$rowContent = '';
foreach($this->getColumns() as $column) {
$colContent = $this->getColumnContent($record, $column);
2015-04-17 02:07:51 +02:00
// A return value of null means this columns should be skipped altogether.
2015-04-17 02:07:51 +02:00
if($colContent === null) {
continue;
}
$colAttributes = $this->getColumnAttributes($record, $column);
2015-04-17 02:07:51 +02:00
$rowContent .= $this->newCell($total, $idx, $record, $colAttributes, $colContent);
}
2015-04-17 02:07:51 +02:00
$rowAttributes = $this->getRowAttributes($total, $idx, $record);
$rows[] = $this->newRow($total, $idx, $record, $rowAttributes, $rowContent);
}
$content['body'] = implode("\n", $rows);
2015-04-17 02:07:51 +02:00
}
// Display a message when the grid field is empty
if(!(isset($content['body']) && $content['body'])) {
$content['body'] = FormField::create_tag(
'tr',
array("class" => 'ss-gridfield-item ss-gridfield-no-items'),
FormField::create_tag(
'td',
array('colspan' => count($columns)),
_t('GridField.NoItemsFound', 'No items found')
)
);
}
// Turn into the relevant parts of a table
$head = $content['header']
? FormField::create_tag('thead', array(), $content['header'])
: '';
$body = $content['body']
? FormField::create_tag('tbody', array('class' => 'ss-gridfield-items'), $content['body'])
: '';
$foot = $content['footer']
? FormField::create_tag('tfoot', array(), $content['footer'])
: '';
$this->addExtraClass('ss-gridfield field');
$attrs = array_diff_key(
2015-04-17 02:07:51 +02:00
$this->getAttributes(),
array('value' => false, 'type' => false, 'name' => false)
);
$attrs['data-name'] = $this->getName();
$tableAttrs = array(
'id' => isset($this->id) ? $this->id : null,
'class' => 'ss-gridfield-table',
2012-01-10 01:05:20 +01:00
'cellpadding' => '0',
2015-04-17 02:07:51 +02:00
'cellspacing' => '0'
);
if($this->getDescription()) {
$content['after'] .= FormField::create_tag(
2015-04-17 02:07:51 +02:00
'span',
array('class' => 'description'),
$this->getDescription()
);
}
return
2015-04-17 02:07:51 +02:00
FormField::create_tag('fieldset', $attrs,
$content['before'] .
2015-04-17 02:07:51 +02:00
FormField::create_tag('table', $tableAttrs, $head . "\n" . $foot . "\n" . $body) .
$content['after']
);
}
2015-04-17 02:07:51 +02:00
/**
* @param int $total
* @param int $index
* @param DataObject $record
* @param array $attributes
* @param string $content
*
* @return string
*/
protected function newCell($total, $index, $record, $attributes, $content) {
2015-04-17 02:07:51 +02:00
return FormField::create_tag(
'td',
$attributes,
$content
);
}
/**
* @param int $total
* @param int $index
* @param DataObject $record
* @param array $attributes
* @param string $content
*
* @return string
*/
protected function newRow($total, $index, $record, $attributes, $content) {
return FormField::create_tag(
'tr',
$attributes,
$content
);
}
/**
* @param int $total
* @param int $index
* @param DataObject $record
*
* @return array
*/
protected function getRowAttributes($total, $index, $record) {
$rowClasses = $this->newRowClasses($total, $index, $record);
return array(
'class' => implode(' ', $rowClasses),
'data-id' => $record->ID,
'data-class' => $record->ClassName,
);
}
/**
* @param int $total
* @param int $index
* @param DataObject $record
*
* @return array
*/
protected function newRowClasses($total, $index, $record) {
2015-04-17 02:07:51 +02:00
$classes = array('ss-gridfield-item');
if($index == 0) {
$classes[] = 'first';
}
if($index == $total - 1) {
$classes[] = 'last';
}
$classes[] = ($index % 2) ? 'even' : 'odd';
return $classes;
2015-04-17 02:07:51 +02:00
}
public function Field($properties = array()) {
return $this->FieldHolder($properties);
2012-03-08 07:11:51 +01:00
}
public function getAttributes() {
return array_merge(parent::getAttributes(), array('data-url' => $this->Link()));
}
/**
* Get the columns of this GridField, they are provided by attached GridField_ColumnProvider
*
* @return array
*/
public function getColumns() {
// Get column list
$columns = array();
foreach($this->getComponents() as $item) {
if($item instanceof GridField_ColumnProvider) {
$item->augmentColumns($this, $columns);
}
}
return $columns;
}
/**
* Get the value from a column
*
* @param DataObject $record
* @param string $column
2015-04-17 02:07:51 +02:00
*
* @return string
* @throws InvalidArgumentException
*/
public function getColumnContent($record, $column) {
// Build the column dispatch
if(!$this->columnDispatch) {
$this->buildColumnDispatch();
}
2015-04-17 02:07:51 +02:00
if(!empty($this->columnDispatch[$column])) {
$content = "";
foreach($this->columnDispatch[$column] as $handler) {
$content .= $handler->getColumnContent($this, $record, $column);
}
return $content;
} else {
throw new InvalidArgumentException("Bad column '$column'");
}
}
2015-04-17 02:07:51 +02:00
/**
* Add additional calculated data fields to be used on this GridField
*
* @param array $fields a map of fieldname to callback. The callback will
2015-04-17 02:07:51 +02:00
* be passed the record as an argument.
*/
public function addDataFields($fields) {
if($this->customDataFields) {
$this->customDataFields = array_merge($this->customDataFields, $fields);
} else {
$this->customDataFields = $fields;
}
}
2015-04-17 02:07:51 +02:00
/**
* Get the value of a named field on the given record.
* Use of this method ensures that any special rules around the data for this gridfield are followed.
*/
public function getDataFieldValue($record, $fieldName) {
// Custom callbacks
if(isset($this->customDataFields[$fieldName])) {
$callback = $this->customDataFields[$fieldName];
return $callback($record);
}
2015-04-17 02:07:51 +02:00
// Default implementation
if($record->hasMethod('relField')) {
return $record->relField($fieldName);
} elseif($record->hasMethod($fieldName)) {
return $record->$fieldName();
} else {
return $record->$fieldName;
}
}
/**
* Get extra columns attributes used as HTML attributes
*
* @param DataObject $record
* @param string $column
2015-04-17 02:07:51 +02:00
*
* @return array
* @throws LogicException
* @throws InvalidArgumentException
*/
public function getColumnAttributes($record, $column) {
// Build the column dispatch
if(!$this->columnDispatch) {
$this->buildColumnDispatch();
}
2015-04-17 02:07:51 +02:00
if(!empty($this->columnDispatch[$column])) {
$attrs = array();
foreach($this->columnDispatch[$column] as $handler) {
$column_attrs = $handler->getColumnAttributes($this, $record, $column);
if(is_array($column_attrs)) {
$attrs = array_merge($attrs, $column_attrs);
} elseif($column_attrs) {
$methodSignature = get_class($handler) . "::getColumnAttributes()";
throw new LogicException("Non-array response from $methodSignature.");
}
}
return $attrs;
} else {
throw new InvalidArgumentException("Bad column '$column'");
}
}
/**
* Get metadata for a column, example array('Title'=>'Email address')
*
* @param string $column
2015-04-17 02:07:51 +02:00
*
* @return array
* @throws LogicException
* @throws InvalidArgumentException
*/
public function getColumnMetadata($column) {
// Build the column dispatch
if(!$this->columnDispatch) {
$this->buildColumnDispatch();
}
2015-04-17 02:07:51 +02:00
if(!empty($this->columnDispatch[$column])) {
$metadata = array();
foreach($this->columnDispatch[$column] as $handler) {
$column_metadata = $handler->getColumnMetadata($this, $column);
2015-04-17 02:07:51 +02:00
if(is_array($column_metadata)) {
$metadata = array_merge($metadata, $column_metadata);
} else {
$methodSignature = get_class($handler) . "::getColumnMetadata()";
throw new LogicException("Non-array response from $methodSignature.");
}
2015-04-17 02:07:51 +02:00
}
2015-04-17 02:07:51 +02:00
return $metadata;
}
throw new InvalidArgumentException("Bad column '$column'");
}
/**
* Return how many columns the grid will have
*
* @return int
*/
public function getColumnCount() {
// Build the column dispatch
if(!$this->columnDispatch) $this->buildColumnDispatch();
2015-04-17 02:07:51 +02:00
return count($this->columnDispatch);
}
/**
* Build an columnDispatch that maps a GridField_ColumnProvider to a column
* for reference later
2015-04-17 02:07:51 +02:00
*
*/
protected function buildColumnDispatch() {
$this->columnDispatch = array();
foreach($this->getComponents() as $item) {
if($item instanceof GridField_ColumnProvider) {
$columns = $item->getColumnsHandled($this);
foreach($columns as $column) {
$this->columnDispatch[$column][] = $item;
}
}
}
}
/**
* This is the action that gets executed when a GridField_AlterAction gets clicked.
*
* @param array $data
2015-04-17 02:07:51 +02:00
*
* @return string
*/
public function gridFieldAlterAction($data, $form, SS_HTTPRequest $request) {
$html = '';
$data = $request->requestVars();
$name = $this->getName();
$fieldData = isset($data[$name]) ? $data[$name] : null;
// Update state from client
$state = $this->getState(false);
if(isset($fieldData['GridState'])) {
$state->setValue($fieldData['GridState']);
}
// Try to execute alter action
foreach($data as $k => $v) {
if(preg_match('/^action_gridFieldAlterAction\?StateID=(.*)/', $k, $matches)) {
$id = $matches[1];
$stateChange = Session::get($id);
$actionName = $stateChange['actionName'];
$args = isset($stateChange['args']) ? $stateChange['args'] : array();
$html = $this->handleAlterAction($actionName, $args, $data);
// A field can optionally return its own HTML
if($html) return $html;
}
}
2015-04-17 02:07:51 +02:00
switch($request->getHeader('X-Pjax')) {
case 'CurrentField':
return $this->FieldHolder();
break;
case 'CurrentForm':
return $form->forTemplate();
break;
default:
return $form->forTemplate();
break;
}
}
/**
* Pass an action on the first GridField_ActionProvider that matches the $actionName
*
* @param string $actionName
* @param mixed $args
* @param arrray $data - send data from a form
2015-04-17 02:07:51 +02:00
*
* @return type
* @throws InvalidArgumentException
*/
public function handleAlterAction($actionName, $args, $data) {
$actionName = strtolower($actionName);
foreach($this->getComponents() as $component) {
if(!($component instanceof GridField_ActionProvider)) {
continue;
}
2015-04-17 02:07:51 +02:00
if(in_array($actionName, array_map('strtolower', (array) $component->getActions($this)))) {
return $component->handleAction($this, $actionName, $args, $data);
}
}
throw new InvalidArgumentException("Can't handle action '$actionName'");
}
2015-04-17 02:07:51 +02:00
/**
* Custom request handler that will check component handlers before proceeding to the default implementation.
2015-04-17 02:07:51 +02:00
*
* @todo There is too much code copied from RequestHandler here.
*/
public function handleRequest(SS_HTTPRequest $request, DataModel $model) {
if($this->brokenOnConstruct) {
user_error("parent::__construct() needs to be called on {$handlerClass}::__construct()", E_USER_WARNING);
}
$this->request = $request;
$this->setDataModel($model);
$fieldData = $this->request->requestVar($this->getName());
if($fieldData && isset($fieldData['GridState'])) $this->getState(false)->setValue($fieldData['GridState']);
2015-04-17 02:07:51 +02:00
foreach($this->getComponents() as $component) {
if(!($component instanceof GridField_URLHandler)) {
continue;
}
2015-04-17 02:07:51 +02:00
$urlHandlers = $component->getURLHandlers($this);
2015-04-17 02:07:51 +02:00
if($urlHandlers) foreach($urlHandlers as $rule => $action) {
if($params = $request->match($rule, true)) {
// Actions can reference URL parameters, eg, '$Action/$ID/$OtherID' => '$Action',
2015-04-17 02:07:51 +02:00
if($action[0] == '$') $action = $params[substr($action, 1)];
if(!method_exists($component, 'checkAccessAction') || $component->checkAccessAction($action)) {
if(!$action) {
$action = "index";
} else if(!is_string($action)) {
throw new LogicException("Non-string method name: " . var_export($action, true));
}
try {
$result = $component->$action($this, $request);
} catch(SS_HTTPResponse_Exception $responseException) {
$result = $responseException->getResponse();
}
if($result instanceof SS_HTTPResponse && $result->isError()) {
return $result;
}
if($this !== $result && !$request->isEmptyPattern($rule) && is_object($result)
2015-04-17 02:07:51 +02:00
&& $result instanceof RequestHandler
) {
$returnValue = $result->handleRequest($request, $model);
if(is_array($returnValue)) {
throw new LogicException("GridField_URLHandler handlers can't return arrays");
}
return $returnValue;
2015-04-17 02:07:51 +02:00
// If we return some other data, and all the URL is parsed, then return that
} else if($request->allParsed()) {
return $result;
2015-04-17 02:07:51 +02:00
// But if we have more content on the URL and we don't know what to do with it, return an error
} else {
return $this->httpError(404,
"I can't handle sub-URLs of a " . get_class($result) . " object.");
}
}
}
}
}
2015-04-17 02:07:51 +02:00
return parent::handleRequest($request, $model);
}
public function saveInto(DataObjectInterface $record) {
foreach($this->getComponents() as $component) {
if($component instanceof GridField_SaveHandler) {
$component->handleSave($this, $record);
}
}
}
}
/**
2015-04-17 02:07:51 +02:00
* This class is the base class when you want to have an action that alters
* the state of the {@link GridField}, rendered as a button element.
*
* @package forms
* @subpackage fields-gridfield
*/
class GridField_FormAction extends FormAction {
/**
* @var GridField
*/
protected $gridField;
2015-04-17 02:07:51 +02:00
/**
2015-04-17 02:07:51 +02:00
* @var array
*/
protected $stateValues;
2015-04-17 02:07:51 +02:00
/**
* @var array
*/
protected $args = array();
/**
* @var string
*/
protected $actionName;
/**
* @var boolean
*/
public $useButtonTag = true;
/**
* @param GridField $gridField
* @param type $name
* @param type $label
* @param type $actionName
2015-04-17 02:07:51 +02:00
* @param type $args
*/
public function __construct(GridField $gridField, $name, $title, $actionName, $args) {
$this->gridField = $gridField;
$this->actionName = $actionName;
$this->args = $args;
parent::__construct($name, $title);
}
/**
2015-04-17 02:07:51 +02:00
* urlencode encodes less characters in percent form than we need - we
* need everything that isn't a \w.
2015-04-17 02:07:51 +02:00
*
* @param string $val
*/
public function nameEncode($val) {
return preg_replace_callback('/[^\w]/', array($this, '_nameEncode'), $val);
}
/**
* The callback for nameEncode
2015-04-17 02:07:51 +02:00
*
* @param string $val
*/
public function _nameEncode($match) {
2015-04-17 02:07:51 +02:00
return '%' . dechex(ord($match[0]));
}
/**
* @return array
*/
public function getAttributes() {
// Store state in session, and pass ID to client side.
$state = array(
'grid' => $this->getNameFromParent(),
'actionName' => $this->actionName,
'args' => $this->args,
);
// Ensure $id doesn't contain only numeric characters
2015-04-17 02:07:51 +02:00
$id = 'gf_' . substr(md5(serialize($state)), 0, 8);
Session::set($id, $state);
$actionData['StateID'] = $id;
2015-04-17 02:07:51 +02:00
return array_merge(
parent::getAttributes(),
array(
// Note: This field needs to be less than 65 chars, otherwise Suhosin security patch
// will strip it from the requests
2015-04-17 02:07:51 +02:00
'name' => 'action_gridFieldAlterAction' . '?' . http_build_query($actionData),
'data-url' => $this->gridField->Link(),
)
);
}
/**
* Calculate the name of the gridfield relative to the Form
*
* @param GridField $base
2015-04-17 02:07:51 +02:00
*
* @return string
*/
protected function getNameFromParent() {
$base = $this->gridField;
$name = array();
2015-04-17 02:07:51 +02:00
do {
array_unshift($name, $base->getName());
$base = $base->getForm();
2015-04-17 02:07:51 +02:00
} while($base && !($base instanceof Form));
return implode('.', $name);
}
}