webdevilopers / php-ddd Goto Github PK

<?php

namespace AcmersonnelManagement\Domain\Model\EmploymentContract;

final class EmploymentContract extends AggregateRoot
{
    /** @var EmploymentContractId $employmentContractId */
    private $id;

    /** @var PersonId $personId */
    private $personId;

    /** @var EmploymentPeriod */
    private $employmentPeriod;

    public static function sign(
        EmploymentContractId $anId, PersonId $aPersonId, PersonalData $aPersonalData, ContractType $aContractType,
        DateTimeImmutable $aStartDate, ?DateTimeImmutable $anEndDate, ?DateTimeImmutable $aProbationEndDate,
        WorkerCategory $aWorkerCategory, WageType $aWageType, bool $aWorkingTimeAccount,
        WorkweekDays $aWorkWeekDays, WeeklyWorkingHours $aWeeklyWorkingHours,
        HolidayEntitlement $aHolidayEntitlement, AdditionalLeave $additionalLeave,
        JobFunctionId $aJobFunctionId, string $aJobFunctionName,
        EmployerId $anEmployerId, string $anEmployerName, WorkplaceId $aWorkplaceId, string $aWorkplaceName
    ): EmploymentContract
    {
        $employmentPeriod = EmploymentPeriod::withType($aContractType, $aStartDate, $anEndDate);

        $self = new self();
        $self->recordThat(EmploymentContractSigned::withData(
            $anId, $aPersonId, $aPersonalData, $aContractType, $employmentPeriod, $aPbationaryPeriod,
            $aWorkerCategory, $aWageType, $aWorkingTimeAccount,
            $aWorkWeekDays, $aWeeklyWorkingHours,
            $aHolidayEntitlement, $additionalLeave,
            $aJobFunctionId, $aJobFunctionName,
            $anEmployerId, $anEmployerName, $aWorkplaceId, $aWorkplaceName,
            new DateTimeImmutable()
        ));

        return $self;
    }

    protected function apply(AggregateChanged $event): void
    {
        switch (get_class($event)) {
            /** @var EmploymentContractSigned $event */
            case EmploymentContractSigned::class:
                $this->id = $event->contractId();
                $this->personId = $event->personId();
                $this->employmentPeriod = $event->employmentPeriod();
                break;
        }
    }

    public function aggregateId(): string
    {
        return $this->id->toString();
    }
}

<?php

namespace Acme\PersonnelManagement\Application\Service\EmploymentContract;

final class SignEmploymentContractHandler
{
    /** @var EmploymentContractEventStoreRepository */
    private $contractCollection;

    /** @var PersonDetailsRepository */
    private $personDetailsRepository;

    /** @var ContractDetailsRepository */
    private $contractsDetailsRepository;

    public function __construct(
        EmploymentContractEventStoreRepository $contractCollection,
        PersonDetailsRepository $personDetailsRepository,
        ContractDetailsRepository $contractsDetailsRepository
    )
    {
        $this->contractCollection = $contractCollection;
        $this->personDetailsRepository = $personDetailsRepository;
        $this->contractsDetailsRepository = $contractsDetailsRepository;
    }

    public function __invoke(SignEmploymentContract $command): void
    {
        $person = $this->personDetailsRepository->ofPersonId($command->personId()->toString());

        $enteredContracts = $this->contractsDetailsRepository->ofPersonId($person->personId());

        if (!OverlappingEmploymentContractPolicy::isSatisfiedBy(
            $command->contractId(), $command->contractType(),
            $command->employmentPeriod(), $command->employerId(), $enteredContracts
        )) {
            throw new EmploymentPeriodOverlapsException();
        }

        $contract = EmploymentContract::sign(
            $command->contractId(), $command->personId(),
            new PersonalData(...),
            $command->contractType(),
            $command->startDate(), $command->endDate(), $command->probationEndDate(),
            $command->workerCategory(), $command->wageType(),
            $command->workingTimeAccount(), $command->workweekDays(),
            $command->weeklyWorkingHours(), $command->holidayEntitlement(), $command->additionalLeave(),
            $command->jobFunctionId(), $jobFunction->name(),
            $command->employerId(), $employer->name(),
            $command->workplaceId(), $workplace->name()
        );

        $this->contractCollection->save($contract);
    }
}

    public function __invoke(SignEmploymentContract $command): void
    {
        $person = $this->personDetailsRepository->ofPersonId($command->personId()->toString());

        $contract = $person->signEmploymentContract(...);
        
        $this->contractCollection->save($contract);
    }

<?php

namespace Acme\PersonnelManagement\Domain\Model\Person;

final class PersonReadModel
{
    private $personId;
    
    private $personalData;
    
    private $employmentContracts;
    
    public function signEmploymentContract(
        EmploymentContractId $contractId, ContractType $contractType,
        DateTimeImmutable $startDate, ?DateTimeImmutable $endDate, ?DateTimeImmutable $aProbationEndDate,
        ...
    ): EmploymentContract {
        $employmentPeriod = EmploymentPeriod::withType($contractType, $startDate, $endDate);
        
        if (!OverlappingEmploymentContractPolicy::isSatisfiedBy(
            $contractId, $contractType, $employmentPeriod, ..., $this->employmentContracts
        )) {
            throw new EmploymentPeriodOverlapsException();
        }
        
        return EmploymentContract::sign(
            $contractId, $this->personId, $this->personalData,
            $contractType, $startDate(), $endDate(), $probationEndDate(),
            ...
        );
    }
}

final class CustomPrice
{
    /** @var int $quantity */
    private $quantity;

    /** @var float $subtotal */
    private $subtotal;

    /** @var float $total */
    private $total;

    /**
     * CustomPrice constructor.
     * @param int $quantity
     * @param float $subtotal
     */
    public function __construct(int $quantity, float $subtotal)
    {
        $this->quantity = $quantity;
        $this->subtotal = $subtotal;
        $this->total = $quantity*$subtotal;
    }

    /**
     * @param array $array
     * @return CustomPrice
     */
    public static function fromArray(array $array): CustomPrice
    {
        Assert::keyExists($array, 'quantity');
        Assert::integer($array['quantity']);
        Assert::keyExists($array, 'subtotal');
        Assert::float($array['quantity']);

        return new self($array['quantity'], $array['subtotal']);
    }

