SimpleEventStoreManager\Infrastructure\Persistence\DbalEventStoreRepository

Complexity

Total Complexity

12

Size/Duplication

Total Lines	158
Duplicated Lines	100 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	save()	33	33	2
A	__construct()	3	3	1
A	buildEventAggregate()	7	7	2
A	count()	8	8	1
A	buildEventAggregateAsArray()	16	16	2
A	buildEventAggregateAsObject()	15	15	2
B	byUuid()	24	24	2

<?php
/**
 * This file is part of the Simple EventStore Manager package.
 *
 * (c) Mauro Cassani<https://github.com/mauretto78>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace SimpleEventStoreManager\Infrastructure\Persistence;

use Doctrine\DBAL\Connection;
use SimpleEventStoreManager\Domain\Model\Contracts\EventInterface;
use SimpleEventStoreManager\Domain\Model\Contracts\EventStoreRepositoryInterface;
use SimpleEventStoreManager\Domain\Model\Event;
use SimpleEventStoreManager\Domain\Model\AggregateUuid;
use SimpleEventStoreManager\Infrastructure\Drivers\PdoDriver;

class DbalEventStoreRepository implements EventStoreRepositoryInterface

This class seems to be duplicated in your project.

{
    /**
     * @var Connection
     */
    private $connection;

    /**
     * InMemoryEventRepository constructor.
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;
    }

    /**
     * @param AggregateUuid $uuid
     * @param int $returnType
     *
     * @return array|mixed|null
     */
    public function byUuid(AggregateUuid $uuid, $returnType = self::RETURN_AS_ARRAY)
    {
        $uuid = (string) $uuid;
        $query = 'SELECT
                  `uuid`,
                  `version`,
                  `payload`,
                  `type`,
                  `body`,
                  `occurred_on`
                FROM `'.PdoDriver::EVENTSTORE_TABLE_NAME.'` 
                WHERE `uuid` = :uuid
                ORDER BY `occurred_on` ASC';
        $stmt = $this->connection->prepare($query);
        $stmt->bindParam(':uuid', $uuid);
        $stmt->execute();

        $row = $stmt->fetchAll(\PDO::FETCH_ASSOC);

        if (!empty($row)) {
            return $this->buildEventAggregate($row, $returnType);
        }

        return null;
    }

    /**
     * @param array $rows
     * @param $returnType
     *
     * @return array
     */
    private function buildEventAggregate(array $rows, $returnType)
    {
        if ($returnType === self::RETURN_AS_ARRAY) {
            return $this->buildEventAggregateAsArray($rows);
        }

        return $this->buildEventAggregateAsObject($rows);
    }

    /**
     * @param array $rows
     * @return array
     */
    private function buildEventAggregateAsArray(array $rows)
    {
        $returnArray = [];

        foreach ($rows as $row) {
            $returnArray[] = [
                'uuid' => $row['uuid'],
                'version' => $row['version'],
                'payload' => $row['payload'],
                'type' => $row['type'],
                'body' => unserialize($row['body']),
                'occurred_on' => $row['occurred_on'],
            ];
        }

        return $returnArray;
    }

    /**
     * @param array $rows
     * @return array
     */
    private function buildEventAggregateAsObject(array $rows)
    {
        $returnObject = [];

        foreach ($rows as $row) {
            $returnObject[] = new Event(
                new AggregateUuid($row['uuid']),
                $row['type'],
                unserialize($row['body']),
                $row['version'],
                $row['occurred_on']
            );
        }

        return $returnObject;
    }

    /**
     * @param AggregateUuid $uuid
     *
     * @return int
     */
    public function count(AggregateUuid $uuid)
    {
        $sql = 'SELECT id FROM `'.PdoDriver::EVENTSTORE_TABLE_NAME.'` WHERE `uuid` = :uuid';
        $stmt = $this->connection->prepare($sql);
        $stmt->bindParam(':uuid', $uuid);
        $stmt->execute();

        return $stmt->rowCount();
    }

    /**
     * @param EventInterface $event
     *
     * @return mixed
     */
    public function save(EventInterface $event)
    {
        $uuid = (string) $event->uuid();
        $version = ($this->count($event->uuid())) ?: 0;
        $type = $event->type();
        $payload = $event->payload();
        $body = serialize($event->body());
        $occurredOn = $event->occurredOn()->format('Y-m-d H:i:s.u');

        $sql = 'INSERT INTO `'.PdoDriver::EVENTSTORE_TABLE_NAME.'` (
                    `uuid`,
                    `version`,
                    `payload`,
                    `type`,
                    `body`,
                    `occurred_on`
                  ) VALUES (
                    :uuid,
                    :version, 
                    :payload, 
                    :type,
                    :body, 
                    :occurred_on
            )';

        $stmt = $this->connection->prepare($sql);
        $stmt->bindParam(':uuid', $uuid);
        $stmt->bindParam(':version', $version);
        $stmt->bindParam(':payload', $payload);
        $stmt->bindParam(':type', $type);
        $stmt->bindParam(':body', $body);
        $stmt->bindParam(':occurred_on', $occurredOn);
        $stmt->execute();
    }
}