Command::editTask() - Code Metrics - Inspection of "no message" - MartinPham/todo-ddd - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 783d3e...cfd8c6 )

by Martin

created 2017-02-04 13:04 UTC

Command::editTask() B

↳ Parent: Command

Complexity

Conditions	6
Paths	10

Size

Total Lines	35
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	35
rs	8.439
c	0
b	0
f	0
cc	6
eloc	18
nc	10
nop	2

<?php

namespace Todo\Application\Task;
use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
use Todo\Application\Task\Exception\TaskCannotBeSavedException;
use Todo\Domain\Exception\TaskNameIsAlreadyExistedException;
use Todo\Domain\Exception\TaskNameIsEmptyException;
use Todo\Domain\Exception\TaskNotFoundException;
use Todo\Domain\Factory\TaskFactory;
use Todo\Domain\Repository\TaskRepositoryInterface;
use Todo\Domain\Service\TaskValidationService;
use Todo\Domain\Specification\TaskNameIsNotEmptySpecification;
use Todo\Domain\Specification\TaskNameIsUniqueSpecification;
use Todo\Domain\Task;

/**
 * Class Command
 *
 * @category None
 * @package  Todo\Application\Task
 * @author   Martin Pham <[email protected]>
 * @license  None http://
 * @link     None
 */
class Command
{
    /**
     * TaskRepository
     *
     * @var TaskRepositoryInterface
     */
    protected $taskRepository;

    /**
     * TaskValidationService
     *
     * @var TaskValidationService
     */
    protected $taskValidationService;

    /**
     * TaskFactory
     *
     * @var TaskFactory
     */
    protected $taskFactory;

    /**
     * Command constructor
     *
     * @param TaskRepositoryInterface $taskRepository Task Repository
     */
    public function __construct(
        TaskRepositoryInterface $taskRepository
    ) {
        $this->taskRepository = $taskRepository;
        $this->taskFactory = new TaskFactory($this->taskRepository);
        $this->taskValidationService = new TaskValidationService($this->taskRepository);
    }


    /**
     * Add New Task
     *
     * @param string $name Name
     *
     * @return Task
     * @throws TaskCannotBeSavedException
     * @throws TaskNameIsAlreadyExistedException
     * @throws TaskNameIsEmptyException
     */
    public function addNewTask(string $name) : Task
    {
        try {
            $task = $this->taskFactory->createFromName($name);
        } catch (TaskNameIsEmptyException | TaskNameIsAlreadyExistedException $e) {
            throw $e;
        }

        $result = $this->taskRepository->save($task);

        if (!$result) {
            throw new TaskCannotBeSavedException(
                'Cannot save task into repository.'
            );
        }

        return $task;
    }

    /**
     * Complete Task
     *
     * @param string $taskId Task ID
     *
     * @return Task
     * @throws TaskNotFoundException
     * @throws TaskCannotBeSavedException
     */
    public function completeTask($taskId) : Task
    {
        try {
            $task = $this->taskRepository->find($taskId);
        } catch (TaskNotFoundException $e) {
            throw $e;
        }

        $task->setStatus(Task::STATUS_COMPLETED);

        $result = $this->taskRepository->save($task);

        if (!$result) {
            throw new TaskCannotBeSavedException(
                'Cannot save task into repository.'
            );
        }

        return $task;
    }

    /**
     * Redo Task
     *
     * @param string $taskId Task ID
     *
     * @return Task
     * @throws TaskNotFoundException
     * @throws TaskCannotBeSavedException
     */
    public function redoTask(string $taskId) : Task
    {
        try {
            $task = $this->taskRepository->find($taskId);
        } catch (TaskNotFoundException $e) {
            throw $e;
        }

        $task->setStatus(Task::STATUS_REMAINING);

        $result = $this->taskRepository->save($task);

        if (!$result) {
            throw new TaskCannotBeSavedException(
                'Cannot save task into repository.'
            );
        }

        return $task;
    }

