Psi\Component\Grid\GridViewFactory

Complexity

Total Complexity

17

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
C	createView()	0	64	10
A	getNumberOfRecords()	0	8	2
B	resolveOrderings()	0	24	4

<?php

declare(strict_types=1);

namespace Psi\Component\Grid;

use Psi\Component\Grid\Metadata\GridMetadata;
use Psi\Component\Grid\View\Grid as GridView;
use Psi\Component\ObjectAgent\AgentInterface;
use Psi\Component\ObjectAgent\Query\Composite;
use Psi\Component\ObjectAgent\Query\Query;

class GridViewFactory
{
    /**
     * @var ColumnFactory
     */
    private $columnFactory;

    /**
     * @var FilterFactory
     */
    private $filterFactory;

    public function __construct(
        ColumnFactory $columnFactory,
        FilterBarFactoryInterface $filterFactory,
        QueryFactory $queryFactory
    ) {
        $this->columnFactory = $columnFactory;
        $this->filterFactory = $filterFactory;

It seems like $filterFactory of type object<Psi\Component\Grid\FilterBarFactoryInterface> is incompatible with the declared type object<Psi\Component\Grid\FilterFactory> of property $filterFactory.

        $this->queryFactory = $queryFactory;

The property queryFactory does not exist. Did you maybe forget to declare it?

    }

    public function createView(AgentInterface $agent, GridContext $gridContext, GridMetadata $gridMetadata): GridView
    {
        // create the filter form based on the metadata and submit any data.
        $filterForm = $this->filterFactory->createForm($gridMetadata, $agent->getCapabilities());

        if ($gridContext->getFilter()) {
            $filterForm->submit($gridContext->getFilter());

            if (false === $filterForm->isValid()) {
                foreach ($filterForm->getErrors(true) as $name => $error) {
                    $message[] = sprintf(

$message was never initialized. Although not strictly required by PHP, it is generally a good practice to add $message = array(); before regardless.

                        '%s %s',
                        $error->getOrigin()->getPropertyPath(),
                        $error->getMessage()
                    );
                }

                throw new \InvalidArgumentException(sprintf(
                    'Invalid filter form: ' . implode(', ', $message)
                ));
            }
        }

        $criteria = $this->filterFactory->createExpression($gridMetadata, $filterForm->getData());

        if ($criteria instanceof Composite && empty($criteria->getExpressions())) {
            $criteria = null;
        }

        $criteria = [
            'criteria' => $criteria,
            'orderings' => $this->resolveOrderings($gridContext->getOrderings(), $gridMetadata),
            'firstResult' => $gridContext->getPageOffset(),
            'maxResults' => $gridContext->isPaginated() ? $gridContext->getPageSize() : null,
        ];

        if ($gridMetadata->hasQuery()) {
            $query = $this->queryFactory->createQuery($agent->getCanonicalClassFqn($gridContext->getClassFqn()), $gridMetadata->getQuery());
            $criteria['selects'] = $query->getSelects();
            $criteria['joins'] = $query->getJoins();

            if ($query->hasExpression()) {
                if (null === $criteria['criteria']) {
                    $criteria['criteria'] = $query->getExpression();
                } else {
                    // filter and user criterias need to be combined
                    $criteria['criteria'] = new Composite(Composite::AND, [$query->getExpression(), $criteria['criteria']]);
                }
            }
        }

        // create the query and get the data collection from the object-agent.
        $query = Query::create($gridContext->getClassFqn(), $criteria);
        $collection = new \IteratorIterator($agent->query($query));

        return new View\Grid(
            $gridContext->getClassFqn(),
            $gridMetadata->getName(),
            new View\Table($this->columnFactory, $gridMetadata, $gridContext, $collection, $gridContext),

The call to Table::__construct() has too many arguments starting with $gridContext.

            new View\Paginator($gridContext, count($collection), $this->getNumberOfRecords($agent, $query)),
            new View\FilterBar($filterForm->createView(), $gridContext),
            new View\ActionBar($gridMetadata)
        );
    }

    private function getNumberOfRecords(AgentInterface $agent, Query $query)
    {
        if (false === $agent->getCapabilities()->canQueryCount()) {
            return;
        }

        return $agent->queryCount($query);
    }

    private function resolveOrderings(array $orderings, GridMetadata $metadata)
    {
        $columns = $metadata->getColumns();
        $realOrderings = [];

        foreach ($orderings as $columnName => $direction) {
            if (!isset($columns[$columnName])) {
                throw new \RuntimeException(sprintf(
                    'Invalid column "%s"', $columnName
                ));
            }

            $column = $columns[$columnName];
            $options = $column->getOptions();

            if (!isset($options['sort_field'])) {
                $options['sort_field'] = $columnName;
            }

            $realOrderings[$options['sort_field']] = $direction;
        }

        return $realOrderings;
    }
}