AtDataGrid\DataGrid

Complexity

Total Complexity

79

Size/Duplication

Total Lines	726
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	38
Bugs	6	Features	8

52 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setTitle()	0	5	1
A	getTitle()	0	4	1
A	setIdentifierColumnName()	0	7	1
A	getIdentifierColumnName()	0	4	1
A	hasColumn()	0	4	1
A	addColumn()	0	10	2
A	setColumn()	0	5	1
A	getColumn()	0	8	2
A	getColumns()	0	4	1
A	removeColumn()	0	8	2
A	removeColumns()	0	8	2
A	hideColumns()	0	8	2
A	hideColumnsInForm()	0	8	2
A	showColumns()	0	8	2
A	showColumnsInForm()	0	8	2
A	setOrder()	0	8	3
A	getOrder()	0	4	1
A	getOrderColumn()	0	8	2
A	getOrderDirection()	0	8	2
A	getRevertOrderDirection()	0	4	2
A	setDataSource()	0	5	1
A	getDataSource()	0	4	1
A	getRow()	0	4	1
B	getData()	0	26	4
A	getPaginator()	0	4	1
A	save()	0	19	3
A	insert()	0	14	2
A	update()	0	14	2
A	delete()	0	8	1
A	addFilter()	0	14	3
A	hasFilter()	0	4	1
A	getFilter()	0	8	2
A	getFilters()	0	4	1
A	hasFilters()	0	4	1
A	setFiltersData()	0	7	2
A	setCurrentPage()	0	5	1
A	getCurrentPage()	0	4	1
A	setItemsPerPage()	0	5	1
A	getItemsPerPage()	0	4	1
A	setPageRange()	0	5	1
A	current()	0	4	1
A	valid()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	rewind()	0	4	1
A	count()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	8	2
A	offsetSet()	0	8	2
A	offsetUnset()	0	6	2
A	getIterator()	0	4	1

<?php

namespace AtDataGrid;

use AtDataGrid\DataSource;
use AtDataGrid\Column\Column;
use AtDataGrid\Filter\FilterInterface;
use Zend\Db\ResultSet\ResultSet;
use Zend\EventManager\EventManagerAwareTrait;
use Zend\Paginator\Paginator;

class DataGrid implements \Countable, \IteratorAggregate, \ArrayAccess
{
    use EventManagerAwareTrait;

    const EVENT_GRID_INSERT_PRE = 'at-datagrid.grid.insert.pre';
    const EVENT_GRID_INSERT_POST = 'at-datagrid.grid.insert.post';

    const EVENT_GRID_UPDATE_PRE = 'at-datagrid.grid.update.pre';
    const EVENT_GRID_UPDATE_POST = 'at-datagrid.grid.update.post';

    const EVENT_GRID_PERSIST_PRE = 'at-datagrid.grid.persist.pre';
    const EVENT_GRID_PERSIST_POST = 'at-datagrid.grid.persist.post';

    const EVENT_GRID_DELETE_PRE = 'at-datagrid.grid.delete.pre';
    const EVENT_GRID_DELETE_POST = 'at-datagrid.grid.delete.post';

    /**
     * Grid title
     *
     * @var string
     */
    protected $title;

    /**
     * Data source
     *
     * @var DataSource\AbstractDataSource
     */
    protected $dataSource;

    /**
     * Data grid columns
     *
     * @var array
     */
    protected $columns = [];

    /**
     * @var string
     */
    protected $identifierColumnName = 'id';

    /**
     * @var Paginator
     */
    protected $paginator;

    /**
     * Order in format ['id' => 'desc']
     *
     * @var array
     */
    protected $order;

    /**
     * Current page
     *
     * @var integer
     */
    protected $currentPage = 1;

    /**
     * Items per page
     *
     * @var integer
     */
    protected $itemsPerPage = 20;

    /**
     * Page range
     *
     * @var integer
     */
    protected $pageRange = 10;

    /**
     * Array of column filters
     *
     * @var array
     */
    protected $filters = [];