    public static function fromArray_v2(array $array): CustomPrice
    {
        Assert::keyExists($array, 'quantity');
        Assert::integer($array['quantity']);
        Assert::keyExists($array, 'subtotal');
        Assert::float($array['quantity']);
        Assert::keyExists($array, 'total');
        Assert::float($array['total']);

        $self = new self();
        $self->quantity = $array['quantity'];
        $self->subtotal = $array['subtotal'];
        $self->total = $array['total'];

        return $self;
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return [
            'quantity' => $this->quantity,
            'subtotal' => $this->subtotal,
            'total' => $this->total
        ];
    }

class ContractState
{
    const STATE_ACCEPTED        = 'contract_accepted';
    const STATE_APPROVED        = 'contract_approved';
    const STATE_QUOTE_SUBMITTED = 'quote_submitted';
    const STATE_IN_PROGRESS     = 'in_progress';
    const STATE_PENDING         = 'pending';
    const STATE_CLOSED          = 'closed';
}

ContractState::fromString($command->contractState());

<?php
class EditPostCommand
{
    public $id;
    public $headline;
    public $text;
    public $tags = array();
}

<?php
class PostController
{
    public function editAction(Request $request)
    {
        $post = $this->findPostViewModel($request->get('id'));

        // This could need some more automation/generic code
        $editPostCommand           = new EditPostCommand();
        $editPostCommand->id       = $request->get('id');
        $editPostCommand->headline = $post->headline;
        $editPostCommand->text     = $post->text;
        $editPostCommand->tags     = $post->tags;

        // here be the form framework handling...
        $form = $this->createForm(new EditPostType(), $editPostCommand);
        $form->bind($request);

        if (!$form->isValid()) {
            // invalid, show errors
        }

        // here we invoke the model, finally, through the service layer
        $this->postService->edit($editPostCommand);
    }
}

namespace Acme\AppBundle\Entity;

class Customer
{
    /**
     * @Gedmo\ReferenceMany(type="document", class="Acme\DomainModel\Order", mappedBy="customer")
     */
    private $orders;
}

namespace Acme\DomainModel;

class Order
{
    private $customer;
    private $customerId;
}

        $event = self::occur(
            $personId->toString(),
            [
                'personId' => $personId->toString(),
                'oldFirstName' => $oldFirstName->toString(),
                'newFirstName' => $newFirstName->toString(),
            ]
        );

