Shippinno\Notification\Infrastructure\Domain\Model\DoctrineNotificationRepository

Complexity

Total Complexity

11

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

89.47%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	add()	0	13	3
A	markSent()	0	5	1
A	markFailed()	0	5	1
A	persist()	0	7	2
A	notificationOfId()	0	4	1
A	hasNotificationOfDeduplicationKey()	0	4	1
A	unsentNotifications()	0	8	1

<?php
declare(strict_types=1);

namespace Shippinno\Notification\Infrastructure\Domain\Model;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\OptimisticLockException;
use Doctrine\ORM\ORMException;
use LogicException;
use Shippinno\Notification\Domain\Model\DeduplicationKey;
use Shippinno\Notification\Domain\Model\Notification;
use Shippinno\Notification\Domain\Model\NotificationId;
use Shippinno\Notification\Domain\Model\NotificationRepository;

class DoctrineNotificationRepository extends EntityRepository implements NotificationRepository
{
    /**
     * @var bool
     */
    private $isPrecocious;

    /**
     * @param $em
     * @param Mapping\ClassMetadata $class
     */
    public function __construct($em, Mapping\ClassMetadata $class, bool $isPrecocious)
    {
        $this->isPrecocious = $isPrecocious;
        parent::__construct($em, $class);
    }

    /**
     * {@inheritdoc}
     */
    public function add(Notification $notification, bool $precocious = false): void
    {
        $deduplicationKey = $notification->deduplicationKey();
        if (!is_null($deduplicationKey) && $this->hasNotificationOfDeduplicationKey($deduplicationKey)) {
            throw new LogicException(
                sprintf(
                    'Notification of deduplication key (%s) already exists.',
                    $deduplicationKey
                )
            );
        }
        $this->persist($notification);
    }

    /**
     * {@inheritdoc}
     * @throws ORMException
     * @throws OptimisticLockException
     */
    public function markSent(Notification $notification): void
    {
        $notification->markSent();
        $this->persist($notification);
    }

    /**
     * {@inheritdoc}
     * @throws ORMException
     * @throws OptimisticLockException
     */
    public function markFailed(Notification $notification, string $reason): void
    {
        $notification->markFailed($reason);
        $this->persist($notification);
    }

    /**
     * @param Notification $notification
     * @throws ORMException
     * @throws OptimisticLockException
     */
    private function persist(Notification $notification): void
    {
        $this->getEntityManager()->persist($notification);
        if ($this->isPrecocious) {
            $this->getEntityManager()->flush();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function notificationOfId(NotificationId $notificationId): ?Notification
    {
        return $this->find($notificationId);
    }

    /**
     * {@inheritdoc}
     */
    public function hasNotificationOfDeduplicationKey(DeduplicationKey $deduplicationKey): bool
    {
        return !is_null($this->findOneBy(['deduplicationKey' => $deduplicationKey]));
    }

    /**
     * {@inheritdoc}
     */
    public function unsentNotifications(): array
    {
        return $this->createQueryBuilder('n')
            ->where('n.sentAt IS NULL')
            ->orderBy('n.notificationId', 'ASC')
            ->getQuery()
            ->getResult();
    }
}