    /**
     * EditTask
     *
     * @param string $taskId ID
     * @param array  $data   Field
     *
     * @return Task
     * @throws TaskCannotBeSavedException
     * @throws TaskNotFoundException
     * @throws TaskNameIsAlreadyExistedException
     * @throws TaskNameIsEmptyException
     */
    public function editTask(string $taskId, array $data) : Task
    {
        try {
            $task = $this->taskRepository->find($taskId);
        } catch (TaskNotFoundException $e) {
            throw $e;
        }

        if (isset($data['name'])) {
            try {
                $this->taskValidationService->validateName($data['name'], $taskId);
            } catch (TaskNameIsEmptyException | TaskNameIsAlreadyExistedException $e) {
                throw $e;
            }


            $task->setName($data['name']);
        }



        if (isset($data['status'])) {
            $task->setStatus($data['status']);
        }

        $result = $this->taskRepository->save($task);

        if (!$result) {
            throw new TaskCannotBeSavedException(
                'Cannot save task into repository.'
            );
        }

        return $task;
    }


    /**
     * RemoveTask
     *
     * @param string $taskId ID
     *
     * @return void
     * @throws TaskCannotBeRemovedException
     * @throws TaskNotFoundException
     */
    public function removeTask($taskId)
    {
        try {
            $task = $this->taskRepository->find($taskId);
        } catch (TaskNotFoundException $e) {
            throw $e;
        }

        $result = $this->taskRepository->remove($task);

        if (!$result) {
            throw new TaskCannotBeRemovedException(
                'Cannot remove task(s) from repository.'
            );
        }
    }

    /**
     * CleanAllCompletedTasks
     *
     * @return void
     * @throws TaskCannotBeRemovedException
     */
    public function cleanAllCompletedTasks()
    {
        $result = $this->taskRepository->removeByStatus(Task::STATUS_COMPLETED);

        if (!$result) {
            throw new TaskCannotBeRemovedException(
                'Cannot remove task(s) from repository.'
            );
        }
    }
}


