Column::isEditable() - Code Metrics - Inspection of "Datagrid aggreggation functions row" - ublaboo/datagrid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#375)

by Dalibor

created 2016-11-02 20:50 UTC

Column::isEditable() A

↳ Parent: Column

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

/**
 * @copyright   Copyright (c) 2015 ublaboo <[email protected]>
 * @author      Pavel Janda <[email protected]>
 * @package     Ublaboo
 */

namespace Ublaboo\DataGrid\Column;

use Ublaboo;
use Ublaboo\DataGrid\DataGrid;
use Ublaboo\DataGrid\Row;
use Ublaboo\DataGrid\Exception\DataGridException;
use Ublaboo\DataGrid\Exception\DataGridColumnRendererException;
use Nette\Utils\Html;
use Ublaboo\DataGrid\Traits;

abstract class Column extends FilterableColumn
{

	use Traits\TLink;

	/**
	 * @var array
	 */
	protected $replacements = [];

	/**
	 * @var Renderer|NULL
	 */
	protected $renderer;

	/**
	 * @var string
	 */
	protected $template;

	/**
	 * @var bool|string
	 */
	protected $sortable = FALSE;

	/**
	 * @var bool
	 */
	protected $sortable_reset_pagination = FALSE;

	/**
	 * @var null|callable
	 */
	protected $sortable_callback = NULL;

	/**
	 * @var array
	 */
	protected $sort;

	/**
	 * @var bool
	 */
	protected $template_escaping = TRUE;

	/**
	 * @var bool
	 */
	protected $header_escaping = FALSE;

	
	/**
	 * @var string
	 */
	protected $align;


	/**
	 * @var array
	 */
	protected $template_variables = [];

	/**
	 * @var callable
	 */
	protected $editable_callback;

	/**
	 * @var array
	 */
	protected $editable_element = ['textarea', ['class' => 'form-control']];

	/**
	 * Cached html elements
	 * @var array
	 */
	protected $el_cache = [];

	/**
	 * @var bool
	 */
	protected $default_hide = FALSE;

	/**
	 * @var ColumnAggregationFunction
	 */
	protected $aggregation_function = NULL;


	/**
	 * Render row item into template
	 * @param  Row   $row
	 * @return mixed
	 */
	public function render(Row $row)
	{
		/**
		 * Renderer function may be used
		 */
		try {
			return $this->useRenderer($row);
		} catch (DataGridColumnRendererException $e) {

			/**
			 * Do not use renderer
			 */
		}

		/**
		 * Or replacements may be applied
		 */
		list($do_replace, $replaced) = $this->applyReplacements($row);
		if ($do_replace) {
			return $replaced;
		}

		return $this->getColumnValue($row);
	}


	/**
	 * Try to render item with custom renderer
	 * @param  Row   $row
	 * @return mixed
	 */
	public function useRenderer(Row $row)
	{
		$renderer = $this->getRenderer();

		if (!$renderer) {
			throw new DataGridColumnRendererException;
		}

		if ($renderer->getConditionCallback()) {
			if (!call_user_func_array($renderer->getConditionCallback(), [$row->getItem()])) {
				throw new DataGridColumnRendererException;
			}

			return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
		}

		return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
	}


	/**
	 * Should be column values escaped in latte?
	 * @param bool $template_escaping
	 */
	public function setTemplateEscaping($template_escaping = TRUE)
	{
		$this->template_escaping = (bool) $template_escaping;

		return $this;
	}


	public function isTemplateEscaped()
	{
		return $this->template_escaping;
	}

	/**
	 * Should be column header escaped in latte?
	 * @param bool $header_escaping
	 */
	public function setHeaderEscaping($header_escaping = FALSE)
	{
		$this->header_escaping = (bool) $header_escaping;

		return $this;
	}
	
