Add AbstractClassResolverInterface

ChapleanDtoHandlerBundle.php

@@ -11,6 +11,8 @@
 
 namespace Chaplean\Bundle\DtoHandlerBundle;
 
+use Chaplean\Bundle\DtoHandlerBundle\DependencyInjection\CompilerPass\AbstractClassCompilerPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
 /**
@@ -23,4 +25,8 @@
  */
 class ChapleanDtoHandlerBundle extends Bundle
 {
+    public function build(ContainerBuilder $container)
+    {
+        $container->addCompilerPass(new AbstractClassCompilerPass());
+    }
 }

DependencyInjection/ChapleanDtoHandlerExtension.php

@@ -11,6 +11,8 @@
 
 namespace Chaplean\Bundle\DtoHandlerBundle\DependencyInjection;
 
+use Chaplean\Bundle\DtoHandlerBundle\DependencyInjection\CompilerPass\AbstractClassCompilerPass;
+use Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolverInterface;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
@@ -42,6 +44,8 @@ public function load(array $configs, ContainerBuilder $container): void
 
         $container->setParameter(Configuration::CONFIG_NODE, $config);
         $this->setParameters($container, Configuration::CONFIG_NODE, $config);
+
+        $container->registerForAutoconfiguration(AbstractClassResolverInterface::class)->addTag(AbstractClassCompilerPass::TAG);
     }
 
     /**

DependencyInjection/CompilerPass/AbstractClassCompilerPass.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chaplean\Bundle\DtoHandlerBundle\DependencyInjection\CompilerPass;
+
+use Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolver;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+final class AbstractClassCompilerPass implements CompilerPassInterface
+{
+    public const TAG = 'chaplean_dto_handler.abstract_class_resolver';
+
+    public function process(ContainerBuilder $container)
+    {
+        $references = $this->getReferences($container);
+        $definition = $container->getDefinition(AbstractClassResolver::class);
+        $definition->setProperty('resolvers', $references);
+    }
+
+    /** @return Reference[] */
+    private function getReferences(ContainerBuilder $container): array
+    {
+        $serviceConfigs = $container->findTaggedServiceIds(self::TAG);
+        $serviceIds = array_keys($serviceConfigs);
+
+        $references = array_map(
+            static function (string $serviceId): Reference {
+                return new Reference($serviceId);
+            },
+            $serviceIds
+        );
+
+        usort(
+            $references,
+            static function (Reference $left, Reference $right): int {
+                $leftPriority = $left::getPriority();
+                $rightPriority = $right::getPriority();
+
+                if ($leftPriority === $rightPriority) {
+                    return 0;
+                }
+
+                return $leftPriority > $rightPriority ? -1 : 1;
+            }
+        );
+
+        return $references;
+    }
+}

ParamConverter/DataTransferObjectParamConverter.php

@@ -14,6 +14,7 @@
 use Chaplean\Bundle\DtoHandlerBundle\ConfigurationExtractor\PropertyConfigurationExtractor;
 use Chaplean\Bundle\DtoHandlerBundle\DataTransferObject\DataTransferObjectInterface;
 use Chaplean\Bundle\DtoHandlerBundle\Exception\DataTransferObjectValidationException;
+use Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolver;
 use Doctrine\Common\Annotations\AnnotationException;
 use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
 use Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter\ParamConverterInterface;
@@ -74,6 +75,11 @@ class DataTransferObjectParamConverter implements ParamConverterInterface
      */
     protected $translator;
 
+    /**
+     * @var AbstractClassResolver
+     */
+    protected $abstractClassResolver;
+
     /**
      * @var ValidatorInterface
      */
@@ -86,20 +92,23 @@ class DataTransferObjectParamConverter implements ParamConverterInterface
      * @param array                   $httpValidationGroups
      * @param ParamConverterManager   $paramConverterManager
      * @param TranslatorInterface     $translator
