MappingAnnotationDriver::convertAnnotationToMapping()

Complexity

Conditions	13
Paths	11

Size

Total Lines	171
Code Lines	101

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	63
CRAP Score	13.0006

Importance

Changes

0

<?php
    private function convertAnnotationToMapping(
        $annotation,
        string $fieldName,
        string $className,
        bool $convertFieldsOnRootLevel = false
    ): ?MappingInterface {
        /** @var ?MappingInterface $fieldMapping */
        $fieldMapping = null;

        if ($annotation instanceof Service) {
            $fieldMapping = new ServiceMapping(
                $this->container,
                $annotation->id,
                $annotation->lax,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof Choice) {
            /** @var string|null|ColumnAnnotation $column */
            $column = $annotation->column;

            if (!$column instanceof ColumnAnnotation) {
                /** @var string $columnName */
                $columnName = $fieldName;

                if (is_string($column)) {
                    $columnName = $column;
                }

                $column = new ColumnAnnotation();
                $column->name = $columnName;
                $column->type = 'string';
                $column->length = 255;
                $column->precision = 10;
                $column->nullable = $annotation->nullable;
            }

            $dbalColumn = new DBALColumn(
                (string) $column->name,
                Type::getType($column->type),
                [
                    'notnull'   => !$column->nullable,
                    'length'    => $column->length,
                    'precision' => $column->precision,
                    'scale'     => $column->scale,
                ]
            );

            /** @var array<MappingInterface>*/
            $choiceMappings = array();

            foreach ($annotation->choices as $determinator => $choiceAnnotation) {
                /** @var ?MappingInterface $choiceMapping */
                $choiceMapping = $this->convertAnnotationToMapping(
                    $choiceAnnotation,
                    $fieldName,
                    $className
                );

                if ($choiceMapping instanceof MappingInterface) {
                    $choiceMappings[$determinator] = $choiceMapping;

                } else {
                    throw new InvalidMappingException(sprintf(
                        "Invalid mapping on entity '%s' in field '%s' of choice-option '%s'!",
                        $className,
                        $fieldName,
                        $determinator
                    ));
                }
            }

            $fieldMapping = new ChoiceMapping(
                $dbalColumn,
                $choiceMappings,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof RDMObject) {
            /** @var array<MappingInterface> $subFieldMappings */
            $subFieldMappings = array();

            /** @var null|CallDefinitionInterface $factory */
            $factory = null;

            /** @var null|CallDefinitionInterface $serializer */
            $serializer = null;

            foreach ($annotation->fields as $subFieldName => $subFieldAnnotation) {
                /** @var object $fieldAnnotation */

                $subFieldMappings[$subFieldName] = $this->convertAnnotationToMapping(
                    $subFieldAnnotation,
                    $fieldName . "->" . $subFieldName,
                    $className,
                    true
                );
            }

            /** @var class-string|null $objectMappingClassName */
            $objectMappingClassName = $annotation->{"class"};

            Assert::classExists($objectMappingClassName);

            $fieldMapping = new ObjectMapping(
                $objectMappingClassName,
                $subFieldMappings,
                null, # TODO: column
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                ),
                $factory,
                $serializer
            );

        } elseif ($annotation instanceof RDMArray) {
            /** @var array<MappingInterface> $entryMappings */
            $entryMappings = array();

            foreach ($annotation->entries as $key => $entryAnnotaton) {
                $entryMappings[$key] = $this->convertAnnotationToMapping(
                    $entryAnnotaton,
                    $fieldName . "->" . $key,
                    $className,
                    true
                );
            }

            $fieldMapping = new ArrayMapping(
                $entryMappings,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof ColumnAnnotation && $convertFieldsOnRootLevel) {
            /** @var DBALColumn $dbalColumn */
            $dbalColumn = new DBALColumn(
                (string) $annotation->name,
                Type::getType($annotation->type ?? 'string'),
                [
                    'notnull'   => !$annotation->nullable,
                    'length'    => $annotation->length,
                    'precision' => $annotation->precision ?? 0,
                    'scale'     => $annotation->scale,
                ]
            );

            $fieldMapping = new FieldMapping(
                $dbalColumn,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );
        }

        return $fieldMapping;
    }