IncidentBundle\Controller\IncidentController

Complexity

Total Complexity

16

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

83.58%

Importance

Changes	9
Bugs	4	Features	4

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getAction()	0	19	3
B	postAction()	0	25	3
B	putAction()	0	27	2
A	deleteAction()	0	20	3
A	getSerializer()	0	4	1
A	setSerializer()	0	4	1
A	getIncident()	0	11	2
A	getErrorHandlerCallback()	0	6	1

<?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;

    /**
     * Get an exist incident
     *
     * @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));
    }

    /**
     * Updates an exist incident
     *
     * @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');

It seems like $request->getContent() targeting Symfony\Component\HttpFoundation\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?

                $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));
    }

    /**
     * Creates a new incident
     *
     * @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');

It seems like $request->getContent() targeting Symfony\Component\HttpFoundation\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?

            $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));
    }

    /**
     * Delete an exist incident
     *
     * @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']);

The call to ObjectRepository::findOneBy() has too many arguments starting with array('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) {

The parameter $errfile is not used and could be removed.

The parameter $errline is not used and could be removed.

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