1			<?php
2
3			namespace Todo\Application\Task;
4			use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
5			use Todo\Application\Task\Exception\TaskCannotBeSavedException;
6			use Todo\Domain\Exception\TaskNameIsAlreadyExistedException;
7			use Todo\Domain\Exception\TaskNameIsEmptyException;
8			use Todo\Domain\Exception\TaskNotFoundException;
9			use Todo\Domain\Factory\TaskFactory;
10			use Todo\Domain\Repository\TaskRepositoryInterface;
11			use Todo\Domain\Service\TaskValidationService;
12			use Todo\Domain\Specification\TaskNameIsNotEmptySpecification;
13			use Todo\Domain\Specification\TaskNameIsUniqueSpecification;
14			use Todo\Domain\Task;
15
16			/**
17			* Class Command
18			*
19			* @category None
20			* @package Todo\Application\Task
21			* @author Martin Pham <[email protected]>
22			* @license None http://
23			* @link None
24			*/
25			class Command
26			{
27			/**
28			* TaskRepository
29			*
30			* @var TaskRepositoryInterface
31			*/
32			protected $taskRepository;
33
34			/**
35			* TaskValidationService
36			*
37			* @var TaskValidationService
38			*/
39			protected $taskValidationService;
40
41			/**
42			* TaskFactory
43			*
44			* @var TaskFactory
45			*/
46			protected $taskFactory;
47
48			/**
49			* Command constructor
50			*
51			* @param TaskRepositoryInterface $taskRepository Task Repository
52			*/
53			public function __construct(
54			TaskRepositoryInterface $taskRepository
55			) {
56			$this->taskRepository = $taskRepository;
57			$this->taskFactory = new TaskFactory($this->taskRepository);
58			$this->taskValidationService = new TaskValidationService($this->taskRepository);
59			}
60
61
62			/**
63			* Add New Task
64			*
65			* @param string $name Name
66			*
67			* @return Task
68			* @throws TaskCannotBeSavedException
69			* @throws TaskNameIsAlreadyExistedException
70			* @throws TaskNameIsEmptyException
71			*/
72			public function addNewTask(string $name) : Task
73			{
74			try {
75			$task = $this->taskFactory->createFromName($name);
76			} catch (TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException $e) {
77			throw $e;
78			}
79
80			$result = $this->taskRepository->save($task);
81
82			if (!$result) {
83			throw new TaskCannotBeSavedException(
84			'Cannot save task into repository.'
85			);
86			}
87
88			return $task;
89			}
90
91			/**
92			* Complete Task
93			*
94			* @param string $taskId Task ID
95			*
96			* @return Task
97			* @throws TaskNotFoundException
98			* @throws TaskCannotBeSavedException
99			*/
100			public function completeTask($taskId) : Task
101			{
102			try {
103			$task = $this->taskRepository->find($taskId);
104			} catch (TaskNotFoundException $e) {
105			throw $e;
106			}
107
108			$task->setStatus(Task::STATUS_COMPLETED);
109
110			$result = $this->taskRepository->save($task);
111
112			if (!$result) {
113			throw new TaskCannotBeSavedException(
114			'Cannot save task into repository.'
115			);
116			}
117
118			return $task;
119			}
120
121			/**
122			* Redo Task
123			*
124			* @param string $taskId Task ID
125			*
126			* @return Task
127			* @throws TaskNotFoundException
128			* @throws TaskCannotBeSavedException
129			*/
130			public function redoTask(string $taskId) : Task
131			{
132			try {
133			$task = $this->taskRepository->find($taskId);
134			} catch (TaskNotFoundException $e) {
135			throw $e;
136			}
137
138			$task->setStatus(Task::STATUS_REMAINING);
139
140			$result = $this->taskRepository->save($task);
141
142			if (!$result) {
143			throw new TaskCannotBeSavedException(
144			'Cannot save task into repository.'
145			);
146			}
147
148			return $task;
149			}
150
151			/**
152			* EditTask
153			*
154			* @param string $taskId ID
155			* @param array $data Field
156			*
157			* @return Task
158			* @throws TaskCannotBeSavedException
159			* @throws TaskNotFoundException
160			* @throws TaskNameIsAlreadyExistedException
161			* @throws TaskNameIsEmptyException
162			*/
163			public function editTask(string $taskId, array $data) : Task
164			{
165			try {
166			$task = $this->taskRepository->find($taskId);
167			} catch (TaskNotFoundException $e) {
168			throw $e;
169			}
170
171			if (isset($data['name'])) {
172			try {
173			$this->taskValidationService->validateName($data['name'], $taskId);
174			} catch (TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException $e) {
175			throw $e;
176			}
177
178
179			$task->setName($data['name']);
180			}
181
182
183
184			if (isset($data['status'])) {
185			$task->setStatus($data['status']);
186			}
187
188			$result = $this->taskRepository->save($task);
189
190			if (!$result) {
191			throw new TaskCannotBeSavedException(
192			'Cannot save task into repository.'
193			);
194			}
195
196			return $task;
197			}
198
199
200			/**
201			* RemoveTask
202			*
203			* @param string $taskId ID
204			*
205			* @return void
206			* @throws TaskCannotBeRemovedException
207			* @throws TaskNotFoundException
208			*/
209			public function removeTask($taskId)
210			{
211			try {
212			$task = $this->taskRepository->find($taskId);
213			} catch (TaskNotFoundException $e) {
214			throw $e;
215			}
216
217			$result = $this->taskRepository->remove($task);
218
219			if (!$result) {
220			throw new TaskCannotBeRemovedException(
221			'Cannot remove task(s) from repository.'
222			);
223			}
224			}
225
226			/**
227			* CleanAllCompletedTasks
228			*
229			* @return void
230			* @throws TaskCannotBeRemovedException
231			*/
232			public function cleanAllCompletedTasks()
233			{
234			$result = $this->taskRepository->removeByStatus(Task::STATUS_COMPLETED);
235
236			if (!$result) {
237			throw new TaskCannotBeRemovedException(
238			'Cannot remove task(s) from repository.'
239			);
240			}
241			}
242			}
243

MartinPham / todo-ddd

Push — master ( 783d3e...cfd8c6 )

Command::editTask() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like