Yaro\Jarboe\Table\CRUD

Complexity

Total Complexity

105

Size/Duplication

Total Lines	532
Duplicated Lines	0 %

Coupling/Cohesion

Components	8
Dependencies	5

Test Coverage

Coverage

41.45%

Importance

Changes

0

69 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	formClass()	0	8	2
A	getRawPerPage()	0	4	1
A	addColumn()	0	4	1
A	getColumns()	0	4	1
A	getColumnsAsFields()	0	15	6
A	getColumnsWithoutRelatedField()	0	11	3
A	getAllFieldObjects()	0	9	1
A	getFieldByName()	0	11	3
A	addField()	0	4	1
A	getFields()	0	4	1
A	getFieldsWithoutMarkup()	0	9	2
A	extractField()	0	11	3
A	getTabs()	0	14	4
A	moveDefaultTabToEnd()	0	11	2
A	setModel()	0	6	1
A	repo()	0	6	1
A	preferences()	0	4	1
A	paginate()	0	16	4
A	order()	0	6	1
A	filter()	0	6	1
A	getModel()	0	4	1
A	hasAnyFieldFilter()	0	10	4
A	editUrl()	0	4	1
A	createUrl()	0	4	1
A	deleteUrl()	0	4	1
A	restoreUrl()	0	4	1
A	forceDeleteUrl()	0	4	1
A	toolbarUrl()	0	4	1
A	listUrl()	0	4	1
A	perPageUrl()	0	4	1
A	searchUrl()	0	4	1
A	relationSearchUrl()	0	4	1
A	inlineUrl()	0	4	1
A	orderUrl()	0	4	1
A	reorderUrl()	0	4	1
A	reorderMoveItemUrl()	0	4	1
A	baseUrl()	0	6	1
A	tableIdentifier()	0	8	2
A	saveSearchFilterParams()	0	4	1
A	getOrderFilterParam()	0	4	1
A	saveOrderFilterParam()	0	4	1
A	getPerPageParam()	0	4	1
A	setPerPageParam()	0	4	1
A	getCurrentLocale()	0	4	2
A	saveCurrentLocale()	0	4	1
A	getTool()	0	8	2
A	addTool()	0	4	1
A	getTools()	0	4	1
A	getActiveHeaderToolbarTools()	0	12	4
A	getActiveBodyToolbarToolsOnTop()	0	4	1
A	getActiveBodyToolbarToolsOnBottom()	0	4	1
A	getActiveBodyToolbarTools()	0	13	5
A	getTabErrorsCount()	0	12	2
A	locales()	0	7	1
A	getLocales()	0	4	1
A	isAssociativeArray()	0	8	2
A	normalizeLocales()	0	9	2
A	actions()	0	4	1
A	enableBatchCheckboxes()	0	4	1
A	isBatchCheckboxesEnabled()	0	4	1
A	enableSortableByWeight()	0	4	1
A	isSortableByWeight()	0	4	1
A	isSortableByWeightActive()	0	4	1
A	getSortableWeightFieldName()	0	4	1
A	setSortableOrderState()	0	4	1
A	enableSoftDelete()	0	4	1
A	isSoftDeleteEnabled()	0	4	1
A	makeDefaultColumnField()	0	4	1

<?php

namespace Yaro\Jarboe\Table;

use Yaro\Jarboe\Table\Actions\ActionsContainer;
use Yaro\Jarboe\Table\Fields\AbstractField;
use Yaro\Jarboe\Table\Fields\Text;
use Yaro\Jarboe\Table\Repositories\ModelRepository;
use Yaro\Jarboe\Table\Repositories\PreferencesRepository;
use Yaro\Jarboe\Table\Toolbar\AbstractTool;
use Yaro\Jarboe\Table\Toolbar\Interfaces\ToolInterface;

class CRUD
{
    const BASE_URL_DELIMITER = '/~/';