	public function isHeaderEscaped()
	{
		return $this->header_escaping;
	}
	
	
	/**
	 * Set column sortable or not
	 * @param bool|string $sortable
	 */
	public function setSortable($sortable = TRUE)
	{
		$this->sortable = is_string($sortable) ? $sortable : (bool) $sortable;

		return $this;
	}


	/**
	 * Tell whether column is sortable
	 * @return bool
	 */
	public function isSortable()
	{
		return (bool) $this->sortable;
	}


	/**
	 * Shoud be the pagination reseted after sorting?
	 * @param bool $sortable_reset_pagination
	 * @return static
	 */
	public function setSortableResetPagination($sortable_reset_pagination = TRUE)
	{
		$this->sortable_reset_pagination = (bool) $sortable_reset_pagination;

		return $this;
	}


	/**
	 * Do reset pagination after sorting?
	 * @return bool
	 */
	public function sortableResetPagination()
	{
		return $this->sortable_reset_pagination;
	}


	/**
	 * Set custom ORDER BY clause
	 * @param callable $sortable_callback
	 * @return static
	 */
	public function setSortableCallback(callable $sortable_callback)
	{
		$this->sortable_callback = $sortable_callback;

		return $this;
	}


	/**
	 * Get custom ORDER BY clause
	 * @return callable|null
	 */
	public function getSortableCallback()
	{
		return $this->sortable_callback;
	}


	/**
	 * Get column to sort by
	 * @return string
	 */
	public function getSortingColumn()
	{
		return is_string($this->sortable) ? $this->sortable : $this->column;
	}


	/**
	 * Get column name
	 * @return string
	 */
	public function getColumnName()
	{
		return $this->column;
	}


	/**
	 * Get column value of row item
	 * @param  Row   $row
	 * @return mixed
	 */
	public function getColumnValue(Row $row)
	{
		return $row->getValue($this->column);
	}


	/**
	 * @return string
	 */
	public function getName()
	{
		return $this->name;
	}


	/**
	 * Set column replacements
	 * @param  array $replacements
	 * @return Column
	 */
	public function setReplacement(array $replacements)
	{
		$this->replacements = $replacements;

		return $this;
	}


	/**
	 * Tell whether columns has replacements
	 * @return bool
	 */
	public function hasReplacements()
	{
		return (bool) $this->replacements;
	}


	/**
	 * Apply replacements
	 * @param  Row   $row
	 * @return array
	 */
	public function applyReplacements(Row $row)
	{
		$value = $row->getValue($this->column);

		if ((is_scalar($value) || is_null($value)) && isset($this->replacements[$value])) {
			return [TRUE, $this->replacements[$value]];
		}

		return [FALSE, NULL];
	}


	/**
	 * Set renderer callback and (it may be optional - the condition callback will decide)
	 * @param callable $renderer
	 */
	public function setRenderer($renderer, $condition_callback = NULL)
	{
		if ($this->hasReplacements()) {
			throw new DataGridException(
				"Use either Column::setReplacement() or Column::setRenderer, not both."
			);
		}

		if (!is_callable($renderer)) {
			throw new DataGridException(
				"Renderer (method Column::setRenderer()) must be callable."
			);
		}

		if (NULL != $condition_callback && !is_callable($condition_callback)) {
			throw new DataGridException(
				"Renderer (method Column::setRenderer()) must be callable."
			);
		}

		$this->renderer = new Renderer($renderer, $condition_callback);

		return $this;
	}


	/**
	 * Set renderer callback just if condition is truthy
	 * @param callable $renderer
	 */
	public function setRendererOnCondition($renderer, $condition_callback)
	{
		return $this->setRenderer($renderer, $condition_callback);
	}


	/**
	 * Return custom renderer callback
	 * @return Renderer|null
	 */
	public function getRenderer()
	{
		return $this->renderer;
	}


	/**
	 * Column may have its own template
	 * @param string $template
	 */
	public function setTemplate($template, array $template_variables = [])
	{
		$this->template = $template;
		$this->template_variables = $template_variables;

		return $this;
	}