    protected function apply(AggregateChanged $event): void
    {
        switch (get_class($event)) {
            case NameChanged::class:
                /** @var NameChanged $event */
                $this->firstName = $event->newFirstName();

    private function __construct(string $aName)
    {
        $name = NameNormalizer::withString($aName);

        if (!NamePolicy::isSatisfiedBy($name)) {
            throw new NameContainsIllegalCharacters();
        }

        $this->name = $name;
    }

    public static function fromString(string $name): FirstName
    {
        return new self($name);
    }

abstract class DomainMessage implements Message
{
    public static function fromArray(array $messageData): DomainMessage
    {
        MessageDataAssertion::assert($messageData);

        $messageRef = new \ReflectionClass(\get_called_class());

        /** @var $message DomainMessage */
        $message = $messageRef->newInstanceWithoutConstructor();

        $message->uuid = Uuid::fromString($messageData['uuid']);
        $message->messageName = $messageData['message_name'];
        $message->metadata = $messageData['metadata'];
        $message->createdAt = $messageData['created_at'];
        $message->setPayload($messageData['payload']);

        return $message;
    }
}

/**
 * Character e.g. numbers were forbidden.
 */
final class FirstName_V2
{
    /** @var string $name */
    private $name;

    private function __construct()
    {
    }

    public static function fromString(string $aName): FirstName
    {
        $name = NameNormalizer::withString($aName);

        if (!NamePolicy::isSatisfiedBy($name)) {
            throw new NameContainsIllegalCharacters();
        }

        $self = new self();
        $self->name = $name;

        return $self;
    }

    public static function fromPayload(string $name): FirstName
    {
        $self = new self();
        $self->name = $name;

        return $self;
    }

    public function toString(): string
    {
        return $this->name;
    }
}

        $fooCommand = FooCommand::fromBar($bar);

        $form = $this->createForm(FooForm::class, $fooCommand);
        $form->handleRequest($this->getRequest());

        if ($form->isValid()) {
            $fooHandler = $this->get('acme.handler.foo');
            try {
                $fooHandler->handle($fooCommand);

                return $this->redirectToRoute('acme_foo_list');
            } catch (\Exception $e) {
                $form->addError(new FormError($e->getMessage()));
            }
        }

$task->setText('new text');
$task->setStartDate($newStartDate);
// and so on

// UpdatePostHandler.php
$aPost->changeTitle($anUpdatePostCommand->getTitle());
$aPost->changeContent($anUpdatePostCommand->getContent());

// Post.php
public function changeTitle($aNewTitle)
{
    $this->applyAndRecordThat(
        new PostTitleWasChanged($this->postId, $aNewTitle)
    );
}

 class User extends AggregateRoot
    {
        /**
         * @var Uuid
         */
        private $uuid;
        /**
         * @var string
         */
        private $name;
        /**
         * ARs should be created via static factory methods
         */
        public static function nameNew(string $username): User
        {
            //Perform assertions before raising a event
            Assertion::notEmpty($username);
            $uuid = Uuid::uuid4();
            //AggregateRoot::__construct is defined as protected so it can be called in a static factory of
            //an extending class
            $instance = new self();
            //Use AggregateRoot::recordThat method to apply a new Event
            $instance->recordThat(UserWasCreated::occur($uuid->toString(), ['name' => $username]));
            return $instance;
        }

        /**
         * Every AR needs a hidden method that returns the identifier of the AR as a string
         */
        protected function aggregateId(): string
        {
            return $this->uuid->toString();
        }
        protected function apply(AggregateChanged $event): void
        {
            switch (\get_class($event)) {
                case UserWasCreated::class:
                    //Simply assign the event payload to the appropriate properties
                    $this->uuid = Uuid::fromString($event->aggregateId());
                    $this->name = $event->username();
                    break;
                case UserWasRenamed::class:
                    $this->name = $event->newName();
                    break;
            }
        }
    }
    /**
     * ProophEventSourcing domain events are of the type AggregateChanged
     */
    class UserWasCreated extends AggregateChanged
    {
        public function username(): string
        {
            return $this->payload['name'];
        }
    }

final class DormerElementCreated extends AggregateChanged
{
    /** @var DormerElementId */
    private $dormerElementId;

    /** @var VariableName */
    private $variableName;

    /** @var string */
    private $variableDescription;

    /** @var DormerPart */
    private $dormerPart;
    
    /** @var MeasurementUnit */
    private $measurementUnit;

    /** @var float */
    private $workingHours;

    /** @var int */
    private $surcharge;

    public static function with(
        DormerElementId $dormerElementId, VariableName $variableName, string $variableDescription,
        DormerPart $part, MeasurementUnit $unit, float $workingHours, int $surcharge
    ): DormerElementCreated
    {
        $event = self::occur(
            $dormerElementId->toString(),
            [
                'id' => $dormerElementId->toString(),
                'variableName' => $variableName->toString(),
                'variableDescription' => $variableDescription,
                'dormerPart' => $part->toString(),
                'measurementUnit' => $unit->toString(),
                'workingHours' => $workingHours,
                'surcharge' => $surcharge,
            ]
        );
        $event->dormerElementId = $dormerElementId;
        $event->variableName = $variableName;
        $event->variableDescription = $variableDescription;
        $event->dormerPart = $part;
        $event->measurementUnit = $unit;
        $event->workingHours = $workingHours;
        $event->surcharge = $surcharge;

        return $event;
    }

    public function dormerElementId(): DormerElementId
    {
        if (null === $this->dormerElementId) {
            $this->dormerElementId = DormerElementId::fromString($this->aggregateId());
        }

        return $this->dormerElementId;
    }

    public function variableName(): VariableName
    {
        if (null === $this->variableName) {
            $this->variableName = VariableName::fromString($this->payload['variableName']);
        }

        return $this->variableName;
    }
}

            function (ActionEvent $event) use ($eventStore): void {
                $recordedEvents = $event->getParam('streamEvents', new \ArrayIterator());

                if (! $this->inTransaction($eventStore)) {
                    if ($event->getParam('streamNotFound', false)
                        || $event->getParam('concurrencyException', false)
                    ) {
                        return;
                    }

                    foreach ($recordedEvents as $recordedEvent) {
                        $this->eventBus->dispatch($recordedEvent);
                    }
                } else {
                    $this->cachedEventStreams[] = $recordedEvents;
                }
            }

final class EmploymentContract extends AggregateRoot
{
    public static function sign(
        EmploymentContractId $anId, ContractType $aContractType,
        DateTimeImmutable $aStartDate, ?DateTimeImmutable $anEndDate
    ) {
        if ($aContractType->isFixedTerm() && null === $anEndDate) {
            throw new FixedTermContractMustHaveAnEndDateException();
        }

        $employmentPeriod = new EmploymentPeriod($aStartDate, $anEndDate);
    }
}

final class EmploymentContract extends AggregateRoot
{
    public static function sign(
        EmploymentContractId $anId, ContractType $aContractType, EmploymentPeriod $aPeriod
    ) {
        // no further validation, the passed value objects are expected too be valid
    }
}

final class EmploymentPeriod
{
    public function __construct(DateTimeImmutable $startDate, ?DateTimeImmutable $endDate)
    {
        if (null !== $endDate) {
            if ($endDate < $startDate) {
                throw new EndDateMustBeGreaterThanStartDateException();
            }
        }

        $this->startDate = $startDate;
        $this->endDate = $endDate;
    }

    public static function withType(
        ContractType $type, DateTimeImmutable $startDate, ?DateTimeImmutable $endDate
    ): EmploymentPeriod
    {
        if ($type->isFixed()) {
            if (null === $endDate) {
                throw new FixedTermContractMustHaveAnEndDateException();
            }
        }

        if ($type->isPermanent()) {
            if (null !== $endDate) {
                throw new PermanentContractMustNotHaveAnEndDateException();
            }
        }

        return new self($startDate, $endDate);
    }
}

final class EmploymentContract extends AggregateRoot
{
    public static function sign(
        EmploymentContractId $anId, ContractType $aContractType, EmploymentPeriod $aPeriod
    ) {
        // no further validation, the passed value objects are expected too be valid
    }
}

final class ContractType
{
    public function specifyEmploymentPeriod($startDate, $endDate); EmploymentPeriod
    {
        if ($this->isFixed()) {
            if (null === $endDate) {
                throw new FixedTermContractMustHaveAnEndDateException();
            }
        }

        if ($this->isPermanent()) {
            if (null !== $endDate) {
                throw new PermanentContractMustNotHaveAnEndDateException();
            }
        }

        return new EmploymentPeriod($startDate, $endDate);
    }
}

<?php

namespace Acme\PersonnelManagement\Domain\Service\EmploymentContract;

use Acme\PersonnelManagement\Domain\Model\EmploymentContract\EmploymentContractId;
use Acme\PersonnelManagement\Domain\Model\EmploymentContract\EmploymentPeriod;
use Acme\PersonnelManagement\Presentation\Model\EmploymentContract\TermRepository;
use Webmozart\Assert\Assert;

final class EmploymentPeriodExtractor
{
    /** @var TermRepository */
    private $termRepository;

    public function __construct(TermRepository $termRepository)
    {
        $this->termRepository = $termRepository;
    }

    /**
     * @param EmploymentContractId[] $contractIds
     * @return EmploymentPeriod
     */
    public function fromContractIds(array $contractIds): EmploymentPeriod
    {
        Assert::allIsInstanceOf($contractIds, EmploymentContractId::class);
        Assert::minCount($contractIds, 1);

        $terms = $this->termRepository->ofContractIds(array_map(function (EmploymentContractId $contractId) {
            return $contractId->toString();
        }, $contractIds));

        $employmentPeriods = [];

        foreach ($terms as $term) {
            $employmentPeriods[] = new EmploymentPeriod(
                $term->startDate(), $term->endDate()
            );
        }

        return EmploymentPeriodMerger::merge($employmentPeriods);
    }
}

<?php

namespace Acme\PersonnelManagement\Application\Service\Person;

use Acme\PersonnelManagement\Domain\Service\EmploymentContract\EmploymentPeriodExtractor;

final class ExtractEmploymentPeriodHandler
{
    /** @var EmploymentPeriodExtractor */
    private $extractor;

    public function __construct(EmploymentPeriodExtractor $extractor)
    {
        $this->extractor = $extractor;
    }

    public function __invoke(ExtractEmploymentPeriod $command): void
    {
        $newPeriod = $this->extractor->fromContractIds($command->contractIds());
        // Save aggregate...
    }
}

<?php

namespace Acme\PersonnelManagement\Presentation\Model\EmploymentContract;

use Acme\PersonnelManagement\Domain\Model\EmploymentContract\EmploymentContractId;

interface TermRepository
{
    public function ofPersonId(string $personId): array;

    /**
     * @param string[] $contractIds
     * @return Term[]
     */
    public function ofContractIds(array $contractIds): array;
}

<?php

namespace Acme\PersonnelManagement\Domain\Service\EmploymentContract;

use Acme\PersonnelManagement\Domain\Model\EmploymentContract\EmploymentContractId;
use Acme\PersonnelManagement\Domain\Model\EmploymentContract\EmploymentPeriod;
use Acme\PersonnelManagement\Presentation\Model\EmploymentContract\TermRepository;
use Webmozart\Assert\Assert;

final class EmploymentPeriodExtractor
{
    /**
     * @param Term[] $terms
     * @return EmploymentPeriod
     */
    public function fromTerms(array $terms): EmploymentPeriod
    {
        Assert::allIsInstanceOf($terms, Term::class);
        Assert::minCount($terms, 1);

        $employmentPeriods = [];

        foreach ($terms as $term) {
            $employmentPeriods[] = new EmploymentPeriod(
                $term->startDate(), $term->endDate()
            );
        }

        return EmploymentPeriodMerger::merge($employmentPeriods);
    }
}

<?php

namespace Acme\PersonnelManagement\Application\Service\Person;

use Acme\PersonnelManagement\Domain\Service\EmploymentContract\EmploymentPeriodExtractor;

final class ExtractEmploymentPeriodHandler
{
    /** @var TermRepository */
    private $termRepository;

    /** @var EmploymentPeriodExtractor */
    private $extractor;

    public function __construct(TermRepository $termRepository, EmploymentPeriodExtractor $extractor)
    {
        $this->termRepository = $termRepository;
        $this->extractor = $extractor;
    }

    public function __invoke(ExtractEmploymentPeriod $command): void
    {
        $terms = $this->termRepository->ofContractIds(array_map(function (EmploymentContractId $contractId) {
            return $contractId->toString();
        }, $command->contractIds()));

        $newPeriod = $this->extractor->fromTerms(terms);
        // Save aggregate...
    }
}

final class EmploymentContractSigned extends AggregateChanged
{
    /** @var EmploymentContractId $contractId */
    private $contractId;

    /** @var EmployerId */
    private $employerId;
}

final class EmploymentContractDetailsProjection implements ReadModelProjection
{
    public function project(ReadModelProjector $projector): ReadModelProjector
    {
        $projector->fromStream('employment_contract_stream')
            ->when([
                EmploymentContractSigned::class => function ($state, EmploymentContractSigned $event) {
                    /** @var EmploymentContractDetailsReadModel $readModel */
                    $readModel = $this->readModel();
                    $readModel->stack('sign', [
                        'contract_id' => $event->contractId()->toString(),
                        'employer_id' => $event->employerId()->toString(),
                        'employer_name' => $event->employerName(),
                        'created_at' => $event->createdAt()->format('Y-m-d H:i:s'),
                        'created_by_user_id' => $event->metadata()['created_by_user_id'],
                        'created_by_username' => $event->metadata()['created_by_username'],
                        'created_by_full_name' => $event->metadata()['created_by_full_name']
                    ]);
                },
            ]);

        return $projector;
    }
}

final class EmploymentContractSigned extends AggregateChanged
{
    public function recognizeEmployerChange($newEmployerName): void
    {
        $this->recordThat(EmployerChangeRecognized::with($this->contractId, $this->employerId, $newEmployerName));
    }

final class EmploymentContractSigned extends AggregateChanged
{
    public function transferToNewEmployer($newEmployerId, $newEmployerName): void
    {
        $this->recordThat(TransferredToNewEmployer::with($this->contractId, $newEmployerId, $newEmployerName));
    }

final class EmploymentContractDetailsRepository extends DbalReadModelRepository implements DetailsRepository
{
    public function ofId(string $id): Details
    {
        $stmt = $this->getConnection()->prepare(sprintf(
            "SELECT * FROM `%s` WHERE contract_id = :id",
            Table::EMPLOYMENT_CONTRACT_DETAILS
        ));
        $stmt->bindValue('id', $id);
        $stmt->execute();

        $result = $stmt->fetch();

        if (false === $result) {
            throw new \Exception('Contract not found');
        }

        return Details::fromArray($result);
    }
}

final class EmploymentContractDetailsRepository extends DbalReadModelRepository implements DetailsRepository
{
    public function ofId(string $id): Details
    {
        $stmt = $this->getConnection()->prepare(sprintf(
            "SELECT * FROM `%s` JOIN `employers` USING (employer_id) WHERE contract_id = :id",
            Table::EMPLOYMENT_CONTRACT_DETAILS
        ));
        $stmt->bindValue('id', $id);
        $stmt->execute();

        $result = $stmt->fetch();

        if (false === $result) {
            throw new \Exception('Contract not found');
        }

        return Details::fromArray($result);
    }
}

        $qb->select(array(
                'b.id',
                'b.date',
                'b.shift',
                'b.shippingnumber AS shipping_number',
                'GroupConcat(DISTINCT b.comment) AS comment',
                'SUM(b.customFieldNum1) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS custom_field_num_1',
                'SUM(b.customFieldNum2) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS custom_field_num_2',
                'SUM(b.customFieldNum3) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS custom_field_num_3',
                'SUM(b.customFieldNum4) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS custom_field_num_4',
                'SUM(b.customFieldNum5) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS custom_field_num_5',
                'b.customFieldStr1 AS custom_field_str_1',
                'b.customFieldStr2 AS custom_field_str_2',
                'b.customFieldStr3 AS custom_field_str_3',
                'b.customFieldStr4 AS custom_field_str_4',
                'b.customFieldStr5 AS custom_field_str_5',
                'p.id AS parttype_id',
                'p.integratorNumber AS part_number',
                'l.name AS location',
                'SUM(bps_ok.quantity) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS ok_total',
                'SUM(bps_ok.quantity+bps_nok_processed.quantity+bps_nok_blocked.quantity) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS total',
                'SUM(bps_nok_processed.quantity+bps_nok_blocked.quantity) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS nok_total',
                'SUM(bps_nok_processed.quantity) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS nok_processed',
                'SUM(bps_nok_blocked.quantity) / CASE WHEN COUNT(bps_ok.id) = 0 THEN 1 ELSE COUNT(bps_ok.id) / COUNT(DISTINCT bps_ok.id) AS nok_blocked',
            ))

<?php
class CustomerDetails
{
    public function __construct($name, $email, $city, $value = null)
    {
        // Bind values to the object properties.
    }
}

<?php
$query = $em->createQuery('SELECT NEW CustomerDetails(c.name, e.email, a.city) FROM Customer c JOIN c.email e JOIN c.address a');
$users = $query->getResult(); // array of CustomerDetails

<?php

final class Dormer
{
    /** @var DormerType $type */
    private $type;

    public static function construct(DormerType $type)
    {
        $this->type = $type;
    }

    public function addGutter(Gutter $gutter)
    {
        if (!$this->type->canHaveGutterInstalled()) {
            throw new DormerTypeCannotHaveGutterInstalledException();
        }
 
       $this->gutter = $gutter;
    }
}

final class DormerCalculationFactory extends AbstractCalculator
{
    private $dormerTypeRepository;

    public function createWithDto(CalculateDormerCommand $dto)
    {
        $dormerType = $this->dormerTypeRepository->ofId(DormerTypeId::fromInteger($dto->dormerTypeId));

        /** @var Dormer $dormer */
        $dormer = Dormer::construct($dormerType);
        $dormer->addGutter(Gutter::fromDto($dto->gutter));
    }
}

<?php

class DormerType()
{
    private $id;

    public function calculateDormer(Gutter $gutter)
    {
         if (!$this->canHaveGutterInstalled()) {
            throw new DormerTypeCannotHaveGutterInstalledException();
        }
       
        return new Dormer($this->id(), $gutter);
    }
}

final class DormerCalculationFactory extends AbstractCalculator
{
    private $dormerTypeRepository;

    public function createWithDto(CalculateDormerCommand $dto)
    {
        $dormerType = $this->dormerTypeRepository->ofId(DormerTypeId::fromInteger($dto->dormerTypeId));

        /** @var Dormer $dormer */
        $dormer = Dormer::construct($dormerType->id());

        if (null !== $dto->gutter && $dormerType->canHaveGutterInstalled()) {
            $dormer->addGutter(Gutter::fromDto($dto->gutter));
        }
    }
}

namespace Prooph\Common\Messaging;

abstract class DomainMessage implements Message
{
    public static function fromArray(array $messageData): DomainMessage
    {
        MessageDataAssertion::assert($messageData);

        $messageRef = new \ReflectionClass(\get_called_class());

        /** @var $message DomainMessage */
        $message = $messageRef->newInstanceWithoutConstructor();

        $message->uuid = Uuid::fromString($messageData['uuid']);
        $message->messageName = $messageData['message_name'];
        $message->metadata = $messageData['metadata'];
        $message->createdAt = $messageData['created_at'];
        $message->setPayload($messageData['payload']);

        return $message;
    }
}

<?php

namespace Acme\Staff\Domain\Service;

use DomainException;
use Prooph\EventSourcing\AggregateChanged;
use Ramsey\Uuid\Uuid;
use ReflectionClass;
use ReflectionProperty;
use Acme\Staff\Domain\Model\StaffMember\ContractId;
use Acme\Staff\Domain\Model\StaffMember\EmploymentPeriod;
use Acme\Staff\Domain\Model\StaffMember\Event\MergedWithStaffMembers;
use Acme\Staff\Domain\Model\StaffMember\Event\StaffMemberAdded;
use Acme\Staff\Domain\Model\StaffMember\Event\StaffMemberContractModified;
use Acme\Staff\Domain\Model\StaffMember\StaffMember;
use Acme\Staff\Domain\Model\StaffMember\StaffMemberId;
use Acme\Staff\Domain\Model\StaffMember\StaffMemberRepository;

final class MergedStaffMember
{
    /** @var StaffMemberRepository */
    private $staffMemberRepository;

    /**
     * Current version
     *
     * @var int
     */
    private $version = 0;

    /**
     * List of events that are not committed to the EventStore
     *
     * @var AggregateChanged[]
     */
    private $recordedEvents = [];

    /** @var StaffMemberId */
    private $newStaffMemberId;

    /** @var StaffMemberId[] */
    private $mergeWithStaffMemberIds = [];

    /** @var ContractId */
    private $newContractId;

    /** @var EmploymentPeriod */
    private $newEmploymentPeriod;

    public function __construct(StaffMemberRepository $staffMemberRepository)
    {
        $this->staffMemberRepository = $staffMemberRepository;
    }

    public function fromMergedHistory(
        StaffMemberId $newStaffMemberId, array $mergeWithStaffMemberIds,
        ContractId $newContractId, EmploymentPeriod $newEmploymentPeriod
    ): StaffMember
    {
        if (0 === count($mergeWithStaffMemberIds)) {
            throw new DomainException('Missing staff members to merge');
        }

        $this->newStaffMemberId = $newStaffMemberId;
        $this->mergeWithStaffMemberIds = $mergeWithStaffMemberIds;
        $this->newContractId = $newContractId;
        $this->newEmploymentPeriod = $newEmploymentPeriod;

        $this->buildHistoryFromMergedStaffMembers();
        $this->finalizeNewStaffMemberHistory();

        $newStaffMemberRef = new ReflectionClass(StaffMember::class);

        /** @var StaffMember $newStaffMember */
        $newStaffMember = $newStaffMemberRef->newInstanceWithoutConstructor();

        $newStaffMemberRecordedEventsRef = new ReflectionProperty($newStaffMember, 'recordedEvents');
        $newStaffMemberRecordedEventsRef->setAccessible(true);
        $newStaffMemberRecordedEventsRef->setValue($newStaffMember, $this->recordedEvents);

        $newStaffMemberStaffMemberIdRef = new ReflectionProperty($newStaffMember, 'staffMemberId');
        $newStaffMemberStaffMemberIdRef->setAccessible(true);
        $newStaffMemberStaffMemberIdRef->setValue($newStaffMember, $newStaffMemberId);

        return $newStaffMember;
    }

    private function buildHistoryFromMergedStaffMembers(): void
    {
        $oldEvents = $this->staffMemberRepository->ofStaffMemberIds($this->mergeWithStaffMemberIds);

        // Ensure chronological order
        uasort($oldEvents, function(AggregateChanged $a, AggregateChanged $b) {
            return $a->createdAt() <=> $b->createdAt();
        });

        $initialStaffMemberId = StaffMemberId::fromString(reset($oldEvents)->aggregateId());

        /** @var AggregateChanged[] $oldEvent */
        foreach ($oldEvents as $oldEvent) {
            $newMessageData = $oldEvent->toArray();
            // The new event needs an own unique ID.
            $newMessageData['uuid'] = Uuid::uuid4()->toString();
            // Set the new staff member ID instead of the merged one.
            $newMessageData['metadata']['_aggregate_id'] = $this->newStaffMemberId->toString();
            // This will be automatically reset correctly.
            unset($newMessageData['metadata']['_position']);

            if ($oldEvent instanceof StaffMemberAdded) {
                /** @var StaffMemberAdded $oldEvent */
                if (!$oldEvent->staffMemberId()->sameValueAs($initialStaffMemberId)) {
                    // Only the initial event can add a staff member.
                    // All other events can only be modifications of the contract.
                    $newMessageData['message_name'] = StaffMemberContractModified::class;
                }
            }

            if ($oldEvent instanceof StaffMemberAdded || $oldEvent instanceof StaffMemberContractModified) {
                $newMessageData['payload']['contractId'] = $this->newContractId->toString();
                // Set new employment period to satisfy all time-period relevant policies.
                $newMessageData['payload']['employmentPeriod'] = $this->newEmploymentPeriod->toArray();
            }

            $eventClassName = $newMessageData['message_name'];

            $newEvent = $eventClassName::fromArray($newMessageData);

            $this->recordThat($newEvent);
        }
    }

    private function finalizeNewStaffMemberHistory(): void
    {
        // Create final event
        $mergedWithStaffMembers = MergedWithStaffMembers::with(
            $this->newStaffMemberId, $this->mergeWithStaffMemberIds,
            $this->newContractId, $this->newEmploymentPeriod
        );
        $mergedWithStaffMembers = $mergedWithStaffMembers
            ->withAddedMetadata('_aggregate_type', StaffMember::class)
        ;

        $this->recordThat($mergedWithStaffMembers);
    }

    /**
     * Record an aggregate changed event
     */
    protected function recordThat(AggregateChanged $event): void
    {
        $this->version += 1;

        $this->recordedEvents[] = $event->withVersion($this->version);
    }
}

<?php

namespace Acme\Staff\Application\Service\StaffMember;

use Acme\Staff\Domain\Model\StaffMember\StaffMemberRepository;
use Acme\Staff\Domain\Service\MergedStaffMember;

final class MergeStaffMembersHandler
{
    /** @var MergedStaffMember */
    private $mergedStaffMember;

    /** @var StaffMemberRepository */
    private $staffMemberRepository;

    public function __construct(MergedStaffMember $mergedStaffMember, StaffMemberRepository $staffMemberRepository)
    {
        $this->mergedStaffMember = $mergedStaffMember;
        $this->staffMemberRepository = $staffMemberRepository;
    }

    public function __invoke(MergeStaffMembers $command): void
    {
        $newStaffMember = $this->mergedStaffMember->fromMergedHistory(
            $command->newStaffMemberId(),
            $command->mergeWithStaffMemberIds(),
            $command->newContractId(),
            $command->newEmploymentPeriod()
        );

        $this->staffMemberRepository->save($newStaffMember);
    }
}

use Acme\Contract\ContractBundle;

/** 
 * @ORM\Entity
 */
class Contract
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    public $id;

    /**     
     * @ORM\Column(type="string", name="status")
     */
    protected $status;

    /**
     * @ORM\OneToMany(targetEntity="Timesheet", mappedBy="contract", cascade={"persist"})
     * @todo Use LAZY loading?
     */
    private $timesheets;

    public function addTimesheet(Timesheet $timesheet) {
        // Policy
        if ($this->isClosed()) {
            throw new ContractAlreadyClosedException();
        }

        $this->timesheets[] = $timesheet;
    }
}

use Acme\Contract\ContractBundle;

/**
 * @ORM\Entity
 */
class Timesheet
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @ORM\ManyToOne(targetEntity="Contract", inversedBy="timesheets")
     * @ORM\JoinColumn(name="contract_id", referencedColumnName="id")
     */
    private $contract;
}

use Acme\Contract\Application\Service;

class WriteTimeSheetHandler
{
    public function handle($command)
    {
        $contract = $this->contractRepository->find($command->contractId());
        $timesheet = new Timesheet($command->start(), $command->end());
        $contract->addTimesheet($timesheet); // Check invariant
    }
}

use Acme\Contract\Application\Service;

class WriteTimesheetHandler
{
    public function handle($command)
    {
        $timesheet = new Timesheet($command->start(), $command->end());
        $this->timesheetRepository->save($timesheet);

        $this->raiseEvent(TimesheetCreated($contractId));
    }
}

class TimesheetCreatedListener
{
    public function __constuct($event)
    {
        $contract = $this->contractRepository->find($event->contractId());
        $timesheet = $this->timesheetRepository->find($event->timesheetId());
        $contract->addTimesheet($timesheet); // Check invariant
        $this->contractRepository->save($contract);
    }
}

class Timesheet
{
    private $contractId;

    public function __construct(Contract $contract, $start, $end)
    {
        // Policy - move to domain service using repository?
        if ($contract->isClosed()) {
            throw new ContractAlreadyClosedException();
        }

        $this->contractId = ContractId::create($contract->id()); // UUID value object soon
        $this->start = $start;
        $this->end = $end;
    }
}

<?php

class ChangeInspectionDetails extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('problemNumber', TextType::class, [
                'empty_data' => '' // no effect
            ]);
    }
}

<?php

class Contract
{
    public $problemNumber = ''; // no effect