    private $fields = [];
    private $actions;
    private $model = '';
    private $repo;
    private $preferences;
    private $tableIdentifier;
    private $rawPerPage;
    private $columns = [];
    private $formClass = 'col-sm-12 col-md-12 col-lg-12';
    private $toolbar = [];
    private $locales = [];
    private $batchCheckboxesEnabled = false;
    private $sortableWeightField = null;
    private $softDeleteEnabled = false;

    public function __construct(ModelRepository $repo, PreferencesRepository $preferences, ActionsContainer $actions)
    {
        $this->repo = $repo;
        $this->preferences = $preferences;
        $this->actions = $actions;
    }

    public function formClass(string $class = null)
    {
        if (!is_null($class)) {
            $this->formClass = $class;
        }

        return $this->formClass;
    }

    public function getRawPerPage()
    {
        return $this->rawPerPage;
    }

    /**
     * @param string|AbstractField $column
     */
    public function addColumn($column)
    {
        $this->columns[] = $column;
    }

    public function getColumns()
    {
        return $this->columns;
    }

    /**
     * Get columns as field objects, or fields if there are no columns.
     *
     * @return array
     */
    public function getColumnsAsFields()
    {
        $columns = [];
        foreach ($this->getColumns() as $column) {
            if (!is_object($column)) {
                $column = $this->getFieldByName($column) ?: $this->makeDefaultColumnField($column);
            }

            if ($column) {
                $columns[] = $column;
            }
        }

        return $columns ?: $this->getFields();
    }

    /**
     * Get list of columns that initialized as field object.
     *
     * @return array
     */
    public function getColumnsWithoutRelatedField()
    {
        $columns = [];
        foreach ($this->getColumns() as $column) {
            if (is_object($column)) {
                $columns[] = $column;
            }
        }

        return $columns;
    }

    public function getAllFieldObjects()
    {
        $fieldsAndColumns = array_merge(
            $this->getFieldsWithoutMarkup(),
            $this->getColumnsWithoutRelatedField()
        );

        return $fieldsAndColumns;
    }

    /**
     * @param $name
     * @return null|AbstractField
     */
    public function getFieldByName($name)
    {
        $fields = $this->getFieldsWithoutMarkup();
        foreach ($fields as $field) {
            if ($field->name() === $name) {
                return $field;
            }
        }

        return null;
    }

    public function addField(AbstractField $field)
    {
        $this->fields[] = $field;
    }

    public function getFields()
    {
        return $this->fields;
    }

    public function getFieldsWithoutMarkup(): array
    {
        $fields = [];
        foreach ($this->getFields() as $field) {
            $this->extractField($field, $fields);
        }

        return $fields;
    }

    private function extractField(AbstractField $field, &$fields)
    {
        if (!$field->isMarkupRow()) {
            $fields[] = $field;
            return;
        }

        foreach ($field->getFields() as $field) {
            $this->extractField($field, $fields);
        }
    }

    public function getTabs($skipHiddenType = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $tabs = [];
        foreach ($this->getFields() as $field) {
            if ($skipHiddenType && $field->hidden($skipHiddenType)) {
                continue;
            }
            $tabs[$field->getTab()][] = $field;
        }

        $this->moveDefaultTabToEnd($tabs);

        return $tabs;
    }

    private function moveDefaultTabToEnd(&$tabs)
    {
        $defaultTab = AbstractField::DEFAULT_TAB_IDENT;
        if (!array_key_exists($defaultTab, $tabs)) {
            return;
        }

        $defaultTabFields = $tabs[$defaultTab];
        unset($tabs[$defaultTab]);
        $tabs[$defaultTab] = $defaultTabFields;
    }

    public function setModel($model)
    {
        $this->model = $model;

        return $this;
    }

    public function repo()
    {
        $this->repo->setCrud($this);

        return $this->repo;
    }

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

    /**
     * @param int|array $perPage
     */
    public function paginate($perPage)
    {
        $this->rawPerPage = $perPage;

        $storedPerPage = $this->getPerPageParam();
        if (is_array($perPage)) {
            $perPage = array_shift($perPage);
        }
        if (!$storedPerPage) {
            $this->setPerPageParam($perPage ?: $this->repo()->perPage());
            $storedPerPage = $perPage;
        }
        $this->repo()->perPage($storedPerPage);

        return $this;
    }