	/**
	 * Column can have variables that will be passed to custom template scope
	 * @return array
	 */
	public function getTemplateVariables()
	{
		return $this->template_variables;
	}


	/**
	 * Tell whether column has its owntemplate
	 * @return bool
	 */
	public function hasTemplate()
	{
		return (bool) $this->template;
	}


	/**
	 * Get column template path
	 * @return string
	 */
	public function getTemplate()
	{
		return $this->template;
	}


	/**
	 * Tell whether data source is sorted by this collumn
	 * @return bool
	 */
	public function isSortedBy()
	{
		return (bool) $this->sort;
	}


	/**
	 * Tell column his sorting options
	 * @param array $sort
	 */
	public function setSort(array $sort)
	{
		$this->sort = $sort[$this->key];

		return $this;
	}


	/**
	 * What sorting will be applied after next click?
	 * @return array
	 */
	public function getSortNext()
	{
		if ($this->sort == 'ASC') {
			return [$this->key => 'DESC'];
		} else if ($this->sort == 'DESC') {
			return [$this->key => FALSE];
		}

		return [$this->key => 'ASC'];
	}


	/**
	 * @return bool
	 */
	public function hasSortNext()
	{
		foreach ($this->getSortNext() as $key => $order) {
			return $order !== FALSE;
		}
	}


	/**
	 * Is sorting ascending?
	 * @return bool
	 */
	public function isSortAsc()
	{
		return $this->sort == 'ASC';
	}


	/**
	 * Set column alignment
	 * @param string $align
	 */
	public function setAlign($align)
	{
		$this->align = (string) $align;

		return $this;
	}


	/**
	 * Has column some alignment?
	 * @return bool [description]
	 */
	public function hasAlign()
	{
		return (bool) $this->align;
	}


	/**
	 * Get column alignment
	 * @return string
	 */
	public function getAlign()
	{
		return $this->align ?: 'left';
	}


	/**
	 * Set column content fit
	 * @param bool $fit_content
	 * @return $this
	 */
	public function setFitContent($fit_content = TRUE)
	{
		($fit_content) ? $this->addAttributes(['class' => 'datagrid-fit-content']) : NULL;

		return $this;
	}


	/**
	 * Set callback that will be called after inline editing
	 * @param callable $editable_callback
	 */
	public function setEditableCallback(callable $editable_callback)
	{
		$this->editable_callback = $editable_callback;

		return $this;
	}


	/**
	 * Return callback that is used after inline editing
	 * @return callable
	 */
	public function getEditableCallback()
	{
		return $this->editable_callback;
	}


	/**
	 * Is column editable?
	 * @return bool
	 */
	public function isEditable()
	{
		return (bool) $this->getEditableCallback();
	}


	/**
	 * Element is by default textarea, user can change that
	 * @param string $el_type
	 * @param array  $attrs
	 * @return static
	 */
	public function setEditableInputType($el_type, array $attrs = [])
	{
		$this->editable_element = [$el_type, $attrs];

		return $this;
	}


	/**
	 * Change small inline edit input type to select
	 * @param array  $options
	 * @return static
	 */
	public function setEditableInputTypeSelect(array $options = [])
	{
		$select = Html::el('select');

		foreach ($options as $value => $text) {
			$select->create('option')
				->value($value)
				->setText($text);
		}

		$this->addAttributes(['data-datagrid-editable-element' => (string) $select]);

		return $this->setEditableInputType('select');
	}


	/**
	 * [getEditableInputType description]
	 * @return array
	 */
	public function getEditableInputType()
	{
		return $this->editable_element;
	}


	/**
	 * Set attributes for both th and td element
	 * @param array $attrs
	 * @return static
	 */
	public function addAttributes(array $attrs)
	{
		$this->getElementPrototype('td')->addAttributes($attrs);
		$this->getElementPrototype('th')->addAttributes($attrs);

		return $this;
	}


