Indigerd\Repository\Repository

Complexity

Total Complexity

35

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

57.45%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getRelation()	0	11	3
A	normalizeResultSet()	0	18	4
A	applyRelationStrategies()	0	10	2
A	findAll()	0	19	5
A	aggregate()	0	4	1
A	aggregateveMax()	0	4	1
A	findOne()	0	17	4
A	create()	0	4	1
A	populate()	0	4	1
A	aggregateCount()	0	4	1
A	aggregateSum()	0	4	1
A	aggregateAverage()	0	4	1
A	aggregateMin()	0	4	1
A	validateModelClass()	0	6	2
A	insert()	0	10	2
A	update()	0	6	1
A	delete()	0	6	1
A	updateAll()	0	4	1
A	deleteAll()	0	4	1

<?php declare(strict_types=1);

namespace Indigerd\Repository;

use Indigerd\Hydrator\Hydrator;
use Indigerd\Hydrator\Strategy\ObjectStrategy;
use Indigerd\Repository\Exception\InsertException;
use Indigerd\Repository\Exception\InvalidModelClassException;
use Indigerd\Repository\Exception\NotFoundException;
use Indigerd\Repository\Relation\Relation;
use Indigerd\Repository\Relation\RelationCollection;
use Indigerd\Repository\TableGateway\TableGatewayInterface;

class Repository implements RepositoryInterface
{
    protected $tableGateway;

    protected $hydrator;

    protected $modelClass;

    protected $relationCollection;

    public function __construct(
        TableGatewayInterface $tableGateway,
        Hydrator $hydrator,
        string $modelClass,
        RelationCollection $relationCollection = null
    ) {
        $this->tableGateway = $tableGateway;
        $this->hydrator = $hydrator;
        $this->modelClass = $modelClass;
        $this->relationCollection = $relationCollection;
    }

    protected function getRelation($name): Relation
    {
        if (\is_null($this->relationCollection)) {
            throw new \InvalidArgumentException("Relation $name do not exist");
        }
        $relation = $this->relationCollection->getRelationByProperty($name);
        if (!($relation instanceof Relation)) {
            throw new \InvalidArgumentException("Relation $name do not exist");
        }
        return $relation;
    }

    protected function normalizeResultSet(array $data, array $relations): array
    {
        /**
         * @var string $property
         * @var Relation $relation
         */
        foreach ($relations as $property => $relation) {
            $relationData = [];
            foreach ($data as $field => $value) {
                if (\strpos($field, $relation->getRelatedCollection() . '_relation_') === 0) {
                    $fieldName = \str_replace($relation->getRelatedCollection() . '_relation_', '', $field);
                    $relationData[$fieldName] = $value;
                }
            }
            $data[$property] = $relationData;
        }
        return $data;
    }

    protected function applyRelationStrategies(array $relations)
    {
        /**
         * @var string $property
         * @var Relation $relation
         */
        foreach ($relations as $property => $relation) {
            $this->hydrator->addStrategy($property, new ObjectStrategy($this->hydrator, $relation->getRelatedModel()));
        }
    }

    public function findOne(array $conditions = [], array $with = []): object
    {
        $relations = [];
        foreach ($with as $relationName) {
            $relations[$relationName] = $this->getRelation($relationName);
        }
        $data = $this->tableGateway->queryOne($conditions, $relations);
        if (!\is_array($data)) {
            throw new NotFoundException();
        }
        if (!empty($relations)) {
            $data = $this->normalizeResultSet($data, $relations);
            $this->applyRelationStrategies($relations);
        }
        $result = $this->hydrator->hydrate($this->modelClass, $data);
        return $result;
    }

    public function findAll(array $conditions = [], array $order = [], int $limit = 0, int $offset = 0, array $with = []): array
    {
        $result = [];
        $relations = [];
        foreach ($with as $relationName) {
            $relations[$relationName] = $this->getRelation($relationName);
        }
        if (!empty($relations)) {
            $this->applyRelationStrategies($relations);
        }
        $data = $this->tableGateway->queryAll($conditions, $order, $limit, $offset, $relations);
        foreach ($data as $row) {
            if (!empty($relations)) {
                $row = $this->normalizeResultSet($row, $relations);
            }
            $result[] = $this->hydrator->hydrate($this->modelClass, $row);
        }
        return $result;
    }

    public function aggregate(string $expression, array $conditions): string
    {
        return $this->tableGateway->aggregate($expression, $conditions);
    }

    public function aggregateCount(string $field = '', array $conditions = []): string
    {
        return $this->tableGateway->aggregateCount($field, $conditions);
    }

    public function aggregateSum(string $field, array $conditions): string
    {
        return $this->tableGateway->aggregateSum($field, $conditions);
    }

    public function aggregateAverage(string $field, array $conditions): string
    {
        return $this->tableGateway->aggregateAverage($field, $conditions);
    }

    public function aggregateMin(string $field, array $conditions): string
    {
        return $this->tableGateway->aggregateMin($field, $conditions);
    }

    public function aggregateveMax(string $field, array $conditions): string
    {
        return $this->tableGateway->aggregateMax($field, $conditions);
    }

    protected function validateModelClass(object $model)
    {
        if (!($model instanceof $this->modelClass)) {
            throw new InvalidModelClassException('Invalid model class: ' . get_class($model) . '. Expected ' . $this->modelClass);
        }
    }

    public function insert(object $model): void
    {
        $this->validateModelClass($model);
        $data = $this->hydrator->extract($model);
        $primaryKeys = $this->tableGateway->insert($data);
        if (!\is_array($primaryKeys)) {
            throw new InsertException($data);
        }
        $this->hydrator->hydrate($model, $primaryKeys);
    }

    public function update(object $model): void
    {
        $this->validateModelClass($model);
        $data = $this->hydrator->extract($model);
        $this->tableGateway->updateOne($data);
    }

    public function delete(object $model): void
    {
        $this->validateModelClass($model);
        $data = $this->hydrator->extract($model);
        $this->tableGateway->deleteOne($data);
    }

    public function updateAll(array $data, array $conditions): int
    {
        return $this->tableGateway->updateAll($data, $conditions);
    }

    public function deleteAll(array $conditions): int
    {
        return $this->tableGateway->deleteAll($conditions);
    }

    /**
     * @param array $data
     * @return object
     */
    public function create(array $data = []): object
    {
        return $this->hydrator->hydrate($this->modelClass, $data);
    }

    /**
     * @param object $entity
     * @param array $data
     */
    public function populate(object $entity, array $data): void
    {
        $this->hydrator->hydrate($entity, $data);
    }
}