Recurrence\Model\Recurrence

Complexity

Total Complexity

31

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Test Coverage

Coverage

68.08%

Importance

Changes	1
Bugs	1	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getCount()	0	3	1
A	addConstraint()	0	9	2
A	setFrequency()	0	5	1
A	removeConstraint()	0	13	3
A	hasConstraints()	0	3	1
A	getConstraints()	0	3	1
A	__construct()	0	3	1
A	getInterval()	0	3	1
A	hasCount()	0	3	1
A	setPeriodStartAt()	0	5	1
A	hasPeriodEndAt()	0	3	1
A	getPeriodEndAt()	0	3	1
A	setCount()	0	5	1
A	getFrequency()	0	3	1
A	setInterval()	0	5	1
A	hasProviderConstraint()	0	9	3
A	setPeriodEndAt()	0	5	1
A	setConstraints()	0	9	2
A	getPeriodStartAt()	0	3	1
A	hasConstraint()	0	9	3
A	hasDatetimeConstraint()	0	9	3

<?php

namespace Recurrence\Model;

use Recurrence\Constraint\DatetimeConstraint\DatetimeConstraintInterface;
use Recurrence\Constraint\ProviderConstraint\ProviderConstraintInterface;
use Recurrence\Constraint\RecurrenceConstraintInterface;

class Recurrence
{
    private ?Frequency $frequency = null;
    private \Datetime $periodStartAt;
    private ?\Datetime $periodEndAt = null;
    private int $interval = 1;
    private ?int $count = null;
    private array $constraints = [];

    public function __construct()
    {
        $this->setPeriodStartAt(new \DateTime());
    }

    public function setPeriodStartAt(\Datetime $periodStartAt): self
    {
        $this->periodStartAt = $periodStartAt;

        return $this;
    }

    public function getPeriodStartAt(): \Datetime
    {
        return $this->periodStartAt;
    }

    public function setPeriodEndAt(\Datetime $periodEndAt): self
    {
        $this->periodEndAt = $periodEndAt;

        return $this;
    }

    public function getPeriodEndAt(): ?\Datetime
    {
        return $this->periodEndAt;
    }

    public function hasPeriodEndAt(): bool
    {
        return $this->periodEndAt !== null;
    }

    public function setFrequency(Frequency $frequency): self
    {
        $this->frequency = $frequency;

        return $this;
    }

    public function getFrequency(): ?Frequency
    {
        return $this->frequency;
    }

    public function getInterval(): int
    {
        return $this->interval;
    }

    public function setInterval(int $interval): self
    {
        $this->interval = $interval;

        return $this;
    }

    public function getCount(): ?int
    {
        return $this->count;
    }

    public function hasCount(): bool
    {
        return $this->count !== null;
    }

    public function setCount(int $count): self
    {
        $this->count = $count;

        return $this;
    }

    public function getConstraints(): array
    {
        return $this->constraints;
    }

    public function setConstraints(array $constraints): self
    {
        $this->constraints = [];

        foreach ($constraints as $constraint) {
            $this->addConstraint($constraint);
        }

        return $this;
    }

    public function hasConstraints(): bool
    {
        return !empty($this->constraints);
    }

    public function addConstraint(RecurrenceConstraintInterface $constraint): self
    {
        if ($this->hasConstraint(get_class($constraint))) {
            throw new \InvalidArgumentException(sprintf('Duplicate constraint [%s]', get_class($constraint)));
        }

        $this->constraints[] = $constraint;

        return $this;
    }

    public function removeConstraint(string $constraintClassName): self
    {
        foreach ($this->constraints as $key => $constraint) {
            if (get_class($constraint) == $constraintClassName) {
                unset($this->constraints[$key]);

                break;
            }
        }

        $this->constraints = array_values($this->constraints);

        return $this;
    }

    public function hasConstraint(string $constraintClassName): bool
    {
        foreach ($this->constraints as $key => $constraint) {
            if (get_class($constraint) == $constraintClassName) {
                return true;
            }
        }

        return false;
    }

    public function hasProviderConstraint(): bool
    {
        foreach ($this->constraints as $key => $constraint) {
            if ($constraint instanceof ProviderConstraintInterface) {
                return true;
            }
        }

        return false;
    }

    public function hasDatetimeConstraint(): bool
    {
        foreach ($this->constraints as $key => $constraint) {
            if ($constraint instanceof DatetimeConstraintInterface) {
                return true;
            }
        }

        return false;
    }
}