    public function order(string $column, string $direction)
    {
        $this->repo()->order($column, $direction);

        return $this;
    }

    public function filter(\Closure $callback)
    {
        $this->repo()->filter($callback);

        return $this;
    }

    public function getModel()
    {
        return $this->model;
    }

    public function hasAnyFieldFilter()
    {
        foreach ($this->getColumnsAsFields() as $field) {
            if (!$field->hidden('list') && $field->filter()) {
                return true;
            }
        }

        return false;
    }

    public function editUrl($id)
    {
        return sprintf('%s%s%s', $this->baseUrl(), self::BASE_URL_DELIMITER, $id);
    }

    public function createUrl()
    {
        return sprintf('%s%screate', $this->baseUrl(), self::BASE_URL_DELIMITER);
    }

    public function deleteUrl($id)
    {
        return sprintf('%s%s%s/delete', $this->baseUrl(), self::BASE_URL_DELIMITER, $id);
    }

    public function restoreUrl($id)
    {
        return sprintf('%s%s%s/restore', $this->baseUrl(), self::BASE_URL_DELIMITER, $id);
    }

    public function forceDeleteUrl($id)
    {
        return sprintf('%s%s%s/force-delete', $this->baseUrl(), self::BASE_URL_DELIMITER, $id);
    }

    public function toolbarUrl($identifier)
    {
        return sprintf('%s%stoolbar/%s', $this->baseUrl(), self::BASE_URL_DELIMITER, $identifier);
    }

    public function listUrl()
    {
        return $this->baseUrl();
    }

    public function perPageUrl($perPage)
    {
        return sprintf('%s%sper-page/%s', $this->baseUrl(), self::BASE_URL_DELIMITER, $perPage);
    }

    public function searchUrl()
    {
        return sprintf('%s%ssearch', $this->baseUrl(), self::BASE_URL_DELIMITER);
    }

    public function relationSearchUrl()
    {
        return sprintf('%s%ssearch/relation', $this->baseUrl(), self::BASE_URL_DELIMITER);
    }

    public function inlineUrl()
    {
        return sprintf('%s%sinline', $this->baseUrl(), self::BASE_URL_DELIMITER);
    }

    public function orderUrl($column, $direction)
    {
        return sprintf('%s%sorder/%s/%s', $this->baseUrl(), self::BASE_URL_DELIMITER, $column, $direction);
    }

    public function reorderUrl()
    {
        return sprintf('%s%sreorder/switch', $this->baseUrl(), self::BASE_URL_DELIMITER);
    }

    public function reorderMoveItemUrl($id)
    {
        return sprintf('%s%sreorder/move/%s', $this->baseUrl(), self::BASE_URL_DELIMITER, $id);
    }

    public function baseUrl()
    {
        $chunks = explode(self::BASE_URL_DELIMITER, request()->url());

        return rtrim($chunks[0], '/');
    }

    /**
     * @param null $ident
     * @return mixed|void
     */
    public function tableIdentifier($ident = null)
    {
        if (is_null($ident)) {
            return $this->tableIdentifier;
        }

        $this->tableIdentifier = $ident;
    }

    public function saveSearchFilterParams(array $params)
    {
        $this->preferences()->saveSearchFilterParams($this->tableIdentifier(), $params);
    }

    public function getOrderFilterParam($column)
    {
        return $this->preferences()->getOrderFilterParam($this->tableIdentifier(), $column);
    }

    public function saveOrderFilterParam($column, $direction)
    {
        $this->preferences()->saveOrderFilterParam($this->tableIdentifier(), $column, $direction);
    }

    public function getPerPageParam()
    {
        return $this->preferences()->getPerPageParam($this->tableIdentifier());
    }