	/**
	 * Get th/td column element
	 * @param  string   $tag th|td
	 * @param  string   $key
	 * @param  Row|NULL $row
	 * @return Html
	 */
	public function getElementPrototype($tag, $key = NULL, Row $row = NULL)
	{
		/**
		 * Get cached element
		 */
		if (empty($this->el_cache[$tag])) {
			$this->el_cache[$tag] = $el = $el = Html::el($tag);
		} else {
			$el = $this->el_cache[$tag];
		}

		/**
		 * If class was set by user via $el->class = '', fix it
		 */
		if (!empty($el->class) && is_string($el->class)) {
			$class = $el->class;
			unset($el->class);

			$el->class[] = $class;
		}

		$el->class[] = "text-{$this->getAlign()}";

		/**
		 * Method called from datagrid template, set appropriate classes and another attributes
		 */
		if ($key !== NULL && $row !== NULL) {
			$el->class[] = "col-{$key}";

			if ($tag == 'td') {
				if ($this->isEditable()) {
					$link = $this->grid->link('edit!', ['key' => $key, 'id' => $row->getId()]);

					$el->data('datagrid-editable-url', $link);

					$el->data('datagrid-editable-type', $this->editable_element[0]);
					$el->data('datagrid-editable-attrs', json_encode($this->editable_element[1]));
				}
			}
		}

		return $el;
	}


	/**
	 * @param bool $default_hide
	 * @return static
	 */
	public function setDefaultHide($default_hide = TRUE)
	{
		$this->default_hide = (bool) $default_hide;

		if ($default_hide) {
			$this->grid->setSomeColumnDefaultHide($default_hide);
		}

		return $this;
	}


	public function getDefaultHide()
	{
		return $this->default_hide;
	}


	/**
	 * Get row item params (E.g. action may be called id => $item->id, name => $item->name, ...)
	 * @param  Row   $row
	 * @param  array $params_list
	 * @return array
	 */
	protected function getItemParams(Row $row, array $params_list)
	{
		$return = [];

		foreach ($params_list as $param_name => $param) {
			$return[is_string($param_name) ? $param_name : $param] = $row->getValue($param);
		}

		return $return;
	}


	/**
	 * @return string
	 */
	public function getColumn()
	{
		return $this->column;
	}


	/**
	 * @return ColumnAggregationFunction
	 */
	public function getAggregationFunction()
	{
		return $this->aggregation_function;
	}


	/**
	 * @return bool
	 */
	public function hasAggregationFunction()
	{
		return $this->aggregation_function instanceof ColumnAggregationFunction;
	}


	/**
	 * @param $aggregation_type use ColumnAggregationFunction::$aggregation_type...
	 * @param string $column
	 * @return ColumnAggregationFunction
	 */
	public function setAggregationFunction($aggregation_type, $column = NULL)
	{
		if ($column === NULL) {
			$column = $this->column;
		}
		$this->aggregation_function = new ColumnAggregationFunction($aggregation_type, $column);
		return $this->aggregation_function;
	}
}


