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

Passed

Push — master ( 8e4ec1...86ac2d )

by Martin

created 2017-02-04 15:25 UTC

TaskController::completeAction() A

↳ Parent: TaskController

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	2

<?php

namespace Todo\Web\FrontendBundle\Controller;

use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
use Todo\Application\Task\Command;
use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
use Todo\Application\Task\Exception\TaskCannotBeSavedException;
use Todo\Application\Task\Query;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Todo\Domain\Exception\TaskNameIsAlreadyExistedException;
use Todo\Domain\Exception\TaskNameIsEmptyException;
use Todo\Domain\Exception\TaskNotFoundException;
use Todo\Domain\Task;
use Todo\Web\FrontendBundle\Form\CreateTaskForm;
use Todo\Web\FrontendBundle\Form\UpdateTaskForm;

/**
 * Class TaskController
 *
 * @category None
 * @package  Todo\Web\FrontendBundle\Controller
 * @author   Martin Pham <[email protected]>
 * @license  None http://
 * @link     None
 *
 * @Route("/task")
 */
class TaskController extends Controller
{
    /**
     * List
     *
     * @param Query $taskQuery Task Query
     *
     * @Route("/list",name="task.list")
     * @Method({"GET"})
     * @Template()
     *
     * @return array
     */
    public function listAction(
        Query $taskQuery
    ) {
        return [
            'remaining_tasks' => $taskQuery->getAllRemainingTasks(),
            'completed_tasks' => $taskQuery->getAllCompletedTasks()
        ];
    }

    /**
     * CreateAction
     *
     * @Route("/create",name="task.create")
     * @Template()
     * @Method({"GET","POST"})
     *
     * @return mixed
     * @throws \LogicException
     */
    public function createAction(
        FormFactoryInterface $formFactory,
        Request $request,
        Command $taskCommand
    ) {
        $errors = [];

        try {
            $createTaskForm = $formFactory->create(
                CreateTaskForm::class,
                $request->request->all()
            );
        } catch (InvalidOptionsException $e) {
            $errors[] = $e->getMessage();
        }

        if (count($errors) === 0) {
            $createTaskForm->handleRequest($request);
            if ($createTaskForm->isSubmitted() && $createTaskForm->isValid()) {
                try {
                    $name = $createTaskForm->getData()['name'];
                } catch (\OutOfBoundsException $e) {
                    $errors[] = $e->getMessage();
                }

                if (count($errors) === 0) {
                    try {
                        $taskCommand->addNewTask($name);
                    } catch (TaskNameIsEmptyException | TaskNameIsAlreadyExistedException | TaskCannotBeSavedException $e) {
                        $errors[] = $e->getMessage();
                    }

                    if (count($errors) === 0) {
                        return $this->redirectToRoute('task.list');
                    }
                }



            }
        }



        return [
            'errors' => $errors,
            'create_task_form' => $createTaskForm->createView()
        ];
    }

    /**
     * CompleteAction
     *
     * @Route("/{taskId}/complete",name="task.complete")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskCannotBeSavedException
     * @throws TaskNotFoundException
     */
    public function completeAction(
        Command $taskCommand,
        $taskId
    ) {
        try {
            $taskCommand->completeTask($taskId);
        } catch (TaskNotFoundException | TaskCannotBeSavedException $e) {
            throw $e;
        }

        return $this->redirectToRoute('task.list');
    }

    /**
     * RedoAction
     *
     * @Route("/{taskId}/redo",name="task.redo")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskCannotBeSavedException
     * @throws TaskNotFoundException
     */
    public function redoAction(
        Command $taskCommand,
        $taskId
    ) {
        try {
            $taskCommand->redoTask($taskId);
        } catch (TaskNotFoundException | TaskCannotBeSavedException $e) {
            throw $e;
        }

        return $this->redirectToRoute('task.list');
    }

    /**
     * UpdateAction
     *
     * @Route("/{taskId}/update",name="task.update")
     * @Method({"GET","POST"})
     * @Template()
     *
     * @return mixed
     */
    public function updateAction(
        FormFactoryInterface $formFactory,
        Request $request,
        Query $taskQuery,
        Command $taskCommand,
        $taskId
    ) {
        $errors = [];
        try {
            $task = $taskQuery->getTaskById($taskId);
        } catch (TaskNotFoundException $e) {
            $errors[] = $e->getMessage();
        }

        $updateTaskForm = null;
        if (count($errors) === 0) {
            try {
                $updateTaskForm = $formFactory->create(
                    UpdateTaskForm::class,
                    ($request->get('name') !== null) ? $request->request->all() : $task
                );
            } catch (InvalidOptionsException $e) {
                $errors[] = $e->getMessage();
            }
        }

        if ($updateTaskForm !== null && count($errors) === 0) {
            $updateTaskForm->handleRequest($request);
            if ($updateTaskForm->isSubmitted() && $updateTaskForm->isValid()) {
                $name = null;
                $status = null;
                try {
                    /** @var Task $task */
                    $task = $updateTaskForm->getData();

                    $name = $task->getName();
                    $status = $task->getStatus();

                } catch (\OutOfBoundsException | \LogicException $e) {
                    $errors[] = $e->getMessage();
                }

                if ($name !== null && $status !== null && count($errors) === 0) {
                    try {
                        $taskCommand->editTask(
                            $taskId,
                            [
                                'name'   => $name,
                                'status' => $status,
                            ]
                        );
                    } catch (TaskNotFoundException | TaskNameIsEmptyException | TaskNameIsAlreadyExistedException | TaskCannotBeSavedException $e) {
                        $errors[] = $e->getMessage();

                    }
                }

                if (count($errors) === 0) {
                    return $this->redirectToRoute('task.list');
                }


            }

        }


        return [
            'errors' => $errors,
            'update_task_form' => $updateTaskForm->createView()
        ];
    }

