TaskController::redoAction() - 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::redoAction() A

↳ Parent: TaskController

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	10
nc	2
nop	2

<?php

namespace Todo\Web\ApiBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Todo\Application\Task\Command;
use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
use Todo\Application\Task\Exception\TaskCannotBeSavedException;
use Todo\Application\Task\Query;
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;

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

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

        $name = $request->get('name');
        try {
            $taskCommand->addNewTask($name);
        } catch (TaskNameIsEmptyException | TaskNameIsAlreadyExistedException | TaskCannotBeSavedException $e) {
            $errors[] = $e->getMessage();
        }


        return $this->json([
            'errors' => $errors
        ]);
    }

    /**
     * CompleteAction
     *
     * @Route("/{taskId}/complete",name="api.task.complete")
     * @Method({"GET"})
     *
     * @return mixed
     */
    public function completeAction(
        Command $taskCommand,
        $taskId
    ) {
        $errors = [];

        try {
            $taskCommand->completeTask($taskId);
        } catch (TaskNotFoundException | TaskCannotBeSavedException $e) {
            $errors[] = $e->getMessage();
        }

        return $this->json([
            'errors' => $errors
        ]);
    }

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


        return $this->json([
            'errors' => $errors
        ]);
    }

    /**
     * UpdateAction
     *
     * @Route("/{taskId}/update",name="api.task.update")
     * @Method({"POST"})
     *
     * @return mixed
     */
    public function updateAction(
        Request $request,
        Command $taskCommand,
        $taskId
    ) {
        $errors = [];

        $name = $request->get('name');
        $status = $request->get('status');


        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();

            }
        }


        return $this->json([
            'errors' => $errors
        ]);
    }

    /**
     * DeleteAction
     *
     * @Route("/{taskId}/delete",name="api.task.delete")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskNotFoundException
     * @throws TaskCannotBeRemovedException
     */
    public function deleteAction(
        Command $taskCommand,
        $taskId
    ) {
        $errors = [];

        try {
            $taskCommand->removeTask($taskId);
        } catch (TaskNotFoundException | TaskCannotBeRemovedException $e) {
            $errors[] = $e->getMessage();
        }


        return $this->json([
            'errors' => $errors
        ]);

    }

    /**
     * CleanAction
     *
     * @Route("/clean",name="api.task.clean")
     * @Method({"GET"})
     *
     * @return mixed
     * @throws TaskCannotBeRemovedException
     */
    public function cleanAction(
        Command $taskCommand
    ) {
        $errors = [];

        try {
            $taskCommand->cleanAllCompletedTasks();
        } catch (TaskCannotBeRemovedException $e) {
            throw $e;
        }

        return $this->json([
            'errors' => $errors
        ]);
    }

}


