CascadeSaveService::saveAssociations() - Code Metrics - alex-patterson-webdev/doctrine-entity-repository - Measure and Improve Code Quality continuously with Scrutinizer

CascadeSaveService::saveAssociations() B
last analyzed 2022-03-20 22:38 UTC

↳ Parent: CascadeSaveService

Complexity

Conditions	6
Paths	4

Size

Total Lines	76
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	44
c	1
b	0
f	0
dl	0
loc	76
rs	8.5937
cc	6
nc	4
nop	5

How to fix Long Method

<?php

declare(strict_types=1);

namespace Arp\DoctrineEntityRepository\Persistence;

use Arp\DoctrineEntityRepository\Exception\EntityRepositoryException;
use Arp\DoctrineEntityRepository\Persistence\Exception\PersistenceException;
use Arp\Entity\EntityInterface;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;

/**
 * @author  Alex Patterson <[email protected]>
 * @package Arp\DoctrineEntityRepository\Persistence
 */
class CascadeSaveService extends AbstractCascadeService
{
    /**
     * @param EntityManagerInterface $entityManager
     * @param string                 $entityName
     * @param EntityInterface        $entity
     * @param array<mixed>           $options
     * @param array<mixed>           $collectionOptions
     *
     * @throws PersistenceException
     * @throws EntityRepositoryException
     */
    public function saveAssociations(
        EntityManagerInterface $entityManager,
        string $entityName,
        EntityInterface $entity,
        array $options = [],
        array $collectionOptions = []
    ): void {
        $options = array_replace_recursive($this->options, $options);
        $collectionOptions = array_replace_recursive($this->collectionOptions, $collectionOptions);

        /** @var ClassMetadata<EntityInterface> $classMetadata */
        $classMetadata = $this->getClassMetadata($entityManager, $entityName);
        $mappings = $classMetadata->getAssociationMappings();

        $this->logger->info(
            sprintf('Processing cascade save operations for for entity class \'%s\'', $entityName)
        );

        foreach ($mappings as $mapping) {
            if (
                !isset(
                    $mapping['targetEntity'],
                    $mapping['fieldName'],
                    $mapping['type'],
                    $mapping['isCascadePersist']
                )
                || true !== $mapping['isCascadePersist']
            ) {
                // We only want to save associations that are configured to cascade persist
                continue;
            }

            $this->logger->info(
                sprintf(
                    'The entity field \'%s::%s\' is configured for cascade operations for target entity \'%s\'',
                    $entityName,
                    $mapping['fieldName'],
                    $mapping['targetEntity']
                )
            );

            /** @var ClassMetadata<EntityInterface> $targetMetadata */
            $targetMetadata = $this->getClassMetadata($entityManager, $mapping['targetEntity']);

            $targetEntityOrCollection = $this->resolveTargetEntityOrCollection(
                $entity,
                $mapping['fieldName'],
                $classMetadata,
                $targetMetadata
            );

            if (!$this->isValidAssociation($targetEntityOrCollection, $mapping)) {
            if (!$this->isValidAssociation(/** @scrutinizer ignore-type */ $targetEntityOrCollection, $mapping)) {
                $errorMessage = sprintf(
                    'The entity field \'%s::%s\' value could not be resolved',
                    $entityName,
                    $mapping['fieldName']
                );

                $this->logger->error($errorMessage);

                throw new PersistenceException($errorMessage);
            }

            $this->logger->info(
                sprintf(
                    'Performing cascading save operations for field \'%s::%s\'',
                    $entityName,
                    $mapping['fieldName']
                )
            );

            $this->saveAssociation(
                $entityManager,
                $mapping['targetEntity'],
                $targetEntityOrCollection,
                (is_iterable($targetEntityOrCollection) ? $collectionOptions : $options)
            );
        }
    }

    /**
     * @param EntityManagerInterface                          $entityManager
     * @param class-string                                    $entityName
     * @param EntityInterface|iterable<EntityInterface>|mixed $entityOrCollection
     * @param array<mixed>                                    $options
     *
     * @throws PersistenceException
     * @throws EntityRepositoryException
     */
    public function saveAssociation(
        EntityManagerInterface $entityManager,
        string $entityName,
        $entityOrCollection,
        array $options = []
    ): void {
        if ($entityOrCollection instanceof EntityInterface) {
            $this->getTargetRepository($entityManager, $entityName)->save($entityOrCollection, $options);
        } elseif (is_iterable($entityOrCollection)) {
            $this->getTargetRepository($entityManager, $entityName)->saveCollection($entityOrCollection, $options);
        } else {
            $errorMessage = sprintf(
                'Unable to cascade save target entity \'%s\': The entity or collection is of an invalid type \'%s\'',
                $entityName,
                (is_object($entityOrCollection) ? get_class($entityOrCollection) : gettype($entityOrCollection))
            );

            $this->logger->error($errorMessage);

            throw new PersistenceException($errorMessage);
        }
    }
}


alex-patterson-webdev / doctrine-entity-repository

CascadeSaveService::saveAssociations() B last analyzed 2022-03-20 22:38 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

CascadeSaveService::saveAssociations() B
last analyzed 2022-03-20 22:38 UTC