    public function changeInspectionDetails(
        string $problemNumber = ''
    ) {
        $this->problemNumber = $problemNumber;

    }
}

<?php

class ChangeInspectionDetails extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('problemNumber', TextType::class, [
                'empty_data' => '' // no effect
            ]);
    }


    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => ChangeInspectionDetailsCommand::class
        ]);
    }    
}

<?php

class ChangeInspectionDetailsCommand
{
    public $problemNumber = ''; // no effect

    public function problemNumber()
    {
        return (string) $this->problemNumber; // workaround 1
    }
}

<?php

class ChangeInspectionDetailsHandler
{
    public function handle(ChangeInspectionDetailsCommand $command)
    {
        // ...
        $contract->changeInspectionDetails(
            #$command->problemNumber() // no effect
            (string) $command->problemNumber() // workaround 2
        );
    }
}

final class StaffMember extends AggregateRoot
{
    public function assignToJobFunction(JobFunctionId $jobFunctionId, string $jobFunctionName): void
    {
        $this->recordThat(AssignedToJobFunction::with($this->staffMemberId, $jobFunctionId, $jobFunctionName));
    }

    // 19 more state changes
}

final class StaffPublisher extends Producer implements MessageSubscriberInterface
{
    /** @var ProducerInterface */
    protected $producer;

