Kreta\TaskManager\Application\Command\Project\Task\CreateTaskHandler

Complexity

Total Complexity

21

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	19

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	areTaskAndParentIdsDifferent()	0	4	3
A	doesTaskExist()	0	4	1
A	doesParentTaskExist()	0	4	2
A	doesProjectExist()	0	4	1
A	__construct()	0	11	1
B	__invoke()	0	60	5
A	checkUsersAreOrganizationMembers()	0	8	1
A	checkAssigneeIsOrganizationMember()	0	6	2
A	checkCreatorIsOrganizationMember()	0	6	2
A	parentTaskId()	0	4	2
A	becomeUserIdToDomainMemberId()	0	4	1

<?php

/*
 * This file is part of the Kreta package.
 *
 * (c) Beñat Espiña <benatespina@gmail.com>
 * (c) Gorka Laucirica <gorka.lauzirika@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Kreta\TaskManager\Application\Command\Project\Task;

use Kreta\TaskManager\Domain\Model\Organization\MemberId;
use Kreta\TaskManager\Domain\Model\Organization\Organization;
use Kreta\TaskManager\Domain\Model\Organization\OrganizationMemberDoesNotExistException;
use Kreta\TaskManager\Domain\Model\Organization\OrganizationRepository;
use Kreta\TaskManager\Domain\Model\Project\Project;
use Kreta\TaskManager\Domain\Model\Project\ProjectDoesNotExistException;
use Kreta\TaskManager\Domain\Model\Project\ProjectId;
use Kreta\TaskManager\Domain\Model\Project\ProjectRepository;
use Kreta\TaskManager\Domain\Model\Project\Task\NumericId;
use Kreta\TaskManager\Domain\Model\Project\Task\Task;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskAlreadyExistsException;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskAndTaskParentCannotBeTheSameException;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskId;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskParentDoesNotExistException;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskPriority;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskRepository;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskSpecificationFactory;
use Kreta\TaskManager\Domain\Model\Project\Task\TaskTitle;
use Kreta\TaskManager\Domain\Model\Project\Task\UnauthorizedTaskActionException;
use Kreta\TaskManager\Domain\Model\User\UserId;

class CreateTaskHandler
{
    private $repository;
    private $specificationFactory;
    private $projectRepository;
    private $organizationRepository;

    public function __construct(
        TaskRepository $repository,
        TaskSpecificationFactory $specificationFactory,
        ProjectRepository $projectRepository,
        OrganizationRepository $organizationRepository
    ) {
        $this->repository = $repository;
        $this->specificationFactory = $specificationFactory;
        $this->projectRepository = $projectRepository;
        $this->organizationRepository = $organizationRepository;
    }

    public function __invoke(CreateTaskCommand $command)
    {
        $taskId = $command->taskId();
        $parentTaskId = $command->parentId();

        if (!$this->areTaskAndParentIdsDifferent($taskId, $parentTaskId)) {
            throw new TaskAndTaskParentCannotBeTheSameException();
        }

        $task = $this->repository->taskOfId(TaskId::generate($taskId));
        if ($this->doesTaskExist($task)) {
            throw new TaskAlreadyExistsException();
        }

        $parentTask = $this->repository->taskOfId(TaskId::generate($parentTaskId));
        if (!$this->doesParentTaskExist($parentTaskId, $parentTask)) {
            throw new TaskParentDoesNotExistException();
        }

        $projectId = $command->projectId();
        $project = $this->projectRepository->projectOfId(ProjectId::generate($projectId));
        if (!$this->doesProjectExist($project)) {
            throw new ProjectDoesNotExistException();
        }

        $organizationId = $project->organizationId();
        $creatorId = UserId::generate($command->creatorId());
        $assigneeId = UserId::generate($command->assigneeId());

        $organization = $this->organizationRepository->organizationOfId($organizationId);

        $this->checkUsersAreOrganizationMembers($organization, $creatorId, $assigneeId);

        $taskId = TaskId::generate($taskId);
        $title = new TaskTitle($command->title());
        $description = $command->description();
        $creator = $this->becomeUserIdToDomainMemberId($organization, $creatorId);
        $assignee = $this->becomeUserIdToDomainMemberId($organization, $assigneeId);
        $priority = new TaskPriority($command->priority());
        $projectId = ProjectId::generate($projectId);
        $parentTaskId = $this->parentTaskId($parentTaskId);

        $tasksNumber = $this->repository->count(
            $this->specificationFactory->buildByProjectSpecification($projectId)
        );
        $numericId = NumericId::fromPrevious($tasksNumber);

        $task = new Task(
            $taskId,
            $numericId,
            $title,
            $description,
            $creator,
            $assignee,
            $priority,
            $projectId,
            $parentTaskId
        );
        $this->repository->persist($task);
    }

    private function areTaskAndParentIdsDifferent(?string $taskId, ?string $parentTaskId) : bool
    {
        return ($taskId === null && $parentTaskId === null) || $parentTaskId !== $taskId;
    }

    private function doesTaskExist(?Task $task) : bool
    {
        return $task instanceof Task;
    }

    private function doesParentTaskExist(?string $parentTaskId, Task $parentTask = null) : bool
    {
        return null === $parentTaskId || $parentTask instanceof Task;
    }

    private function doesProjectExist(?Project $project) : bool
    {
        return $project instanceof Project;
    }

    private function checkUsersAreOrganizationMembers(
        Organization $organization,
        UserId $creatorId,
        UserId $assigneeId
    ) : void {
        $this->checkCreatorIsOrganizationMember($organization, $creatorId);
        $this->checkAssigneeIsOrganizationMember($organization, $assigneeId);
    }

    private function checkAssigneeIsOrganizationMember(Organization $organization, UserId $assigneeId) : void
    {
        if (!$organization->isOrganizationMember($assigneeId)) {
            throw new OrganizationMemberDoesNotExistException($assigneeId);
        }
    }

    private function checkCreatorIsOrganizationMember(Organization $organization, UserId $creatorId) : void
    {
        if (!$organization->isOrganizationMember($creatorId)) {
            throw new UnauthorizedTaskActionException();
        }
    }

    private function parentTaskId(?string $parentTaskId) : ?TaskId
    {
        return null === $parentTaskId ? null : TaskId::generate($parentTaskId);
    }

    private function becomeUserIdToDomainMemberId(Organization $organization, UserId $userId) : MemberId
    {
        return $organization->organizationMember($userId)->id();
    }
}