1			<?php
2
3			namespace Todo\Web\ApiBundle\Controller;
4
5			use Symfony\Component\HttpFoundation\Request;
6			use Todo\Application\Task\Command;
7			use Todo\Application\Task\Exception\TaskCannotBeRemovedException;
8			use Todo\Application\Task\Exception\TaskCannotBeSavedException;
9			use Todo\Application\Task\Query;
10			use Symfony\Bundle\FrameworkBundle\Controller\Controller;
11			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
12			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
13			use Todo\Domain\Exception\TaskNameIsAlreadyExistedException;
14			use Todo\Domain\Exception\TaskNameIsEmptyException;
15			use Todo\Domain\Exception\TaskNotFoundException;
16			use Todo\Domain\Task;
17			use Todo\Web\FrontendBundle\Form\CreateTaskForm;
18
19			/**
20			* Class TaskController
21			*
22			* @category None
23			* @package Todo\Web\ApiBundle\Controller
24			* @author Martin Pham <[email protected]>
25			* @license None http://
26			* @link None
27			*
28			* @Route("/task")
29			*/
30			class TaskController extends Controller
31			{
32			/**
33			* ListAction
34			*
35			* @param Query $taskQuery Task Query
36			*
37			* @Route("/list",name="api.task.list")
38			* @Method({"GET"})
39			*
40			* @return \Symfony\Component\HttpFoundation\JsonResponse
41			*/
42			public function listAction(
43			Query $taskQuery
44			) {
45			return $this->json(
46			[
47			'remaining_tasks' => $taskQuery->getAllRemainingTasks(),
48			'completed_tasks' => $taskQuery->getAllCompletedTasks()
49			]
50			);
51			}
52
53			/**
54			* CreateAction
55			*
56			* @Route("/create",name="api.task.create")
57			* @Method({"POST"})
58			*
59			* @return mixed
60			*/
61			public function createAction(
62			Request $request,
63			Command $taskCommand
64			) {
65			$errors = [];
66
67			$name = $request->get('name');
68			try {
69			$taskCommand->addNewTask($name);
70			} catch (TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException \| TaskCannotBeSavedException $e) {
71			$errors[] = $e->getMessage();
72			}
73
74
75			return $this->json([
76			'errors' => $errors
77			]);
78			}
79
80			/**
81			* CompleteAction
82			*
83			* @Route("/{taskId}/complete",name="api.task.complete")
84			* @Method({"GET"})
85			*
86			* @return mixed
87			*/
88			public function completeAction(
89			Command $taskCommand,
90			$taskId
91			) {
92			$errors = [];
93
94			try {
95			$taskCommand->completeTask($taskId);
96			} catch (TaskNotFoundException \| TaskCannotBeSavedException $e) {
97			$errors[] = $e->getMessage();
98			}
99
100			return $this->json([
101			'errors' => $errors
102			]);
103			}
104
105			/**
106			* RedoAction
107			*
108			* @Route("/{taskId}/redo",name="api.task.redo")
109			* @Method({"GET"})
110			*
111			* @return mixed
112			*/
113			public function redoAction(
114			Command $taskCommand,
115			$taskId
116			) {
117			$errors = [];
118			try {
119			$taskCommand->redoTask($taskId);
120			} catch (TaskNotFoundException \| TaskCannotBeSavedException $e) {
121			$errors[] = $e->getMessage();
122			}
123
124
125			return $this->json([
126			'errors' => $errors
127			]);
128			}
129
130			/**
131			* UpdateAction
132			*
133			* @Route("/{taskId}/update",name="api.task.update")
134			* @Method({"POST"})
135			*
136			* @return mixed
137			*/
138			public function updateAction(
139			Request $request,
140			Command $taskCommand,
141			$taskId
142			) {
143			$errors = [];
144
145			$name = $request->get('name');
146			$status = $request->get('status');
147
148
149			if ($name !== null && $status !== null && count($errors) === 0) {
150			try {
151			$taskCommand->editTask(
152			$taskId,
153			[
154			'name' => $name,
155			'status' => $status,
156			]
157			);
158			} catch (TaskNotFoundException \| TaskNameIsEmptyException \| TaskNameIsAlreadyExistedException \| TaskCannotBeSavedException $e) {
159			$errors[] = $e->getMessage();
160
161			}
162			}
163
164
165			return $this->json([
166			'errors' => $errors
167			]);
168			}
169
170			/**
171			* DeleteAction
172			*
173			* @Route("/{taskId}/delete",name="api.task.delete")
174			* @Method({"GET"})
175			*
176			* @return mixed
177			* @throws TaskNotFoundException
178			* @throws TaskCannotBeRemovedException
179			*/
180			public function deleteAction(
181			Command $taskCommand,
182			$taskId
183			) {
184			$errors = [];
185
186			try {
187			$taskCommand->removeTask($taskId);
188			} catch (TaskNotFoundException \| TaskCannotBeRemovedException $e) {
189			$errors[] = $e->getMessage();
190			}
191
192
193			return $this->json([
194			'errors' => $errors
195			]);
196
197			}
198
199			/**
200			* CleanAction
201			*
202			* @Route("/clean",name="api.task.clean")
203			* @Method({"GET"})
204			*
205			* @return mixed
206			* @throws TaskCannotBeRemovedException
207			*/
208			public function cleanAction(
209			Command $taskCommand
210			) {
211			$errors = [];
212
213			try {
214			$taskCommand->cleanAllCompletedTasks();
215			} catch (TaskCannotBeRemovedException $e) {
216			throw $e;
217			}
218
219			return $this->json([
220			'errors' => $errors
221			]);
222			}
223
224			}
225

MartinPham / todo-ddd

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

TaskController::redoAction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like