AmaTeam\ElasticSearch\Mapping\Validator

Complexity

Total Complexity

11

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	validateInternal()	0	8	1
A	validate()	0	8	1
A	validateType()	0	11	2
B	validateParameters()	0	27	5
A	validateProperties()	0	9	2

<?php

declare(strict_types=1);

namespace AmaTeam\ElasticSearch\Mapping;

use AmaTeam\ElasticSearch\API\Mapping\MappingInterface;
use AmaTeam\ElasticSearch\API\Mapping\Validation\ContextInterface;
use AmaTeam\ElasticSearch\API\Mapping\Validation\DefaultContext;
use AmaTeam\ElasticSearch\API\Mapping\ValidatorInterface;
use AmaTeam\ElasticSearch\Mapping\Type\Infrastructure\Registry as TypeRegistry;
use AmaTeam\ElasticSearch\Mapping\Type\Parameter\Infrastructure\Registry as ParameterRegistry;
use AmaTeam\ElasticSearch\Mapping\Validation\Constraint\ApplicableParameter;
use AmaTeam\ElasticSearch\Mapping\Validation\Constraint\ExistingParameter;
use AmaTeam\ElasticSearch\Mapping\Validation\Constraint\ExistingType;
use AmaTeam\ElasticSearch\Mapping\Validation\Constraint\ValidParameterName;
use AmaTeam\ElasticSearch\Mapping\Validation\Constraint\ValidTypeName;
use Symfony\Component\Validator\Constraints\NotNull;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validation;
use Symfony\Component\Validator\Validator\ContextualValidatorInterface;

class Validator implements ValidatorInterface
{

    public function validate(
        MappingInterface $mapping,
        ContextInterface $context = null
    ): ConstraintViolationListInterface {
        $validator = Validation::createValidator()->startContext();
        $context = $context ?? new DefaultContext();
        $this->validateInternal($validator, $mapping, $context);
        return $validator->getViolations();
    }

    private function validateInternal(
        ContextualValidatorInterface $validator,
        MappingInterface $mapping,
        ContextInterface $context
    ): void {
        $this->validateType($validator, $mapping, $context);
        $this->validateParameters($validator, $mapping, $context);
        $this->validateProperties($validator, $mapping, $context);
    }

    private function validateType(
        ContextualValidatorInterface $validator,
        MappingInterface $mapping,
        ContextInterface $context
    ): void {
        $path = array_merge($context->getPath(), ['type']);
        $validator->atPath(implode('.', $path));
        $type = TypeRegistry::getInstance()->find($mapping->getType());
        $validator->validate($mapping->getType(), new ExistingType());
        if ($type) {
            $validator->validate($mapping->getType(), new ValidTypeName(['id' => $type->getId()]));
        }
    }

    private function validateParameters(
        ContextualValidatorInterface $validator,
        MappingInterface $mapping,
        ContextInterface $context
    ): void {
        foreach ($mapping->getParameters() as $name => $value) {
            $path = array_merge($context->getPath(), [$name]);
            $validator->atPath(implode('.', $path));
            if (!$context->shouldIgnoreUnknownParameters()) {
                $validator->validate($name, new ExistingParameter());
            }
            $parameter = ParameterRegistry::getInstance()->find($name);
            if (!$parameter) {
                continue;
            }
            $validator->validate(
                $name,
                [
                    new ValidParameterName(['id' => $parameter->getId()]),
                    new ApplicableParameter(['parameter' => $name, 'type' => $mapping->getType()])
                ]
            );
            $constraints = $parameter->getConstraints();
            if (!$parameter->nullValueAllowed()) {
                $constraints[] = new NotNull();
            }
            $validator->validate($value, $constraints);
        }
    }

    private function validateProperties(
        ContextualValidatorInterface $validator,
        MappingInterface $mapping,
        ContextInterface $context
    ): void {
        foreach ($mapping->getProperties() as $name => $property) {
            $path = array_merge($context->getPath(), ['properties', $name]);
            $innerContext = DefaultContext::from($context)->setPath($path);
            $this->validateInternal($validator, $property, $innerContext);
        }
    }
}