    /**
     * DeleteAction
     *
     * @Route("/{taskId}/delete",name="task.delete")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskNotFoundException
     * @throws TaskCannotBeRemovedException
     */
    public function deleteAction(
        Command $taskCommand,
        $taskId
    ) {
        try {
            $taskCommand->removeTask($taskId);
        } catch (TaskNotFoundException | TaskCannotBeRemovedException $e) {
            throw $e;
        }

        return $this->redirectToRoute('task.list');

    }

    /**
     * CleanAction
     *
     * @Route("/clean",name="task.clean")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskCannotBeRemovedException
     */
    public function cleanAction(
        Command $taskCommand
    ) {
        try {
            $taskCommand->cleanAllCompletedTasks();
        } catch (TaskCannotBeRemovedException $e) {
            throw $e;
        }
        return $this->redirectToRoute('task.list');
    }

}


1			<?php
2
3			namespace Todo\Web\FrontendBundle\Controller;
4
5			use Symfony\Component\Form\FormFactoryInterface;
6			use Symfony\Component\HttpFoundation\Request;
7			use Symfony\Component\HttpFoundation\Session\Session;
8			use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
9			use Todo\Application\Task\Command;
10			use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
11			use Todo\Application\Task\Exception\TaskCannotBeSavedException;
12			use Todo\Application\Task\Query;
13			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
14			use Symfony\Bundle\FrameworkBundle\Controller\Controller;
15			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
16			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
17			use Todo\Domain\Exception\TaskNameIsAlreadyExistedException;
18			use Todo\Domain\Exception\TaskNameIsEmptyException;
19			use Todo\Domain\Exception\TaskNotFoundException;
20			use Todo\Domain\Task;
21			use Todo\Web\FrontendBundle\Form\CreateTaskForm;
22			use Todo\Web\FrontendBundle\Form\UpdateTaskForm;
23
24			/**
25			* Class TaskController
26			*
27			* @category None
28			* @package Todo\Web\FrontendBundle\Controller
29			* @author Martin Pham <[email protected]>
30			* @license None http://
31			* @link None
32			*
33			* @Route("/task")
34			*/
35			class TaskController extends Controller
36			{
37			/**
38			* List
39			*
40			* @param Query $taskQuery Task Query
41			*
42			* @Route("/list",name="task.list")
43			* @Method({"GET"})
44			* @Template()
45			*
46			* @return array
47			*/
48			public function listAction(
49			Query $taskQuery
50			) {
51			return [
52			'remaining_tasks' => $taskQuery->getAllRemainingTasks(),
53			'completed_tasks' => $taskQuery->getAllCompletedTasks()
54			];
55			}
56
57			/**
58			* CreateAction
59			*
60			* @Route("/create",name="task.create")
61			* @Template()
62			* @Method({"GET","POST"})
63			*
64			* @return mixed
65			* @throws \LogicException
66			*/
67			public function createAction(
68			FormFactoryInterface $formFactory,
69			Request $request,
70			Command $taskCommand
71			) {
72			$errors = [];
73
74			try {
75			$createTaskForm = $formFactory->create(
76			CreateTaskForm::class,
77			$request->request->all()
78			);
79			} catch (InvalidOptionsException $e) {
80			$errors[] = $e->getMessage();
81			}
82
83			if (count($errors) === 0) {
84			$createTaskForm->handleRequest($request);
85			if ($createTaskForm->isSubmitted() && $createTaskForm->isValid()) {
86			try {
87			$name = $createTaskForm->getData()['name'];
88			} catch (\OutOfBoundsException $e) {
89			$errors[] = $e->getMessage();
90			}
91
92			if (count($errors) === 0) {
93			try {
94			$taskCommand->addNewTask($name);
95			} catch (TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException \| TaskCannotBeSavedException $e) {
96			$errors[] = $e->getMessage();
97			}
98
99			if (count($errors) === 0) {
100			return $this->redirectToRoute('task.list');
101			}
102			}
103
104
105
106			}
107			}
108
109
110
111			return [
112			'errors' => $errors,
113			'create_task_form' => $createTaskForm->createView()
114			];
115			}
116
117			/**
118			* CompleteAction
119			*
120			* @Route("/{taskId}/complete",name="task.complete")
121			* @Method({"GET"})
122			*
123			* @return mixed
124			* @throws TaskCannotBeSavedException
125			* @throws TaskNotFoundException
126			*/
127			public function completeAction(
128			Command $taskCommand,
129			$taskId
130			) {
131			try {
132			$taskCommand->completeTask($taskId);
133			} catch (TaskNotFoundException \| TaskCannotBeSavedException $e) {
134			throw $e;
135			}
136
137			return $this->redirectToRoute('task.list');
138			}
139
140			/**
141			* RedoAction
142			*
143			* @Route("/{taskId}/redo",name="task.redo")
144			* @Method({"GET"})
145			*
146			* @return mixed
147			* @throws TaskCannotBeSavedException
148			* @throws TaskNotFoundException
149			*/
150			public function redoAction(
151			Command $taskCommand,
152			$taskId
153			) {
154			try {
155			$taskCommand->redoTask($taskId);
156			} catch (TaskNotFoundException \| TaskCannotBeSavedException $e) {
157			throw $e;
158			}
159
160			return $this->redirectToRoute('task.list');
161			}
162
163			/**
164			* UpdateAction
165			*
166			* @Route("/{taskId}/update",name="task.update")
167			* @Method({"GET","POST"})
168			* @Template()
169			*
170			* @return mixed
171			*/
172			public function updateAction(
173			FormFactoryInterface $formFactory,
174			Request $request,
175			Query $taskQuery,
176			Command $taskCommand,
177			$taskId
178			) {
179			$errors = [];
180			try {
181			$task = $taskQuery->getTaskById($taskId);
182			} catch (TaskNotFoundException $e) {
183			$errors[] = $e->getMessage();
184			}
185
186			$updateTaskForm = null;
187			if (count($errors) === 0) {
188			try {
189			$updateTaskForm = $formFactory->create(
190			UpdateTaskForm::class,
191			($request->get('name') !== null) ? $request->request->all() : $task
192			);
193			} catch (InvalidOptionsException $e) {
194			$errors[] = $e->getMessage();
195			}
196			}
197
198			if ($updateTaskForm !== null && count($errors) === 0) {
199			$updateTaskForm->handleRequest($request);
200			if ($updateTaskForm->isSubmitted() && $updateTaskForm->isValid()) {
201			$name = null;
202			$status = null;
203			try {
204			/** @var Task $task */
205			$task = $updateTaskForm->getData();
206
207			$name = $task->getName();
208			$status = $task->getStatus();
209
210			} catch (\OutOfBoundsException \| \LogicException $e) {
211			$errors[] = $e->getMessage();
212			}
213
214			if ($name !== null && $status !== null && count($errors) === 0) {
215			try {
216			$taskCommand->editTask(
217			$taskId,
218			[
219			'name' => $name,
220			'status' => $status,
221			]
222			);
223			} catch (TaskNotFoundException \| TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException \| TaskCannotBeSavedException $e) {
224			$errors[] = $e->getMessage();
225
226			}
227			}
228
229			if (count($errors) === 0) {
230			return $this->redirectToRoute('task.list');
231			}
232
233
234			}
235
236			}
237
238
239			return [
240			'errors' => $errors,
241			'update_task_form' => $updateTaskForm->createView()
242			];
243			}
244
245			/**
246			* DeleteAction
247			*
248			* @Route("/{taskId}/delete",name="task.delete")
249			* @Method({"GET"})
250			*
251			* @return mixed
252			* @throws TaskNotFoundException
253			* @throws TaskCannotBeRemovedException
254			*/
255			public function deleteAction(
256			Command $taskCommand,
257			$taskId
258			) {
259			try {
260			$taskCommand->removeTask($taskId);
261			} catch (TaskNotFoundException \| TaskCannotBeRemovedException $e) {
262			throw $e;
263			}
264
265			return $this->redirectToRoute('task.list');
266
267			}
268
269			/**
270			* CleanAction
271			*
272			* @Route("/clean",name="task.clean")
273			* @Method({"GET"})
274			*
275			* @return mixed
276			* @throws TaskCannotBeRemovedException
277			*/
278			public function cleanAction(
279			Command $taskCommand
280			) {
281			try {
282			$taskCommand->cleanAllCompletedTasks();
283			} catch (TaskCannotBeRemovedException $e) {
284			throw $e;
285			}
286			return $this->redirectToRoute('task.list');
287			}
288
289			}
290

MartinPham / todo-ddd

Push — master ( 8e4ec1...86ac2d )

TaskController::completeAction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like