+     * @param AbstractClassResolver   $abstractClassResolver
      * @param ValidatorInterface|null $validator
      */
     public function __construct(
         array $bypassParamConverterExceptionClasses,
         array $httpValidationGroups,
         ParamConverterManager $paramConverterManager,
         TranslatorInterface $translator,
+        AbstractClassResolver $abstractClassResolver,
         ValidatorInterface $validator = null
     ) {
         $this->bypassParamConverterExceptionClasses = $bypassParamConverterExceptionClasses;
         $this->manager = $paramConverterManager;
         $this->validator = $validator;
         $this->taggedDtoClasses = [];
         $this->translator = $translator;
+        $this->abstractClassResolver = $abstractClassResolver;
         $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
 
         usort(
@@ -286,16 +295,30 @@ protected function autoConfigureOne(
         $name = $prefix . '_' . $propertyConfigurationModel->getName();
         $request->attributes->set($name, $value);
 
-        if ($propertyConfigurationModel->getType() === null) {
+        $type_ = $propertyConfigurationModel->getType();
+
+        if ($type_ === null) {
             return $paramConfiguration;
         }
 
+        if (\class_exists($type_)) {
+            $reflectionClass = new \ReflectionClass($type_);
+
+            if ($reflectionClass->isAbstract()) {
+                $resolvedClass = $this->abstractClassResolver->getClassFor($type_, $request, $value);
+
+                if ($resolvedClass !== null) {
+                    $type_ = $resolvedClass;
+                }
+            }
+        }
+
         $config = new ParamConverter([]);
         $config->setName($name);
-        $config->setClass($propertyConfigurationModel->getType());
+        $config->setClass($type_);
         $config->setIsOptional(true);
 
-        if (!\in_array($propertyConfigurationModel->getType(), $this->bypassParamConverterExceptionClasses, true)) {
+        if (!\in_array($type_, $this->bypassParamConverterExceptionClasses, true)) {
             $config->setIsOptional($propertyConfigurationModel->isOptional());
         }
 

Resolver/AbstractClassResolver.php

@@ -0,0 +1,22 @@
+<?php declare(strict_types=1);
+
+namespace Chaplean\Bundle\DtoHandlerBundle\Resolver;
+
+use Symfony\Component\HttpFoundation\Request;
+
+class AbstractClassResolver
+{
+    /** @var AbstractClassResolverInterface[] */
+    public $resolvers = [];
+
+    public function getClassFor(string $abstractClass, Request $request, $value): ?string
+    {
+        foreach ($this->resolvers as $resolver) {
+            if ($resolver->supports($abstractClass)) {
+                return $resolver->getClass($request, $value);
+            }
+        }
+
+        return null;
+    }
+}

Resolver/AbstractClassResolverInterface.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Chaplean\Bundle\DtoHandlerBundle\Resolver;
+
+use Symfony\Component\HttpFoundation\Request;
+
+interface AbstractClassResolverInterface
+{
+    public function getClass(Request $request, $value): string;
+
+    public function supports(string $abstractClass): bool;
+
+    public static function getPriority(): int;
+}

Resources/config/services.xml

@@ -16,12 +16,15 @@
             <argument key="$httpValidationGroups">%chaplean_dto_handler.http_code_validation_groups%</argument>
             <argument key="$paramConverterManager" type="service" id="sensio_framework_extra.converter.manager" />
             <argument key="$translator" type="service" id="translator" />
+            <argument key="$abstractClassResolver" type="service" id="Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolver" />
             <argument key="$validator" type="service" id="validator" />
             <tag name="request.param_converter" converter="data_transfer_object_converter" />
         </service>
 
         <service id="Chaplean\Bundle\DtoHandlerBundle\Validator\Constraints\UniqueEntityDataValidator" />
 
+        <service id="Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolver" />
+
         <!-- Serializer -->
         <service id="Chaplean\Bundle\DtoHandlerBundle\Serializer\DataTransferObjectDenormalizer">
             <argument key="$paramConverterManager" type="service" id="sensio_framework_extra.converter.manager" />

Tests/ParamConverter/DataTransferObjectParamConverterTest.php

@@ -13,6 +13,7 @@
 
 use Chaplean\Bundle\DtoHandlerBundle\Exception\DataTransferObjectValidationException;
 use Chaplean\Bundle\DtoHandlerBundle\ParamConverter\DataTransferObjectParamConverter;
+use Chaplean\Bundle\DtoHandlerBundle\Resolver\AbstractClassResolver;
 use Doctrine\Common\Annotations\AnnotationException;
 use Mockery\Adapter\Phpunit\MockeryTestCase;
 use Mockery\MockInterface;
@@ -59,6 +60,11 @@ class DataTransferObjectParamConverterTest extends MockeryTestCase
      */
     private $validator;
 
+    /**
+     * @var AbstractClassResolver|MockInterface
+     */
+    private $abstractClassResolver;
+
     /**
      * @return void
      */
@@ -69,6 +75,7 @@ public function setUp(): void
         $this->manager = \Mockery::mock(ParamConverterManager::class);
         $this->translator = \Mockery::mock(TranslatorInterface::class);
         $this->validator = \Mockery::mock(ValidatorInterface::class);
+        $this->abstractClassResolver = \Mockery::mock(AbstractClassResolver::class);
 
         PHPMockery::mock('Chaplean\Bundle\DtoHandlerBundle\ParamConverter', 'uniqid')->andReturn('hash');
 
@@ -80,6 +87,7 @@ public function setUp(): void
             ],
             $this->manager,
             $this->translator,
+            $this->abstractClassResolver,
             $this->validator
         );
     }