kalanis\kw_connect\dibi\Connector

Complexity

Total Complexity

14

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getTotalCount()	0	5	1
A	parseData()	0	4	2
A	setFiltering()	0	8	2
A	fetchData()	0	8	3
A	getFilterFactory()	0	3	1
A	getTranslated()	0	3	1
A	__construct()	0	4	1
A	setOrdering()	0	3	1
A	setPagination()	0	4	1
A	getPrimaryKey()	0	3	1

<?php

namespace kalanis\kw_connect\dibi;


use Dibi\Fluent;
use Dibi\Row as DRow;
use kalanis\kw_connect\core\AConnector;
use kalanis\kw_connect\core\Interfaces\IFilterFactory;
use kalanis\kw_connect\core\Interfaces\IFilterSubs;
use kalanis\kw_connect\core\Interfaces\IIterableConnector;
use kalanis\kw_connect\core\Interfaces\IOrder;
use kalanis\kw_connect\core\Interfaces\IRow;


/**
 * Class Connector
 * @package kalanis\kw_connect\dibi
 * Data source is Dibi\Fluent
 */
class Connector extends AConnector implements IIterableConnector
{
    protected Fluent $dibiFluent;
    protected string $primaryKey;
    /** @var array<int, array<string>> */
    protected array $sorters = [];
    protected ?int $limit = null;
    protected ?int $offset = null;
    /** @var DRow[] */
    protected array $rawData = [];
    protected bool $dataFetched = false;

    public function __construct(Fluent $dataSource, string $primaryKey)
    {
        $this->dibiFluent = $dataSource;
        $this->primaryKey = $primaryKey;
    }

    public function setFiltering(string $colName, string $filterType, $value): void
    {
        $type = $this->getFilterFactory()->getFilter($filterType);
        if ($type instanceof IFilterSubs) {
            $type->addFilterFactory($this->getFilterFactory());
        }
        $type->setDataSource($this->dibiFluent);
        $type->setFiltering($colName, $value);
    }

    public function setOrdering(string $colName, string $direction): void
    {
        $this->sorters[] = [$colName, $direction];
    }

    public function setPagination(?int $offset, ?int $limit): void
    {
        $this->offset = $offset;
        $this->limit = $limit;
    }

    public function getTotalCount(): int
    {
        // count needs only filtered content
        $dataSource = clone $this->dibiFluent;
        return $dataSource->count();
    }

    public function fetchData(): void
    {
        foreach (array_reverse($this->sorters) as list($colName, $direction)) {
            $dir = IOrder::ORDER_ASC == $direction ? 'ASC' : 'DESC' ;
            $this->dibiFluent->orderBy($colName, $dir);
        }
        $this->rawData = $this->dibiFluent->fetchAll($this->offset, $this->limit);
        $this->parseData();
    }

    protected function parseData(): void
    {
        foreach ($this->rawData as $mapper) {
            $this->translatedData[$this->getPrimaryKey($mapper)] = $this->getTranslated($mapper);
        }
    }

    protected function getTranslated(DRow $data): IRow
    {
        return new Row($data);
    }

    protected function getPrimaryKey(DRow $record): string
    {
        return strval($record->offsetGet($this->primaryKey));
    }

    public function getFilterFactory(): IFilterFactory
    {
        return Filters\Factory::getInstance();
    }
}