1			<?php
2
3			/**
4			* @copyright Copyright (c) 2015 ublaboo <[email protected]>
5			* @author Pavel Janda <[email protected]>
6			* @package Ublaboo
7			*/
8
9			namespace Ublaboo\DataGrid\Column;
10
11			use Ublaboo;
12			use Ublaboo\DataGrid\DataGrid;
13			use Ublaboo\DataGrid\Row;
14			use Ublaboo\DataGrid\Exception\DataGridException;
15			use Ublaboo\DataGrid\Exception\DataGridColumnRendererException;
16			use Nette\Utils\Html;
17			use Ublaboo\DataGrid\Traits;
18
19			abstract class Column extends FilterableColumn
20			{
21
22			use Traits\TLink;
23
24			/**
25			* @var array
26			*/
27			protected $replacements = [];
28
29			/**
30			* @var Renderer\|NULL
31			*/
32			protected $renderer;
33
34			/**
35			* @var string
36			*/
37			protected $template;
38
39			/**
40			* @var bool\|string
41			*/
42			protected $sortable = FALSE;
43
44			/**
45			* @var bool
46			*/
47			protected $sortable_reset_pagination = FALSE;
48
49			/**
50			* @var null\|callable
51			*/
52			protected $sortable_callback = NULL;
53
54			/**
55			* @var array
56			*/
57			protected $sort;
58
59			/**
60			* @var bool
61			*/
62			protected $template_escaping = TRUE;
63
64			/**
65			* @var bool
66			*/
67			protected $header_escaping = FALSE;
68
69
70			/**
71			* @var string
72			*/
73			protected $align;
74
75
76			/**
77			* @var array
78			*/
79			protected $template_variables = [];
80
81			/**
82			* @var callable
83			*/
84			protected $editable_callback;
85
86			/**
87			* @var array
88			*/
89			protected $editable_element = ['textarea', ['class' => 'form-control']];
90
91			/**
92			* Cached html elements
93			* @var array
94			*/
95			protected $el_cache = [];
96
97			/**
98			* @var bool
99			*/
100			protected $default_hide = FALSE;
101
102			/**
103			* @var ColumnAggregationFunction
104			*/
105			protected $aggregation_function = NULL;
106
107
108			/**
109			* Render row item into template
110			* @param Row $row
111			* @return mixed
112			*/
113			public function render(Row $row)
114			{
115			/**
116			* Renderer function may be used
117			*/
118			try {
119			return $this->useRenderer($row);
120			} catch (DataGridColumnRendererException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-02-26 10:17 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
121			/**
122			* Do not use renderer
123			*/
124			}
125
126			/**
127			* Or replacements may be applied
128			*/
129			list($do_replace, $replaced) = $this->applyReplacements($row);
130			if ($do_replace) {
131			return $replaced;
132			}
133
134			return $this->getColumnValue($row);
135			}
136
137
138			/**
139			* Try to render item with custom renderer
140			* @param Row $row
141			* @return mixed
142			*/
143			public function useRenderer(Row $row)
144			{
145			$renderer = $this->getRenderer();
146
147			if (!$renderer) {
148			throw new DataGridColumnRendererException;
149			}
150
151			if ($renderer->getConditionCallback()) {
152			if (!call_user_func_array($renderer->getConditionCallback(), [$row->getItem()])) {
153			throw new DataGridColumnRendererException;
154			}
155
156			return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
157			}
158
159			return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
160			}
161
162
163			/**
164			* Should be column values escaped in latte?
165			* @param bool $template_escaping
166			*/
167			public function setTemplateEscaping($template_escaping = TRUE)
168			{
169			$this->template_escaping = (bool) $template_escaping;
170
171			return $this;
172			}
173
174
175			public function isTemplateEscaped()
176			{
177			return $this->template_escaping;
178			}
179
180			/**
181			* Should be column header escaped in latte?
182			* @param bool $header_escaping
183			*/
184			public function setHeaderEscaping($header_escaping = FALSE)
185			{
186			$this->header_escaping = (bool) $header_escaping;
187
188			return $this;
189			}
190
191			public function isHeaderEscaped()
192			{
193			return $this->header_escaping;
194			}
195
196
197			/**
198			* Set column sortable or not
199			* @param bool\|string $sortable
200			*/
201			public function setSortable($sortable = TRUE)
202			{
203			$this->sortable = is_string($sortable) ? $sortable : (bool) $sortable;
204
205			return $this;
206			}
207
208
209			/**
210			* Tell whether column is sortable
211			* @return bool
212			*/
213			public function isSortable()
214			{
215			return (bool) $this->sortable;
216			}
217
218
219			/**
220			* Shoud be the pagination reseted after sorting?
221			* @param bool $sortable_reset_pagination
222			* @return static
223			*/
224			public function setSortableResetPagination($sortable_reset_pagination = TRUE)
225			{
226			$this->sortable_reset_pagination = (bool) $sortable_reset_pagination;
227
228			return $this;
229			}
230
231
232			/**
233			* Do reset pagination after sorting?
234			* @return bool
235			*/
236			public function sortableResetPagination()
237			{
238			return $this->sortable_reset_pagination;
239			}
240
241
242			/**
243			* Set custom ORDER BY clause
244			* @param callable $sortable_callback
245			* @return static
246			*/
247			public function setSortableCallback(callable $sortable_callback)
248			{
249			$this->sortable_callback = $sortable_callback;
250
251			return $this;
252			}
253
254
255			/**
256			* Get custom ORDER BY clause
257			* @return callable\|null
258			*/
259			public function getSortableCallback()
260			{
261			return $this->sortable_callback;
262			}
263
264
265			/**
266			* Get column to sort by
267			* @return string
268			*/
269			public function getSortingColumn()
270			{
271			return is_string($this->sortable) ? $this->sortable : $this->column;
272			}
273
274
275			/**
276			* Get column name
277			* @return string
278			*/
279			public function getColumnName()
280			{
281			return $this->column;
282			}
283
284
285			/**
286			* Get column value of row item
287			* @param Row $row
288			* @return mixed
289			*/
290			public function getColumnValue(Row $row)
291			{
292			return $row->getValue($this->column);
293			}
294
295
296			/**
297			* @return string
298			*/
299			public function getName()
300			{
301			return $this->name;
302			}
303
304
305			/**
306			* Set column replacements
307			* @param array $replacements
308			* @return Column
309			*/
310			public function setReplacement(array $replacements)
311			{
312			$this->replacements = $replacements;
313
314			return $this;
315			}
316
317
318			/**
319			* Tell whether columns has replacements
320			* @return bool
321			*/
322			public function hasReplacements()
323			{
324			return (bool) $this->replacements;
325			}
326
327
328			/**
329			* Apply replacements
330			* @param Row $row
331			* @return array
332			*/
333			public function applyReplacements(Row $row)
334			{
335			$value = $row->getValue($this->column);
336
337			if ((is_scalar($value) \|\| is_null($value)) && isset($this->replacements[$value])) {
338			return [TRUE, $this->replacements[$value]];
339			}
340
341			return [FALSE, NULL];
342			}
343
344
345			/**
346			* Set renderer callback and (it may be optional - the condition callback will decide)
347			* @param callable $renderer
348			*/
349			public function setRenderer($renderer, $condition_callback = NULL)
350			{
351			if ($this->hasReplacements()) {
352			throw new DataGridException(
353			"Use either Column::setReplacement() or Column::setRenderer, not both."
354			);
355			}
356
357			if (!is_callable($renderer)) {
358			throw new DataGridException(
359			"Renderer (method Column::setRenderer()) must be callable."
360			);
361			}
362
363			if (NULL != $condition_callback && !is_callable($condition_callback)) {
364			throw new DataGridException(
365			"Renderer (method Column::setRenderer()) must be callable."
366			);
367			}
368
369			$this->renderer = new Renderer($renderer, $condition_callback);
370
371			return $this;
372			}
373
374
375			/**
376			* Set renderer callback just if condition is truthy
377			* @param callable $renderer
378			*/
379			public function setRendererOnCondition($renderer, $condition_callback)
380			{
381			return $this->setRenderer($renderer, $condition_callback);
382			}
383
384
385			/**
386			* Return custom renderer callback
387			* @return Renderer\|null
388			*/
389			public function getRenderer()
390			{
391			return $this->renderer;
392			}
393
394
395			/**
396			* Column may have its own template
397			* @param string $template
398			*/
399			public function setTemplate($template, array $template_variables = [])
400			{
401			$this->template = $template;
402			$this->template_variables = $template_variables;
403
404			return $this;
405			}
406
407
408			/**
409			* Column can have variables that will be passed to custom template scope
410			* @return array
411			*/
412			public function getTemplateVariables()
413			{
414			return $this->template_variables;
415			}
416
417
418			/**
419			* Tell whether column has its owntemplate
420			* @return bool
421			*/
422			public function hasTemplate()
423			{
424			return (bool) $this->template;
425			}
426
427
428			/**
429			* Get column template path
430			* @return string
431			*/
432			public function getTemplate()
433			{
434			return $this->template;
435			}
436
437
438			/**
439			* Tell whether data source is sorted by this collumn
440			* @return bool
441			*/
442			public function isSortedBy()
443			{
444			return (bool) $this->sort;
445			}
446
447
448			/**
449			* Tell column his sorting options
450			* @param array $sort
451			*/
452			public function setSort(array $sort)
453			{
454			$this->sort = $sort[$this->key];
455
456			return $this;
457			}
458
459
460			/**
461			* What sorting will be applied after next click?
462			* @return array
463			*/
464			public function getSortNext()
465			{
466			if ($this->sort == 'ASC') {
467			return [$this->key => 'DESC'];
468			} else if ($this->sort == 'DESC') {
469			return [$this->key => FALSE];
470			}
471
472			return [$this->key => 'ASC'];
473			}
474
475
476			/**
477			* @return bool
478			*/
479			public function hasSortNext()
480			{
481			foreach ($this->getSortNext() as $key => $order) {
482			return $order !== FALSE;
483			}
484			}
485
486
487			/**
488			* Is sorting ascending?
489			* @return bool
490			*/
491			public function isSortAsc()
492			{
493			return $this->sort == 'ASC';
494			}
495
496
497			/**
498			* Set column alignment
499			* @param string $align
500			*/
501			public function setAlign($align)
502			{
503			$this->align = (string) $align;
504
505			return $this;
506			}
507
508
509			/**
510			* Has column some alignment?
511			* @return bool [description]
512			*/
513			public function hasAlign()
514			{
515			return (bool) $this->align;
516			}
517
518
519			/**
520			* Get column alignment
521			* @return string
522			*/
523			public function getAlign()
524			{
525			return $this->align ?: 'left';
526			}
527
528
529			/**
530			* Set column content fit
531			* @param bool $fit_content
532			* @return $this
533			*/
534			public function setFitContent($fit_content = TRUE)
535			{
536			($fit_content) ? $this->addAttributes(['class' => 'datagrid-fit-content']) : NULL;
537
538			return $this;
539			}
540
541
542			/**
543			* Set callback that will be called after inline editing
544			* @param callable $editable_callback
545			*/
546			public function setEditableCallback(callable $editable_callback)
547			{
548			$this->editable_callback = $editable_callback;
549
550			return $this;
551			}
552
553
554			/**
555			* Return callback that is used after inline editing
556			* @return callable
557			*/
558			public function getEditableCallback()
559			{
560			return $this->editable_callback;
561			}
562
563
564			/**
565			* Is column editable?
566			* @return bool
567			*/
568			public function isEditable()
569			{
570			return (bool) $this->getEditableCallback();
571			}
572
573
574			/**
575			* Element is by default textarea, user can change that
576			* @param string $el_type
577			* @param array $attrs
578			* @return static
579			*/
580			public function setEditableInputType($el_type, array $attrs = [])
581			{
582			$this->editable_element = [$el_type, $attrs];
583
584			return $this;
585			}
586
587
588			/**
589			* Change small inline edit input type to select
590			* @param array $options
591			* @return static
592			*/
593			public function setEditableInputTypeSelect(array $options = [])
594			{
595			$select = Html::el('select');
596
597			foreach ($options as $value => $text) {
598			$select->create('option')
599			->value($value)
600			->setText($text);
601			}
602
603			$this->addAttributes(['data-datagrid-editable-element' => (string) $select]);
604
605			return $this->setEditableInputType('select');
606			}
607
608
609			/**
610			* [getEditableInputType description]
611			* @return array
612			*/
613			public function getEditableInputType()
614			{
615			return $this->editable_element;
616			}
617
618
619			/**
620			* Set attributes for both th and td element
621			* @param array $attrs
622			* @return static
623			*/
624			public function addAttributes(array $attrs)
625			{
626			$this->getElementPrototype('td')->addAttributes($attrs);
627			$this->getElementPrototype('th')->addAttributes($attrs);
628
629			return $this;
630			}
631
632
633			/**
634			* Get th/td column element
635			* @param string $tag th\|td
636			* @param string $key
637			* @param Row\|NULL $row
638			* @return Html
639			*/
640			public function getElementPrototype($tag, $key = NULL, Row $row = NULL)
641			{
642			/**
643			* Get cached element
644			*/
645			if (empty($this->el_cache[$tag])) {
646			$this->el_cache[$tag] = $el = $el = Html::el($tag);
647			} else {
648			$el = $this->el_cache[$tag];
649			}
650
651			/**
652			* If class was set by user via $el->class = '', fix it
653			*/
654			if (!empty($el->class) && is_string($el->class)) {
655			$class = $el->class;
656			unset($el->class);
657
658			$el->class[] = $class;
659			}
660
661			$el->class[] = "text-{$this->getAlign()}";
662
663			/**
664			* Method called from datagrid template, set appropriate classes and another attributes
665			*/
666			if ($key !== NULL && $row !== NULL) {
667			$el->class[] = "col-{$key}";
668
669			if ($tag == 'td') {
670			if ($this->isEditable()) {
671			$link = $this->grid->link('edit!', ['key' => $key, 'id' => $row->getId()]);
672
673			$el->data('datagrid-editable-url', $link);
674
675			$el->data('datagrid-editable-type', $this->editable_element[0]);
676			$el->data('datagrid-editable-attrs', json_encode($this->editable_element[1]));
677			}
678			}
679			}
680
681			return $el;
682			}
683
684
685			/**
686			* @param bool $default_hide
687			* @return static
688			*/
689			public function setDefaultHide($default_hide = TRUE)
690			{
691			$this->default_hide = (bool) $default_hide;
692
693			if ($default_hide) {
694			$this->grid->setSomeColumnDefaultHide($default_hide);
695			}
696
697			return $this;
698			}
699
700
701			public function getDefaultHide()
702			{
703			return $this->default_hide;
704			}
705
706
707			/**
708			* Get row item params (E.g. action may be called id => $item->id, name => $item->name, ...)
709			* @param Row $row
710			* @param array $params_list
711			* @return array
712			*/
713			protected function getItemParams(Row $row, array $params_list)
714			{
715			$return = [];
716
717			foreach ($params_list as $param_name => $param) {
718			$return[is_string($param_name) ? $param_name : $param] = $row->getValue($param);
719			}
720
721			return $return;
722			}
723
724
725			/**
726			* @return string
727			*/
728			public function getColumn()
729			{
730			return $this->column;
731			}
732
733
734			/**
735			* @return ColumnAggregationFunction
736			*/
737			public function getAggregationFunction()
738			{
739			return $this->aggregation_function;
740			}
741
742
743			/**
744			* @return bool
745			*/
746			public function hasAggregationFunction()
747			{
748			return $this->aggregation_function instanceof ColumnAggregationFunction;
749			}
750
751
752			/**
753			* @param $aggregation_type use ColumnAggregationFunction::$aggregation_type...
754			* @param string $column
755			* @return ColumnAggregationFunction
756			*/
757			public function setAggregationFunction($aggregation_type, $column = NULL)
758			{
759			if ($column === NULL) {
760			$column = $this->column;
761			}
762			$this->aggregation_function = new ColumnAggregationFunction($aggregation_type, $column);
763			return $this->aggregation_function;
764			}
765			}
766

ublaboo / datagrid

Pull Request — master (#375)

Column::isEditable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like