    /**
     * Array of rows from data source
     *
     * @var array
     */
    protected $data = [];

    /**
     * @param $dataSource
     * @param string $title
     */
    public function __construct($dataSource, $title = '')
    {
        $this->setDataSource($dataSource);
        $this->setTitle($title);

        // Collect column names from data source and create default column objects
        $this->columns = $this->getDataSource()->loadColumns();

It seems like $this->getDataSource()->loadColumns() of type * is incompatible with the declared type array of property $columns.

    }
    
    // METADATA

    /**
     * @param $title
     * @return $this
     */
    public function setTitle($title)
    {
        $this->title = $title;
        return $this;
    }

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

    // COLUMNS

    /**
     * @param $name
     * @return $this
     */
    public function setIdentifierColumnName($name)
    {
        $this->identifierColumnName = (string) $name;
        $this->getDataSource()->setIdentifierFieldName($this->identifierColumnName);

        return $this;
    }

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

    /**
     * Check if grid has column by the given name
     *
     * @param $name
     * @return bool
     */
    protected function hasColumn($name)
    {
        return array_key_exists($name, $this->columns);
    }

    /**
     * Add a column to data grid
     *
     * @param Column $column
     * @return $this
     */
    public function addColumn(Column $column)
    {
        $columnName = $column->getName();
        if ($this->hasColumn($columnName) ) {
            throw new \Exception('Column `' . $columnName . '` already presents in grid.');
        }    
        
        $this->columns[$columnName] = $column;
    	return $this;
    }

    /**
     * Set column by given name with overwriting.
     *
     * @param Column $column
     * @return $this
     */
    public function setColumn(Column $column)
    {
        $this->columns[$column->getName()] = $column;
        return $this;
    }

    /**
     * Return column object specified by it name
     *
     * @param $name
     * @return Column
     * @throws \Exception
     */
    public function getColumn($name)
    {
        if ($this->hasColumn($name)) {
            return $this->columns[$name];
        }

        throw new \Exception("Column '" . $name . "' doesn't presents in grid.");
    }

    /**
     * Return all column objects
     *
     * @return array
     */
    public function getColumns()
    {
        return $this->columns;
    }

    /**
     * Remove column specified by it name
     *
     * @param $name
     * @return DataGrid
     */
    public function removeColumn($name)
    {
        if ($this->hasColumn($name)) {
            unset($this->columns[$name]);
        }

    	return $this;	
    }

    /**
     * Remove columns specified by its names
     *
     * @param array $names
     * @return DataGrid
     */
    public function removeColumns(array $names)
    {
        foreach ($names as $name) {
	        $this->removeColumn($name);
        }

        return $this;
    }

    /**
     * Set columns invisible in grid
     *
     * @param array $names
     * @return DataGrid
     */
    public function hideColumns(array $names)
    {
        foreach ($names as $name) {
            $this->getColumn($name)->setVisible(false);
        }

        return $this;                   
    }

    /**
     * Set columns invisible in form
     *
     * @param $names
     * @return DataGrid
     */
    public function hideColumnsInForm(array $names)
    {
        foreach ($names as $name) {
            $this->getColumn($name)->setVisibleInForm(false);
        }

        return $this;
    }

    /**
     * Set columns visible in grid
     *
     * @param array $names
     * @return DataGrid
     */
    public function showColumns(array $names)
    {
        foreach ($names as $name) {
            $this->getColumn($name)->setVisible(true);
        }

        return $this;
    }

    /**
     * Set columns visible in form
     *
     * @param $names
     * @return DataGrid
     */
    public function showColumnsInForm(array $names)
    {
        foreach ($names as $name) {
            $this->getColumn($name)->setVisibleInForm(true);
        }

        return $this;
    }

    // SORTING

    /**
     * @param array $order
     */
    public function setOrder(array $order)
    {
        $column = key($order);
        $direction = $order[$column];
        if ($this->hasColumn($column) && in_array(strtolower($direction), ['asc', 'desc'])) {
            $this->order = $order;
        }
    }

