IncidentController::putAction() - Code Metrics - Inspection of "fix puli and errors handler" - tonicforhealth/health-checker-incident - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d6aa99...66d238 )

by Dmitry

created 2016-05-24 15:01 UTC

IncidentController::putAction() B

↳ Parent: IncidentController

Complexity

Conditions	2
Paths	7

Size

Total Lines	27
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	2

Importance

Changes	4
Bugs	1	Features	2

Metric	Value
c	4
b	1
f	2
dl	0
loc	27
ccs	14
cts	14
cp	1
rs	8.8571
cc	2
eloc	15
nc	7
nop	1
crap	2

<?php

namespace IncidentBundle\Controller;

use Exception;
use IncidentBundle\Entity\Incident;
use JMS\Serializer\Serializer;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Class IncidentController
 */
class IncidentController extends Controller
{
    /**
     * @var Serializer;
     */
    private $serializer;

    /**
     * @Route("/{ident}")
     * @Method({"GET"})
     *
     * @param int $ident
     *
     * @return Response
     */
    public function getAction($ident)
    {
        $errors = [];
        set_error_handler($this->getErrorHandlerCallback($errors));

        $responseData = ['data' => [], 'error' => []];
        try {
            if ($incident = $this->getIncident($ident, $errors)) {
                /** @var Serializer $serializer */
                $serializer = $this->get('jms_serializer');
                $responseData['data'] = $serializer->toArray($incident);
            }
        } catch (Exception $e) {
            $errors[] = $e;
        }
        $responseData['errors'] = $errors;

        return new Response(json_encode($responseData));
    }

    /**
     * @Route("/{ident}")
     * @Method({"POST"})
     *
     * @param int     $ident
     * @param Request $request
     *
     * @return Response
     */
    public function postAction($ident, Request $request)
    {
        $errors = [];
        set_error_handler($this->getErrorHandlerCallback($errors));

        $responseData = ['data' => [], 'errors' => []];
        try {
            if ($incident = $this->getIncident($ident, $errors)) {
                $entityManager = $this->getDoctrine()->getManager();
                /** @var Serializer $serializer */
                $serializer = $this->get('jms_serializer');
                $incidentNew = $serializer->deserialize($request->getContent(), Incident::class, 'json');

                $incidentNew->setId($incident->getId());
                $entityManager->merge($incidentNew);
                $entityManager->flush();

                $responseData['data'] = $this->get('jms_serializer')->toArray($incident);
            }
        } catch (Exception $e) {
            $errors[] = $e;
        }
        $responseData['errors'] = $errors;

        return new Response(json_encode($responseData));
    }

    /**
     * @Route("/")
     * @Method({"PUT"})
     *
     * @param Request $request
     *
     * @return Response
     */
    public function putAction(Request $request)
    {
        $errors = [];
        set_error_handler($this->getErrorHandlerCallback($errors));

        $responseData = ['data' => [], 'errors' => []];
        try {

            $entityManager = $this->getDoctrine()->getManager();
            /** @var Serializer $serializer */
            $serializer = $this->get('jms_serializer');
            /** @var Incident $incident */
            $incident = $serializer->deserialize($request->getContent(), Incident::class, 'json');


            $entityManager->persist($incident);

            $entityManager->flush();


            $responseData['data'] = $this->get('jms_serializer')->toArray($incident);
        } catch (Exception $e) {
            $errors[] = $e->getMessage();
        }
        $responseData['errors'] = $errors;

        return new Response(json_encode($responseData));
    }

    /**
     * @Route("/{ident}")
     * @Method({"DELETE"})
     *
     * @param int $ident
     *
     * @return Response
     */
    public function deleteAction($ident)
    {
        $errors = [];
        set_error_handler($this->getErrorHandlerCallback($errors));

        $responseData = ['data' => [], 'errors' => []];
        try {
            if ($incident = $this->getIncident($ident, $errors)) {
                $entityManager = $this->getDoctrine()->getManager();
                $entityManager->remove($incident);
                $entityManager->flush();
            }
        } catch (Exception $e) {
            $errors[] = $e;
        }

        $responseData['errors'] = $errors;

        return new Response(json_encode($responseData));
    }

