Cubiche\Domain\EventSourcing\Snapshot\Policy\TimeBasedSnapshottingPolicy

Complexity

Total Complexity

7

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	shouldCreateSnapshot()	0	15	4
A	loadSnapshot()	0	4	1
A	streamName()	0	4	1

<?php
/**
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cubiche\Domain\EventSourcing\Snapshot\Policy;

use Cubiche\Domain\EventSourcing\EventSourcedAggregateRootInterface;
use Cubiche\Domain\EventSourcing\Snapshot\Snapshot;
use Cubiche\Domain\EventSourcing\Snapshot\SnapshotStoreInterface;
use Cubiche\Domain\EventSourcing\Utils\NameResolver;
use Cubiche\Domain\Model\IdInterface;

/**
 * TimeBasedSnapshottingPolicy class.
 *
 * @author Ivannis Suárez Jerez <ivannis.suarez@gmail.com>
 */
class TimeBasedSnapshottingPolicy implements SnapshottingPolicyInterface
{
    /**
     * @var SnapshotStoreInterface
     */
    protected $snapshotStore;

    /**
     * @var string
     */
    protected $threshold;

    /**
     * @var string
     */
    protected $aggregateClassName;

    /**
     * TimeBasedSnapshottingPolicy constructor.
     *
     * @param SnapshotStoreInterface $snapshotStore
     * @param string                 $aggregateClassName
     * @param string                 $threshold
     */
    public function __construct(SnapshotStoreInterface $snapshotStore, $aggregateClassName, $threshold = '1 hour')
    {
        $this->snapshotStore = $snapshotStore;
        $this->threshold = $threshold;

        $this->aggregateClassName = $aggregateClassName;
    }

    /**
     * {@inheritdoc}
     */
    public function shouldCreateSnapshot(EventSourcedAggregateRootInterface $eventSourcedAggregateRoot)
    {
        $recordedEvents = $eventSourcedAggregateRoot->recordedEvents();

        if (count($recordedEvents) > 0) {
            $lastSnapshot = $this->loadSnapshot($eventSourcedAggregateRoot->id());
            $threshold = new \DateTime(date('c', strtotime('-'.$this->threshold)));

            if ($lastSnapshot !== null && $lastSnapshot->createdAt() < $threshold) {
                return true;
            }
        }

        return false;
    }

    /**
     * Load a aggregate snapshot from the storage.
     *
     * @param IdInterface $id
     *
     * @return Snapshot|null
     */
    protected function loadSnapshot(IdInterface $id)
    {
        return $this->snapshotStore->load($this->streamName($id));
    }

    /**
     * @return string
     */
    protected function streamName(IdInterface $id)
    {
        return NameResolver::resolve($this->aggregateClassName, $id);
    }
}