    public function setPerPageParam($perPage)
    {
        $this->preferences()->setPerPageParam($this->tableIdentifier(), $perPage);
    }

    public function getCurrentLocale()
    {
        return $this->preferences()->getCurrentLocale($this->tableIdentifier()) ?: key($this->getLocales());
    }

    public function saveCurrentLocale($locale)
    {
        $this->preferences()->saveCurrentLocale($this->tableIdentifier(), $locale);
    }

    /**
     * @param $ident
     * @throws \RuntimeException
     * @return AbstractTool
     */
    public function getTool($ident)
    {
        if (array_key_exists($ident, $this->toolbar)) {
            return $this->toolbar[$ident];
        }

        throw new \RuntimeException('Not allowed toolbar');
    }

    public function addTool(ToolInterface $tool)
    {
        $this->toolbar[$tool->identifier()] = $tool;
    }

    public function getTools()
    {
        return $this->toolbar;
    }

    public function getActiveHeaderToolbarTools()
    {
        $list = [];
        /** @var ToolInterface $tool */
        foreach ($this->toolbar as $tool) {
            if ($tool->position() == ToolInterface::POSITION_HEADER && $tool->check()) {
                $list[] = $tool;
            }
        }

        return $list;
    }

    public function getActiveBodyToolbarToolsOnTop()
    {
        return $this->getActiveBodyToolbarTools(ToolInterface::POSITION_BODY_TOP);
    }

    public function getActiveBodyToolbarToolsOnBottom()
    {
        return $this->getActiveBodyToolbarTools(ToolInterface::POSITION_BODY_BOTTOM);
    }

    public function getActiveBodyToolbarTools($position)
    {
        $list = [];
        /** @var ToolInterface $tool */
        foreach ($this->toolbar as $tool) {
            $isPositioned = $tool->position() == $position || $tool->position() == ToolInterface::POSITION_BODY_BOTH;
            if ($isPositioned && $tool->check()) {
                $list[] = $tool;
            }
        }

        return $list;
    }

    public function getTabErrorsCount($tabTitle, $errors)
    {
        $count = 0;
        $tabs = $this->getTabs();
        $fields = $tabs[$tabTitle];

        foreach ($fields as $field) {
            $count += count($errors->get($field->name()));
        }

        return $count;
    }

    public function locales(array $locales)
    {
        $this->normalizeLocales($locales);
        $this->locales = $locales;

        return $this;
    }

    public function getLocales()
    {
        return $this->locales;
    }

    // TODO: move helper to trait or smth
    private function isAssociativeArray(array $array)
    {
        if ($array === []) {
            return false;
        }

        return array_keys($array) !== range(0, count($array) - 1);
    }

    private function normalizeLocales(array &$locales)
    {
        if (!$this->isAssociativeArray($locales)) {
            $locales = array_combine(
                array_values($locales),
                array_values($locales)
            );
        }
    }

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

    public function enableBatchCheckboxes(bool $enabled = true)
    {
        $this->batchCheckboxesEnabled = $enabled;
    }

    public function isBatchCheckboxesEnabled()
    {
        return $this->batchCheckboxesEnabled;
    }

    public function enableSortableByWeight(string $field)
    {
        $this->sortableWeightField = $field;
    }

    public function isSortableByWeight()
    {
        return (bool) $this->getSortableWeightFieldName();
    }

    public function isSortableByWeightActive()
    {
        return $this->preferences()->isSortableByWeightActive($this->tableIdentifier());
    }

    public function getSortableWeightFieldName()
    {
        return $this->sortableWeightField;
    }

    public function setSortableOrderState(bool $active)
    {
        $this->preferences()->setSortableOrderState($this->tableIdentifier(), $active);
    }

    public function enableSoftDelete(bool $enabled = true)
    {
        $this->softDeleteEnabled = $enabled;
    }

    public function isSoftDeleteEnabled(): bool
    {
        return $this->softDeleteEnabled;
    }

    private function makeDefaultColumnField($column)
    {
        return Text::make($column);
    }
}