AbstractMutationResolver::preValidate() - Code Metrics - Inspection of "Update demo & tests for latest changes" - ynloultratech/graphql-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 9e9a0d...740d0f )

by Rafael
created 2017-12-15 05:43 UTC
AbstractMutationResolver::preValidate() A

↳ Parent: AbstractMutationResolver
Complexity

Conditions	1
Paths	1
Size

Total Lines	2
Code Lines	0
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	0
nc	1
nop	1
dl	0
loc	2
ccs	1
cts	1
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Mutation;

use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Validator\ConstraintViolation as SymfonyConstraintViolation;
use Ynlo\GraphQLBundle\Form\DataTransformer\DataWithIdToNodeTransformer;
use Ynlo\GraphQLBundle\Model\ConstraintViolation;
use Ynlo\GraphQLBundle\Resolver\AbstractResolver;
use Ynlo\GraphQLBundle\Validator\ConstraintViolationList;

/**
 * Base class for mutations
 * Implement the method "process()" and "returnPayload()" is enough in many scenarios
 */
abstract class AbstractMutationResolver extends AbstractResolver
{
    /**
     * @param array $input
     *
     * @return mixed
     */
    public function __invoke($input)
    {
        $formBuilder = $this->createDefinitionForm($input);

        $form = null;
        if ($formBuilder) {
            $form = $formBuilder->getForm();
        }

        $this->preValidate($input);
        if ($form) {
            $form->submit($input, false);
            $data = $form->getData();
        } else {
            $data = $input;
        }

        $this->onSubmit($input, $data);

        $violations = new ConstraintViolationList();
        if ($form) {
            $this->extractFormErrors($form, $violations);
        }
        $this->postValidation($data, $violations);

        $dryRun = $input['dryRun'] ?? false;

        if ($dryRun) {
            $data = null;
        } else {
            if ((!$form && !$violations->count())
                || ($form->isSubmitted() && $form->isValid() && !$violations->count())
            ) {

                $this->process($data);
            }
        }

        return $this->returnPayload($data, $violations, $input);
    }

    /**
     * Actions to process
     * the result processed data is given to payload
     *
     * @param mixed $data
     */
    abstract protected function process(&$data);

    /**
     * The payload object or array matching the GraphQL definition
     *
     * @param mixed                   $data        normalized data, its the input data processed by the form
     * @param ConstraintViolationList $violations  violations returned by the form validation process
     * @param array                   $inputSource the original submitted data in array
     *
     * @return mixed
     */
    abstract protected function returnPayload($data, ConstraintViolationList $violations, $inputSource);

    /**
     * @param mixed $data
     *
     * @return FormBuilderInterface|null
     */
    protected function createDefinitionForm($data): ?FormBuilderInterface
    {
        if (!$this->context->getDefinition()->hasMeta('form')) {
            return null;
        }

        $formConfig = $this->context->getDefinition()->getMeta('form') ?? [];
        $formType = $formConfig['type'] ?? null;
        if (!$formConfig || !$formType) {
            throw new \RuntimeException(sprintf('Can`t find a valid form for %s', $this->context->getDefinition()->getName()));
        }

        $options = [
            'csrf_protection' => false,
            'allow_extra_fields' => true,
        ];

        $options = array_merge($options, $formConfig['options'] ?? []);
        $form = $this->createFormBuilder($formType, $data, $options);
        $viewTransformer = new DataWithIdToNodeTransformer($this->getManager(), $this->context->getEndpoint());
        $form->addViewTransformer($viewTransformer);

        return $form;
    }

    /**
     * @param FormInterface           $form
     * @param ConstraintViolationList $violations
     * @param null|string             $parentName
     */
    protected function extractFormErrors(FormInterface $form, ConstraintViolationList $violations, ?string $parentName = null)
    {
        $errors = $form->getErrors();
        foreach ($errors as $error) {
            $violation = new ConstraintViolation();

            $path = null;
            if ($form->getParent()) {
                $path = $form->getName();
            }
            if ($parentName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $path = $parentName.'.'.$form->getName();
            }

            $violation->setPropertyPath($path);
            $violation->setMessage($error->getMessage());
            $violation->setMessage($error->/** @scrutinizer ignore-call */ getMessage());
            $violation->setMessageTemplate($error->getMessageTemplate());
            $violation->setMessageTemplate($error->/** @scrutinizer ignore-call */ getMessageTemplate());
            foreach ($error->getMessageParameters() as $key => $value) {
            foreach ($error->/** @scrutinizer ignore-call */ getMessageParameters() as $key => $value) {
                $violation->addParameter($key, $value);
            }

            $cause = $error->getCause();
            $cause = $error->getCause();
            if ($cause instanceof SymfonyConstraintViolation) {
                $violation->setCode($cause->getCode());
                $violation->setInvalidValue($cause->getInvalidValue());
                $violation->setPlural($cause->getPlural());
            }

            $violations->addViolation($violation);
        }
        if ($form->all()) {
            foreach ($form->all() as $child) {
                $parentName = $form->getName();

                //avoid set the name of the form
                if ($form->getName() === $parentName && !$form->getParent()) {
                    $parentName = null;
                }

                $this->extractFormErrors($child, $violations, $parentName);
            }
        }
    }

    /**
     * Can use this method to verify if submitted data is valid
     * otherwise can trow a error
     *
     * @param mixed $inputSource contain the original submitted input data
     * @param mixed $normData    contains the processed and normalized data by the form
     */
    protected function onSubmit($inputSource, &$normData)
    protected function onSubmit(/** @scrutinizer ignore-unused */ $inputSource, &$normData)
    {
        //override in child
    }

    /**
     * Can do something before validate the submitted data
     *
     * @param mixed $data
     */
    protected function preValidate(&$data)
    protected function preValidate(/** @scrutinizer ignore-unused */ &$data)
    {
        //override in child
    }

    /**
     * Can use this to add your custom validations errors
     *
     * @param mixed                   $data
     * @param ConstraintViolationList $violations
     */
    protected function postValidation($data, ConstraintViolationList $violations)
    protected function postValidation(/** @scrutinizer ignore-unused */ $data, ConstraintViolationList $violations)
    {
        //override in child
    }
}

ynloultratech / graphql-bundle

Push — master ( 9e9a0d...740d0f )

AbstractMutationResolver::preValidate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