    /**
     * @return array
     */
    public function getOrder()
    {
        return $this->order;
    }

    /**
     * @return mixed
     */
    public function getOrderColumn()
    {
        if (!empty($this->order)) {
            return key($this->order);
        }

        return null;
    }

    /**
     * @return mixed
     */
    public function getOrderDirection()
    {
        if (!empty($this->order)) {
            return strtolower($this->order[key($this->order)]);
        }

        return null;
    }

    /**
     * @return string
     */
    public function getRevertOrderDirection()
    {
        return ($this->getOrderDirection() == 'asc') ? 'desc' : 'asc';
    }

    // DATA SOURCE

    /**
     * @param DataSource\AbstractDataSource $dataSource
     * @return $this
     */
    public function setDataSource(DataSource\AbstractDataSource $dataSource)
    {
        $this->dataSource = $dataSource;
    	return $this;
    }

    /**
     * @return DataSource\AbstractDataSource
     */
    public function getDataSource()
    {
        return $this->dataSource;
    }
    
    /**
     * Find row by primary key
     *
     * @param $key
     * @return mixed
     */
    public function getRow($key)
    {
        return $this->getDataSource()->find($key);
    }

    /**
     * @return mixed
     * @throws \Exception
     */
    public function getData()
    {
        // Prepare data source for fetching data
    	$this->getDataSource()->prepare($this->getOrder(), $this->getFilters());

        // Load data using paginator
        $this->paginator = new Paginator($this->getDataSource()->getPaginatorAdapter());
        $this->paginator->setCurrentPageNumber($this->currentPage);
        $this->paginator->setItemCountPerPage($this->itemsPerPage);
        $this->paginator->setPageRange($this->pageRange);
        $data = $this->paginator->getCurrentItems();

        // Convert data to array
        if (! is_array($data)) {
            if ($data instanceof ResultSet) {

The class Zend\Db\ResultSet\ResultSet does not exist. Did you forget a USE statement, or did you not list all dependencies?

                $data = $data->toArray();
            } elseif ($data instanceof \ArrayIterator) {
                $data = $data->getArrayCopy();
            } else {
                throw new \RuntimeException('Result data couldn\'t be converted to array');
            }
        }

        $this->data = $data;
        return $this->data;
    }

    /**
     * @return Paginator
     */
    public function getPaginator()
    {
        return $this->paginator;
    }

    // CRUD

    /**
     * @param $data
     * @return mixed
     */
    public function save($data, $identifier = null)
    {
        $eventResult = $this->getEventManager()->trigger(self::EVENT_GRID_PERSIST_PRE, $this, $data)->last();
        if ($eventResult) {
            $data = $eventResult;
        }

        if (!$identifier) {
            $id = $this->insert($data);
        } else {
            $id = $this->update($data, $identifier);
        }

        $data[$this->getIdentifierColumnName()] = $id;

        $this->getEventManager()->trigger(self::EVENT_GRID_PERSIST_POST, $this, $data);

        return $this->getRow($id);
    }

    /**
     * @param $data
     * @return mixed
     */
    public function insert($data)
    {
        $eventResult = $this->getEventManager()->trigger(self::EVENT_GRID_INSERT_PRE, $this, $data)->last();
        if ($eventResult) {
            $data = $eventResult;
        }

        $id = $this->getDataSource()->insert($data);

        $data[$this->getIdentifierColumnName()] = $id;
        $this->getEventManager()->trigger(self::EVENT_GRID_INSERT_POST, $this, $data);

        return $id;
    }

    /**
     * @param $data
     * @param $primary
     * @return mixed
     */
    public function update($data, $primary)
    {
        $eventResult = $this->getEventManager()->trigger(self::EVENT_GRID_UPDATE_PRE, $this, $data)->last();
        if ($eventResult) {
            $data = $eventResult;
        }

        $this->getDataSource()->update($data, $primary);
        $data[$this->getIdentifierColumnName()] = $primary;

        $this->getEventManager()->trigger(self::EVENT_GRID_UPDATE_POST, $this, $data);

        return $primary;
    }

