Passing read models (value objects representing state) / domain service to aggregate methods about php-ddd HOT 6 OPEN

final class ServiceContract extends AggregateRoot
{
    public static function enter(
        ServiceContractId $anId, PersonId $anPersonId, PersonalData $aPersonalData,
        AssignmentPeriod $anAssignmentPeriod, WorkweekDays $aWorkweekDays, WeeklyWorkingHours $aWeeklyWorkingHours,
        JobFunctionId $aJobFunctionId, string $aJobFunctionName,
        AgencyId $anAgencyId, string $anAgencyName,
        WorkplaceId $aWorkplaceId, string $aWorkplaceName,
        OverlapDetectorServiceInterface $overlapDetector
    ): ServiceContract
    {
        Assert::notEmpty($aJobFunctionName);
        Assert::notEmpty($anAgencyName);
        Assert::notEmpty($aWorkplaceName);

        $overlapDetector->ofPersonId($anPersonId, $anId, $anAssignmentPeriod);

        $self = new self();
        $self->recordThat(ServiceContractEntered::withData(
            $anId, $anPersonId, $aPersonalData,
            $anAssignmentPeriod, $aWorkweekDays, $aWeeklyWorkingHours,
            $aJobFunctionId, $aJobFunctionName, $anAgencyId, $anAgencyName,
            $aWorkplaceId, $aWorkplaceName, new DateTimeImmutable()
        ));

        return $self;
    }

final class OverlapDetector implements OverlapDetectorServiceInterface
{
    public function ofPersonId(PersonId $personId, ServiceContractId $currentContractId, AssignmentPeriod $currentPeriod): array
    {
        $enteredContracts = $this->contractTermRepository->ofPersonId($personId()->toString());

        foreach ($enteredContracts as $enteredContract) {
            if ($currentPeriod->overlapsWith($enteredContract->assignmentPeriod())) {
                throw new AssignmentPeriodOverlapsException();
            }
        }
    }
}

final class Person extends AggregateRoot
{
    private $personId;

    private $personalData;

    private $enteredContracts; // From applying "ServiceContractEntered" event from the `ServiceContract` A+ES

    public function enterServiceContract(ServiceContractId $serviceContractId, AssignmentPeriod $period, ...other arguments...): ServiceContract
    {
        foreach ($this->enteredContracts as $enteredContract) {
            if ($period->overlapsWith($enteredContract->assignmentPeriod())) {
                throw new AssignmentPeriodOverlapsException();
            }
        }

        return ServiceContract::enter(
            $serviceContractId
            $this->personId,
            $this->personalData,
            $period,
            WorkweekDays::fromArray(["monday","tuesday","wednesday","thursday","friday"]),
            WeeklyWorkingHours::fromFloat(40),
            JobFunctionId::fromInteger(4), 'Qualitätsprüfer/in',
            AgencyId::fromString('904c0436-4226-4725-afbe-14526906afdb'), 'Office People',
            WorkplaceId::fromString('1e522e02-b28d-44d2-a3fb-4efbdacec462'), 'Bratislava'
        );
    }
}

final class ServiceContract extends AggregateRoot
{
    public static function enter(
        ServiceContractId $anId, PersonId $anPersonId, PersonalData $aPersonalData,
        AssignmentPeriod $anAssignmentPeriod, WorkweekDays $aWorkweekDays, WeeklyWorkingHours $aWeeklyWorkingHours,
        JobFunctionId $aJobFunctionId, string $aJobFunctionName,
        AgencyId $anAgencyId, string $anAgencyName,
        WorkplaceId $aWorkplaceId, string $aWorkplaceName
    ): ServiceContract
    {
        Assert::notEmpty($aJobFunctionName);
        Assert::notEmpty($anAgencyName);
        Assert::notEmpty($aWorkplaceName);

        $self = new self();
        $self->recordThat(ServiceContractEntered::withData(
            $anId, $anPersonId, $aPersonalData,
            $anAssignmentPeriod, $aWorkweekDays, $aWeeklyWorkingHours,
            $aJobFunctionId, $aJobFunctionName, $anAgencyId, $anAgencyName,
            $aWorkplaceId, $aWorkplaceName, new DateTimeImmutable()
        ));

        return $self;
    }

final class ServiceContract extends AggregateRoot
{
    public function mergeWith(array $mergeWithContractIds, array $enteredContracts): void
    {
        Assert::minCount($mergeWithContractIds, 2);

        /** @var Details $contractsToMerge */
        $contractsToMerge = [];
        $surroundingAssignmentPeriod = $this->assignmentPeriod;

        foreach ($mergeWithContractIds as $mergeWithContractId) {
            if (!key_exists($mergeWithContractId->toString(), $enteredContracts)) {
                throw new InvalidServiceContractProvidedForMergingException();
            }

            if ($this->isMergedWith($mergeWithContractId)) {
                throw new AlreadyMergedWithServiceContractException();
            }

            $contractToMerge = $enteredContracts[$mergeWithContractId->toString()];

            // Calculate surrounding period for all contracts.
            $surroundingAssignmentPeriod = $surroundingAssignmentPeriod->mergeWith($contractToMerge->assignmentPeriod());

            if ($this->id->sameValueAs(ServiceContractId::fromString($contractToMerge->contractId()))) {
                continue;
            }

            $contractsToMerge[] = $contractToMerge;
        }

        if ($this->assignmentPeriod->startDate()->format('Y-m-d') !== $surroundingAssignmentPeriod->startDate()->format('Y-m-d')) {
            // This is not the initial contract
            throw new InvalidInitialServiceContractForMergingException();
        }

        $overlappingEnteredContractIds = [];

        foreach ($enteredContracts as $enteredContract) {
            if ($enteredContract->assignmentPeriod()->overlapsWith($surroundingAssignmentPeriod)) {
                // Handle overlapping contracts only.
                if (!in_array(ServiceContractId::fromString($enteredContract->contractId()), $mergeWithContractIds)) {
                    // Register overlapping contracts that have not been marked for merging.
                    $overlappingEnteredContractIds[] = $enteredContract->contractId();
                }
            }
        }

        if (0 !== count($overlappingEnteredContractIds)) {
            throw new ServiceContractMergeConflictDetectedException();
        }

        foreach ($contractsToMerge as $contractToMerge) {
            $this->recordThat(MergedWithServiceContract::with(
                $this->id,
                ServiceContractId::fromString($contractToMerge->contractId()),
                $surroundingAssignmentPeriod,
                WorkweekDays::fromArray($contractToMerge->workweekDays()),
                WeeklyWorkingHours::fromFloat($contractToMerge->weeklyWorkingHours()),
                JobFunctionId::fromInteger($contractToMerge->jobFunctionId()),
                $contractToMerge->jobFunctionName(),
                AgencyId::fromString($contractToMerge->agencyId()),
                $contractToMerge->agencyName(),
                WorkplaceId::fromString($contractToMerge->workplaceId()),
                $contractToMerge->workplaceName(),
                new DateTimeImmutable()
            ));
        }
    }
}