AppBundle\Serializer\SurveyNormalizer

Complexity

Total Complexity

16

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	denormalize()	0	35	8
A	supportsDenormalization()	0	8	2
A	supportsNormalization()	0	4	1
B	normalize()	0	28	4

<?php

namespace AppBundle\Serializer;

use AppBundle\Entity\Survey\Survey;
use AppBundle\Entity\Survey\SurveyAnswer;
use Doctrine\Bundle\DoctrineBundle\Registry;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
use Symfony\Component\Serializer\Exception\LogicException;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;

class SurveyNormalizer extends ObjectNormalizer
{
    /**
     * @var Registry
     */
    protected $doctrine;

    /**
     * SurveyNormalizer constructor.
     *
     * @param ClassMetadataFactoryInterface|null  $classMDF
     * @param NameConverterInterface|null         $nameCv
     * @param PropertyAccessorInterface|null      $propAs
     * @param PropertyTypeExtractorInterface|null $propTE
     * @param Registry                            $doctrine
     */
    public function __construct($classMDF, $nameCv, $propAs, $propTE, Registry $doctrine)
    {
        parent::__construct($classMDF, $nameCv, $propAs, $propTE);
        $this->doctrine = $doctrine;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null)
    {
        return $data instanceof Survey;
    }
    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        if (!$this->serializer instanceof NormalizerInterface) {
            throw new LogicException('Cannot normalize attributes because injected serializer is not a normalizer');
        }
        /** @var Survey $survey */
        $survey = &$object;
        if (isset($context[ObjectNormalizer::GROUPS])) {
            if ($context[ObjectNormalizer::GROUPS][0] == 'list') {
                return $this->serializer->normalize(new \ArrayObject([
                    'id' => $survey->getId(),
                    'type' => $survey->getType(),
                    'status' => $survey->getStatus(),
                    'createdAt' => $survey->getCreatedAt(),
                    'updatedAt' => $survey->getUpdatedAt(),
                ]), $format, $context);
            }
        }

        return $this->serializer->normalize(new \ArrayObject([
            'id' => $survey->getId(),
            'type' => $survey->getType(),
            'status' => $survey->getStatus(),
            'answers' => $survey->getAnswers(),
            'createdAt' => $survey->getCreatedAt(),
            'updatedAt' => $survey->getUpdatedAt(),
        ]), $format, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function denormalize($data, $class, $format = null, array $context = array())
    {
        if (!$this->serializer instanceof DenormalizerInterface) {
            throw new LogicException('Cannot normalize attributes because injected serializer is not a normalizer');
        }
        if (!isset($context[ObjectNormalizer::OBJECT_TO_POPULATE])) {
            throw new LogicException('Not found object_to_populate');
        }
        /** @var Survey $survey */
        $survey = $context[ObjectNormalizer::OBJECT_TO_POPULATE];

        if (!array_key_exists('answers', $data)) {
            throw new LogicException('Wrong json consruction');
        }
        foreach ($data['answers'] as $item) {
            $answer = $this->serializer->denormalize($item, SurveyAnswer::class, $format, $context);
            $answer->setSurvey($survey);
            $answers[] = $answer;

$answers was never initialized. Although not strictly required by PHP, it is generally a good practice to add $answers = array(); before regardless.

            $this->doctrine->getManager()->persist($answer);
        }
        foreach ($answers as $answer) {

The variable $answers does not seem to be defined for all execution paths leading up to this point.

            $questions[] = $answer->getQuestion()->getId();

$questions was never initialized. Although not strictly required by PHP, it is generally a good practice to add $questions = array(); before regardless.

        }
        foreach ($survey->getQuestions() as $question) {
            $surveyQuestions[] = $question->getId();

$surveyQuestions was never initialized. Although not strictly required by PHP, it is generally a good practice to add $surveyQuestions = array(); before regardless.

        }
        if ($surveyQuestions !== $questions) {

The variable $surveyQuestions does not seem to be defined for all execution paths leading up to this point.

The variable $questions does not seem to be defined for all execution paths leading up to this point.

            throw new LogicException('Wrong json content');
        }
        $survey->setStatus('submited');
        $this->doctrine->getManager()->persist($survey);
        $this->doctrine->getManager()->flush();

        return $survey;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization($data, $type, $format = null)
    {
        if ($type != Survey::class) {
            return false;
        }

        return true;
    }
}