    /**
     * @param $id
     */
    public function delete($id)
    {
        $identifierColumnName = $this->getIdentifierColumnName();

        $this->getEventManager()->trigger(self::EVENT_GRID_DELETE_PRE, $this, [$identifierColumnName => $id]);
        $this->getDataSource()->delete($id);
        $this->getEventManager()->trigger(self::EVENT_GRID_DELETE_POST, $this, [$identifierColumnName => $id]);
    }

    // FILTERS

    /**
     * @param FilterInterface $filter
     * @param Column $column
     * @return $this
     */
    public function addFilter(FilterInterface $filter, Column $column)
    {
        if (! $filter->getName()) {
            $filter->setName($column->getName());
        }

        if (! $filter->getLabel()) {
            $filter->setLabel($column->getLabel());
        }

        $this->filters[$filter->getName()] = $filter;

        return $this;
    }

    /**
     * @param $columnName
     * @return bool
     */
    public function hasFilter($columnName)
    {
        return array_key_exists($columnName, $this->filters);
    }

    /**
     * @param $columnName
     * @return null
     */
    public function getFilter($columnName)
    {
        if ($this->hasFilter($columnName)) {
            return $this->filters[$columnName];
        }

        return null;
    }

    /**
     * @return array
     */
    public function getFilters()
    {
        return $this->filters;
    }

    /**
     * @return bool
     */
    public function hasFilters()
    {
        return count($this->getFilters()) > 0;
    }

    /**
     * @param $values
     */
    public function setFiltersData($values)
    {
        /** @var FilterInterface $filter */
        foreach ($this->getFilters() as $filter) {
            $filter->setValue($values[$filter->getName()]);
        }
    }

    // PAGINATOR

    /**
     * @param $number
     * @return $this
     */
    public function setCurrentPage($number)
    {
        $this->currentPage = (int) $number;
        return $this;
    }

    /**
     * @return int
     */
    public function getCurrentPage()
    {
        return $this->currentPage;
    }


    /**
     * @param $count
     * @return $this
     */
    public function setItemsPerPage($count)
    {
        $this->itemsPerPage = (int) $count;
        return $this;
    }

    /**
     * @return int
     */
    public function getItemsPerPage()
    {
        return $this->itemsPerPage;
    }

    /**
     * @param $count
     * @return $this
     */
    public function setPageRange($count)
    {
        $this->pageRange = (int) $count;
        return $this;
    }

    // INTERFACES IMPLEMENTATION

    /**
     * @return mixed
     */
    public function current()
    {
        return current($this->columns);
    }

    /**
     * @return bool
     */
    public function valid()
    {
        return ($this->current() !== false);
    }

    /**
     * @return mixed
     */
    public function next()
    {
        return next($this->columns);
    }

    /**
     * @return mixed
     */
    public function key()
    {
        return key($this->columns);
    }

    /**
     * @return mixed
     */
    public function rewind()
    {
        return reset($this->columns);
    }

    /**
     * @return int
     */
    public function count()
    {
        return count($this->columns);
    }

    /**
     * @param mixed $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return isset($this->columns[$offset]);
    }

    /**
     * @param mixed $offset
     * @return bool|mixed
     */
    public function offsetGet($offset)
    {
        if(isset($this->columns[$offset])) {
            return $this->columns[$offset];
        }

        return false;
    }

    /**
     * @param mixed $offset
     * @param mixed $column
     */
    public function offsetSet($offset, $column)
    {
        if ($offset !== null) {
            $this->columns[$offset] = $column;
        } else {
            $this->columns[] = $column;
        }
    }

    /**
     * @param mixed $offset
     */
    public function offsetUnset($offset)
    {
        if (isset($this->columns[$offset])) {
            unset($this->columns[$offset]);
        }
    }

    /**
     * Get an iterator for iterating over the elements in the collection.
     *
     * @return \ArrayIterator|\Traversable
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->columns);
    }
}