AmaTeam\ElasticSearch\Mapping\Manager

Complexity

Total Complexity

10

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	3	1
A	convert()	0	13	3
A	exists()	0	3	1
A	find()	0	4	2
A	normalize()	0	5	1
A	validate()	0	5	1
A	__construct()	0	6	1

<?php

declare(strict_types=1);

namespace AmaTeam\ElasticSearch\Mapping;

use AmaTeam\ElasticSearch\API\Entity\Mapping\ClassMappingInterface;
use AmaTeam\ElasticSearch\API\Entity\Mapping\ProviderInterface;
use AmaTeam\ElasticSearch\API\Mapping\Conversion\ContextInterface as ConversionContextInterface;
use AmaTeam\ElasticSearch\API\Mapping\Conversion\ConverterInterface;
use AmaTeam\ElasticSearch\API\Mapping\ManagerInterface;
use AmaTeam\ElasticSearch\API\Mapping\MappingInterface;
use AmaTeam\ElasticSearch\API\Mapping\Normalization\ContextInterface as NormalizationContextInterface;
use AmaTeam\ElasticSearch\API\Mapping\NormalizerInterface;
use AmaTeam\ElasticSearch\API\Mapping\Validation\ContextInterface as ValidationContextInterface;
use AmaTeam\ElasticSearch\API\Mapping\Validation\ValidationException;
use AmaTeam\ElasticSearch\API\Mapping\ValidatorInterface;
use AmaTeam\ElasticSearch\Mapping\Conversion\Converter;
use Symfony\Component\Validator\ConstraintViolationListInterface;

class Manager implements ManagerInterface
{
    /**
     * @var ProviderInterface
     */
    private $provider;
    /**
     * @var ConverterInterface
     */
    private $converter;
    /**
     * @var ValidatorInterface
     */
    private $validator;
    /**
     * @var NormalizerInterface
     */
    private $normalizer;

    /**
     * @param ProviderInterface $provider
     */
    public function __construct(ProviderInterface $provider)
    {
        $this->provider = $provider;
        $this->converter = new Converter($provider);
        $this->validator = new Validator();
        $this->normalizer = new Normalizer();
    }

    public function get(string $name, ConversionContextInterface $context = null): MappingInterface
    {
        return $this->convert($this->provider->get($name), $context);
    }

    public function find(string $name, ConversionContextInterface $context = null): ?MappingInterface
    {
        $mapping = $this->provider->find($name);
        return $mapping ? $this->convert($mapping, $context) : null;
    }

    public function exists(string $name): bool
    {
        return $this->provider->exists($name);
    }

    public function convert(ClassMappingInterface $source, ConversionContextInterface $context = null): MappingInterface
    {
        $mapping = $this->converter->convert($source, $context);
        $mapping = $this->normalizer->normalize($mapping);
        $violations = $this->validator->validate($mapping);
        if ($violations->count() > 0) {
            $lines = ['Generated mapping failed validation:'];
            foreach ($violations as $violation) {
                $lines[] = $violation->getPropertyPath() . ': ' . $violation->getMessage();
            }
            throw new ValidationException(implode(PHP_EOL, $lines), $violations);
        }
        return $mapping;
    }

    public function validate(
        MappingInterface $mapping,
        ValidationContextInterface $context = null
    ): ConstraintViolationListInterface {
        return $this->validator->validate($mapping, $context);
    }

    public function normalize(
        MappingInterface $mapping,
        NormalizationContextInterface $context = null
    ): MappingInterface {
        return $this->normalizer->normalize($mapping, $context);
    }
}