    /**
     * @return Serializer
     */
    public function getSerializer()
    {
        return $this->serializer;
    }

    /**
     * @param Serializer $serializer
     */
    protected function setSerializer(Serializer $serializer)
    {
        $this->serializer = $serializer;
    }

    /**
     * @param string $ident
     * @param array  $errors
     *
     * @return Incident
     */
    protected function getIncident($ident, &$errors)
    {
        $incident = $this->getDoctrine()
            ->getRepository('IncidentBundle:Incident')
            ->findOneBy(['ident' => $ident], ['id' => 'desc']);

        if (!$incident) {
            $errors[] = ['code' => 404, 'text' => 'Incident not find'];
        }

        return $incident;
    }

    /**
     * @param array $errors
     *
     * @return \Closure
     */
    protected function getErrorHandlerCallback(&$errors)
    {
        return function ($errno, $errstr, $errfile, $errline) use (&$errors) {

            $errors[] = ['code' => $errno, 'text' => $errstr];
        };
    }
}


1		<?php
2
3		namespace IncidentBundle\Controller;
4
5		use Exception;
6		use IncidentBundle\Entity\Incident;
7		use JMS\Serializer\Serializer;
8		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
9		use Symfony\Bundle\FrameworkBundle\Controller\Controller;
10		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
11		use Symfony\Component\HttpFoundation\Request;
12		use Symfony\Component\HttpFoundation\Response;
13
14		/**
15		* Class IncidentController
16		*/
17		class IncidentController extends Controller
18		{
19		/**
20		* @var Serializer;
21		*/
22		private $serializer;
23
24		/**
25		* @Route("/{ident}")
26		* @Method({"GET"})
27		*
28		* @param int $ident
29		*
30		* @return Response
31		*/
32	2	public function getAction($ident)
33		{
34	2	$errors = [];
35	2	set_error_handler($this->getErrorHandlerCallback($errors));
36
37	2	$responseData = ['data' => [], 'error' => []];
38		try {
39	2	if ($incident = $this->getIncident($ident, $errors)) {
40		/** @var Serializer $serializer */
41	1	$serializer = $this->get('jms_serializer');
42	2	$responseData['data'] = $serializer->toArray($incident);
43		}
44		} catch (Exception $e) {
45		$errors[] = $e;
46		}
47	2	$responseData['errors'] = $errors;
48
49	2	return new Response(json_encode($responseData));
50		}
51
52		/**
53		* @Route("/{ident}")
54		* @Method({"POST"})
55		*
56		* @param int $ident
57		* @param Request $request
58		*
59		* @return Response
60		*/
61	2	public function postAction($ident, Request $request)
62		{
63	2	$errors = [];
64	2	set_error_handler($this->getErrorHandlerCallback($errors));
65
66	2	$responseData = ['data' => [], 'errors' => []];
67		try {
68	2	if ($incident = $this->getIncident($ident, $errors)) {
69	1	$entityManager = $this->getDoctrine()->getManager();
70		/** @var Serializer $serializer */
71	1	$serializer = $this->get('jms_serializer');
72	1	$incidentNew = $serializer->deserialize($request->getContent(), Incident::class, 'json');
		0 ignored issues – show Bug introduced 2016-03-29 14:43 UTC by Report Bug Copy Issue Report It seems like `$request->getContent()` targeting `Symfony\Component\HttpFo...n\Request::getContent()` can also be of type `resource`; however, `JMS\Serializer\Serializer::deserialize()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
73	1	$incidentNew->setId($incident->getId());
74	1	$entityManager->merge($incidentNew);
75	1	$entityManager->flush();
76
77	2	$responseData['data'] = $this->get('jms_serializer')->toArray($incident);
78		}
79		} catch (Exception $e) {
80		$errors[] = $e;
81		}
82	2	$responseData['errors'] = $errors;
83
84	2	return new Response(json_encode($responseData));
85		}
86
87		/**
88		* @Route("/")
89		* @Method({"PUT"})
90		*
91		* @param Request $request
92		*
93		* @return Response
94		*/
95	2	public function putAction(Request $request)
96		{
97	2	$errors = [];
98	2	set_error_handler($this->getErrorHandlerCallback($errors));
99
100	2	$responseData = ['data' => [], 'errors' => []];
101		try {
102
103	2	$entityManager = $this->getDoctrine()->getManager();
104		/** @var Serializer $serializer */
105	2	$serializer = $this->get('jms_serializer');
106		/** @var Incident $incident */
107	2	$incident = $serializer->deserialize($request->getContent(), Incident::class, 'json');
		0 ignored issues – show Bug introduced 2016-03-29 14:43 UTC by Report Bug Copy Issue Report It seems like `$request->getContent()` targeting `Symfony\Component\HttpFo...n\Request::getContent()` can also be of type `resource`; however, `JMS\Serializer\Serializer::deserialize()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
108
109	2	$entityManager->persist($incident);
110
111	2	$entityManager->flush();
112
113
114	1	$responseData['data'] = $this->get('jms_serializer')->toArray($incident);
115	1	} catch (Exception $e) {
116	1	$errors[] = $e->getMessage();
117		}
118	2	$responseData['errors'] = $errors;
119
120	2	return new Response(json_encode($responseData));
121		}
122
123		/**
124		* @Route("/{ident}")
125		* @Method({"DELETE"})
126		*
127		* @param int $ident
128		*
129		* @return Response
130		*/
131	2	public function deleteAction($ident)
132		{
133	2	$errors = [];
134	2	set_error_handler($this->getErrorHandlerCallback($errors));
135
136	2	$responseData = ['data' => [], 'errors' => []];
137		try {
138	2	if ($incident = $this->getIncident($ident, $errors)) {
139	1	$entityManager = $this->getDoctrine()->getManager();
140	1	$entityManager->remove($incident);
141	2	$entityManager->flush();
142		}
143		} catch (Exception $e) {
144		$errors[] = $e;
145		}
146
147	2	$responseData['errors'] = $errors;
148
149	2	return new Response(json_encode($responseData));
150		}
151
152		/**
153		* @return Serializer
154		*/
155		public function getSerializer()
156		{
157		return $this->serializer;
158		}
159
160		/**
161		* @param Serializer $serializer
162		*/
163		protected function setSerializer(Serializer $serializer)
164		{
165		$this->serializer = $serializer;
166		}
167
168		/**
169		* @param string $ident
170		* @param array $errors
171		*
172		* @return Incident
173		*/
174	6	protected function getIncident($ident, &$errors)
175		{
176	6	$incident = $this->getDoctrine()
177	6	->getRepository('IncidentBundle:Incident')
178	6	->findOneBy(['ident' => $ident], ['id' => 'desc']);
		0 ignored issues – show Unused Code introduced 2016-04-01 14:03 UTC by Report Bug Copy Issue Report The call to `ObjectRepository::findOneBy()` has too many arguments starting with `array('id' => 'desc')`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
179	6	if (!$incident) {
180	4	$errors[] = ['code' => 404, 'text' => 'Incident not find'];
181		}
182
183	6	return $incident;
184		}
185
186		/**
187		* @param array $errors
188		*
189		* @return \Closure
190		*/
191		protected function getErrorHandlerCallback(&$errors)
192		{
193	7	return function ($errno, $errstr, $errfile, $errline) use (&$errors) {
		0 ignored issues – show Unused Code introduced 2016-03-29 14:43 UTC by Report Bug Copy Issue Report The parameter `$errfile` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2016-03-29 14:43 UTC by Report Bug Copy Issue Report The parameter `$errline` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
194		$errors[] = ['code' => $errno, 'text' => $errstr];
195	7	};
196		}
197		}
198

tonicforhealth / health-checker-incident

Push — master ( d6aa99...66d238 )

IncidentController::putAction() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like