    public function whenAssignedToJobFunction(AssignedToJobFunction $event): void
    {
        $this->publish($event->serialize(), 'acme.staff.staff.member_assigned_to_job_function');
    }
}

final class StaffMember extends AggregateRoot
{
    /** @var StaffMemberId */
    private $staffMemberId;

    /** @var JobFunctionId */
    private $jobFunctionId;

    /** @var string */
    private $jobFunctionName;

    // 19+x more properties holding the state only for the extra event, currently not required for protecting invariants
    public function assignToJobFunction(JobFunctionId $jobFunctionId, string $jobFunctionName): void
    {
        $this->recordThat(AssignedToJobFunction::with($this->staffMemberId, $jobFunctionId, $jobFunctionName));
        $this->recordThat(StaffMemberDetailsSummarized::with($this->staffMemberId, $jobFunctionId, $jobFunctionName, // entire state...));
    }

    // 19 more state changes
}

final class Deployment1
{
    public static function with(DeploymentId $anId, EmploymentContractId $anEmploymentContractId,
                                DeploymentPeriod $aPeriod): Deployment
    {
        // No period range validation, final period was already validated and passed
    }
}

final class Host extends AggregateRoot
{
    private HostId $hostId;

    private EmailAddress $emailAddress;

    private VerificationToken $verificationToken;

    private bool $verified = false;

    public static function register(HostId $hostId, EmailAddress $emailAddress): Host
    {
        $emailAddressVerificationToken = VerificationToken::generate($hostId, $emailAddress);

        $self = new self();
        $self->recordThat(HostRegistered::with($hostId, $emailAddress, $emailAddressVerificationToken));

        return $self;
    }

    public function verify(string $token): void
    {
        if ($this->isVerified()) {
            return;
        }

        if ($this->verificationToken->token() !== $token) {
            throw new InvalidVerificationTokenException();
        }

        if ($this->verificationToken->hasExpired()) {
            throw new VerificationTokenExpiredException();
        }

        $this->recordThat(HostVerified::with($this->hostId));
    }

final class VerificationToken
{
    public const LIFETIME = 345600;

    private string $token;

    private DateTimeImmutable $expiresAt;

    private function __construct()
    {
    }

    public static function generate(HostId $hostId, EmailAddress $emailAddress): VerificationToken
    {
        $encodedData = json_encode([$hostId->toString(), $emailAddress->toString()]);
        $signingKey = 'some_secret';
        $token = base64_encode(hash_hmac('sha256', $encodedData, $signingKey, true));

        $expiryTimestamp = time() + VerificationToken::LIFETIME;
        $expiresAt = (new DateTimeImmutable())->setTimestamp($expiryTimestamp);

        $self = new self();
        $self->token = $token;
        $self->expiresAt = $expiresAt;

        return $self;
    }

    public function token(): string
    {
        return $this->token;
    }

    public function expiresAt(): DateTimeImmutable
    {
        return $this->expiresAt;
    }

    public function hasExpired(): bool
    {
        return time() > $this->expiresAt->getTimestamp();
    }

final class Host extends AggregateRoot
{
    public static function register(HostId $hostId, EmailAddress $emailAddress): Host
    {
        $expiryTimestamp = time() + VerificationToken::LIFETIME;
        $expiresAt = (new DateTimeImmutable())->setTimestamp($expiryTimestamp);

        $emailAddressVerificationToken = VerificationToken::generate($hostId, $emailAddress, $expiresAt);

final class Host extends AggregateRoot
{
    public function verify(string $token): void
    {
        if ($this->isVerified()) {
            return;
        }

        if ($this->verificationToken->token() !== $token) {
            throw new InvalidVerificationTokenException();
        }

        if ($this->verificationToken->hasExpired()) {
            throw new VerificationTokenExpiredException();
        }

final class Host extends AggregateRoot
{
    public static function register(HostId $hostId, EmailAddress $emailAddress, DateTimeImmutable $registeredAt): Host
    {
        $expiryTimestamp = $registeredAt + VerificationToken::LIFETIME;
        $expiresAt = (new DateTimeImmutable())->setTimestamp($expiryTimestamp);

        $emailAddressVerificationToken = VerificationToken::generate($hostId, $emailAddress, $expiresAt);

<?php

namespace Acme\Common\Infrastructure\Symfony\EventListener;

use DomainException;
use Prooph\EventStore\Exception\ConcurrencyException;
use Acme\Common\Presentation\Model\NotFoundException;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\ExceptionEvent;
use Symfony\Component\Messenger\Exception\HandlerFailedException;
use Symfony\Component\Messenger\Exception\RuntimeException;
use Symfony\Component\Messenger\Exception\ValidationFailedException;
use Symfony\Component\Validator\ConstraintViolation;
use Symfony\Contracts\Translation\TranslatorInterface;

/**
 * Handles bad requests and returns a 400 status with human-readable errors to the client.
 * Returns a 500 status otherwise.
 */
final class ExceptionListener
{
    /** @var TranslatorInterface */
    private $translator;

    private $translationDomain = 'exception';

    private $locale = 'de';

    public function __construct(TranslatorInterface $translator)
    {
        $this->translator = $translator;
    }

    public function onKernelException(ExceptionEvent $event)
    {
        // You get the exception object from the received event
        $exception = $event->getThrowable();

        if (!$exception instanceof RuntimeException) {
            return;
        }

        $response = new JsonResponse();
        $response->setStatusCode(Response::HTTP_BAD_REQUEST);

        if ($exception instanceof ValidationFailedException) {
            // Handle domain specific exceptions - public to the client
            $errors = [];

            /** @var ConstraintViolation $violation */
            foreach ($exception->getViolations() as $violation) {
                $errors[] = [
                    'message' => $violation->getMessage(),
                    'path' => $violation->getPropertyPath()
                ];
            }

            $response->setContent(json_encode(['errors' => $errors]));
            $event->setResponse($response);

            return;
        }

        if ($exception instanceof HandlerFailedException) {
            // Handle presentation and domain specific exceptions - public to the client
            $errors = [];

            if ($exception->getPrevious() instanceof NotFoundException) {
                $errors = [
                    'message' => $exception->getMessage(),
                    'path' => null
                ];

                $response->setContent(json_encode(['errors' => $errors]));
                $response->setStatusCode(Response::HTTP_NOT_FOUND);

                $event->setResponse($response);

                return;
            }

            if ($exception->getPrevious() instanceof DomainException) {
                $errors[] = [
                    'message' => $this->translator->trans(
                        $exception->getPrevious()->getMessage(), [], $this->translationDomain, $this->locale
                    ),
                    'path' => null
                ];

                $response->setContent(json_encode(['errors' => $errors]));
                $event->setResponse($response);

                return;
            }

            // Handle individual server errors if relevant to the client
            switch (get_class($exception->getPrevious())) {
                case ConcurrencyException::class:
                    $errors = [
                        'message' => 'Duplicate entry',
                        'path' => null
                    ];

                    $response->setContent(json_encode(['errors' => $errors]));
                    $event->setResponse($response);

                    return;

                    break;
            }
        }
    }
}

final class LoginController
{
    private MessageBusInterface $queryBus;

    public function __construct(MessageBusInterface $queryBus)
    {
        $this->queryBus = $queryBus;
    }

    public function __invoke(Request $request): Response
    {
        $query = new LoginHost(json_decode($request->getContent(), true));

        $envelope = $this->queryBus->dispatch($query);
        $handledStamp = $envelope->last(HandledStamp::class);

        return new JsonResponse($handledStamp->getResult(), Response::HTTP_OK);
    }
}

final class HostReadModel
{
    private HostId $hostId;

    private EmailAddress $emailAddress;

    private EncodedPassword $password;

    private bool $verified = false;

    private string $locale = 'de';

    public static function fromArray(array $data): HostReadModel
    {
        $self = new self();
        $self->hostId = HostId::fromString($data['hostId']);
        $self->emailAddress = EmailAddress::fromString($data['emailAddress']);
        $self->password = EncodedPassword::fromString($data['password']);
        $self->verified = $data['verified'];
        $self->locale = 'de';

        return $self;
    }

    public function isVerified(): bool
    {
        return $this->verified;
    }
}

final class LoginHostHandler
{
    private HostDetailsFinder $hostDetailsFinder;

    private UserPasswordEncoderInterface $passwordEncoder;

    private JWTEncoderInterface $jwtEncoder;

    public function __construct(
        HostDetailsFinder $hostDetailsFinder,
        UserPasswordEncoderInterface $passwordEncoder,
        JWTEncoderInterface $jwtEncoder
    )
    {
        $this->hostDetailsFinder = $hostDetailsFinder;
        $this->passwordEncoder = $passwordEncoder;
        $this->jwtEncoder = $jwtEncoder;
    }

    public function __invoke(LoginHost $query): array
    {
        /** @var HostReadModel $hostDetails */
        $hostDetails = $this->hostDetailsFinder->ofEmailAddress($query->emailAddress()); // CQRS Read Model

        if (!$hostDetails->isVerified()) {
            throw new HostNotVerifiedException();
        }

        if (!$this->passwordEncoder->isPasswordValid($hostDetails, $query->password()->toString())) {
            throw new InvalidCredentialsException();
        }

        return ['token' => $this->jwtEncoder->encode($hostDetails->toArray())];
    }
}

class CalculateDormerHandler extends AbstractCalculateDormerHandler
{
    public function handle(CalculateDormerCommand $command)
    {
        // Pass to domain service calculator
        $dormerCalculation = $this->dormerCalculator->calculate(
            PartnerId::create($this->getTokenStorage()->getToken()->getUser()->getId()),
            $command
        );

        $this->dormerCalculationRepository->save($dormerCalculation);
    }
}

class DormerCalculator
{
    public function calculate(
        PartnerId $partnerId,
        $command
    ) {
        $this->partner = $this->partnerRepository->ofId($partnerId);
        $this->gutter = $this->calculateGutter($command->gutter());
    }

    private function calculateGutter($gutterData) : Gutter
    {
        if (true !== $gutterData['add']) {
            return;
        }
        return new Gutter(
            GutterMaterial::create($gutterData['materialId']),
            GutterColor::create($gutterData['colorId'])
        );
    }
}

class CalculateDormerHandler extends AbstractCalculateDormerHandler
{
    public function handle(CalculateDormerCommand $command)
    {
        if (true !== $command->gutter()['add']) {
            $gutter = new Gutter(
                GutterMaterial::create($gutterData['materialId']),
                GutterColor::create($gutterData['colorId'])
            );
        }

        // Pass to domain service calculator
        $dormerCalculation = $this->dormerCalculator->calculate(
            PartnerId::create($this->getTokenStorage()->getToken()->getUser()->getId()),
            $gutter
            // ...
        );
    }
}

class DormerCalculator
{
    public function calculate(
        PartnerId $partnerId,
        Gutter $gutter = null,
        // ...
    ) {
        $this->partner = $this->partnerRepository->ofId($partnerId);
        $this->gutter = $this->gutter;
    }
}

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,
        array $enteredContracts
    ): ServiceContract
    {
        Assert::notEmpty($aJobFunctionName);
        Assert::notEmpty($anAgencyName);
        Assert::notEmpty($aWorkplaceName);

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

        return $self;
    }

    private function detectConflicts(ServiceContractId $id, array $enteredContracts, AssignmentPeriod $period): void
    {
        Assert::allIsInstanceOf($enteredContracts, Term::class);

        foreach ($enteredContracts as $enteredContract) {
            if ($id->sameValueAs(ServiceContractId::fromString($enteredContract->contractId()))) {
                continue; // Used only when editing the assignment period, not for actual creation of the contract
            }

            if ($period->overlapsWith($enteredContract->assignmentPeriod())) {
                throw new AssignmentPeriodOverlapsException();
            }
        }
    }
}

final class EnterServiceContractHandler
{
    public function __invoke(EnterServiceContract $command): void
    {
        $person = $this->personDetailsRepository->ofPersonId($command->personId()->toString());

        $enteredContracts = $this->contractTermRepository->ofPersonId($command->personId()->toString());

        $contract = ServiceContract::enter(
            $command->contractId(), $command->personId(),
            ... personal data from the person etc. ...
            $enteredContracts
        );

        $this->contractCollection->save($contract);
    }
}

final class ServiceContractTest extends EventSourcedAggregateRootTestCase
{
    /** @test */
    public function signingDetectsConflictWhenExistingPrecedingContractIsStillActive(): void
    {
        $this->expectException(AssignmentPeriodOverlapsException::class);

        $enteredContracts = [
            Term::fromArray([
                'contract_id' => 'a391c713-2cf7-4500-b997-e37ea24c5889',
                'person_id' => '71efb6b7-6eb1-4b17-b1d5-a3a47bac78f1',
                'start_date' => '2019-02-01',
                'end_date' => '2020-01-31',
            ])
        ];

        ServiceContract::enter(
            ServiceContractId::fromString('b88f676e-221d-4807-97c9-8f549b13425a'),
            PersonId::fromString('71efb6b7-6eb1-4b17-b1d5-a3a47bac78f1'),
            $this->getPersonalData(),
            AssignmentPeriod::with(
                new DateTimeImmutable('2020-01-01'),
                new DateTimeImmutable('2020-12-31'),
            ),
            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',
            $enteredContracts
        );
    }
}

public function postAction(Request $request)
{
    $command = new CreateTaskCommand($request->get('name'), $request->get('startDate'));

    $this->get('command_bus')->handle($command);

    return $this->createView(???); // here I want to return new created entity as a response body with 201 CREATED status code
}

public function postAction(Request $request)
{
    $uuid = $request->get('uuid'); // or new TaskId();
    $command = new CreateTaskCommand($uuid, $request->get('name'), $request->get('startDate'));

    $this->get('command_bus')->handle($command);

    // here we fetch the new entity from the storage
    $entity = $someService->find($uuid);

    return $this->createView($entity);
}