CascadeDeleteService::deleteAssociations() - Code Metrics - Inspection of "Feature/0.0.2" - alex-patterson-webdev/doctrine-entity-repository - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#5)

by Alex

created 2020-06-16 16:10 UTC

CascadeDeleteService::deleteAssociations() B

↳ Parent: CascadeDeleteService

Complexity

Conditions	6
Paths	4

Size

Total Lines	72
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	72
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;

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

        $classMetadata = $this->getClassMetadata($entityManager, $entityName);
        $mappings = $classMetadata->getAssociationMappings();

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

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

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

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

            if (!$this->isValidAssociation($targetEntityOrCollection, $mapping)) {
                $errorMessage = sprintf(
                    'The entity field \'%s::%s\' value could not be resolved',
                    $entityName,
                    $mappings['fieldName']
                );
                $this->logger->error($errorMessage);

                throw new PersistenceException($errorMessage);
                continue;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            }

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

            $this->deleteAssociation(
                $entityManager,
                $mapping['targetEntity'],
                $targetEntityOrCollection,
                (is_iterable($targetEntityOrCollection) ? $deleteCollectionOptions : $deleteOptions)
            );
        }
    }

    /**
     * @param EntityManagerInterface $entityManager
     * @param string                 $targetEntityName
     * @param                        $entityOrCollection
     * @param array                  $options
     *
     * @throws PersistenceException
     * @throws EntityRepositoryException
     */
    public function deleteAssociation(
        EntityManagerInterface $entityManager,
        string $targetEntityName,
        $entityOrCollection,
        array $options = []
    ): void {
        $targetRepository = $this->getTargetRepository($entityManager, $targetEntityName);

        if (is_iterable($entityOrCollection)) {
            $targetRepository->deleteCollection($entityOrCollection, $options);
        } elseif ($entityOrCollection instanceof EntityInterface) {
            $targetRepository->delete($entityOrCollection, $options);
        } else {
            $errorMessage = sprintf(
                'Unable to cascade save target entity \'%s\': The entity or collection is of an invalid type \'%s\'',
                $targetEntityName,
                (is_object($entityOrCollection) ? get_class($entityOrCollection) : gettype($entityOrCollection))
            );

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

            throw new PersistenceException($errorMessage);
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Arp\DoctrineEntityRepository\Persistence;
6
7			use Arp\DoctrineEntityRepository\Exception\EntityRepositoryException;
8			use Arp\DoctrineEntityRepository\Persistence\Exception\PersistenceException;
9			use Arp\Entity\EntityInterface;
10			use Doctrine\ORM\EntityManagerInterface;
11
12			/**
13			* @author Alex Patterson <[email protected]>
14			* @package Arp\DoctrineEntityRepository\Persistence
15			*/
16			class CascadeDeleteService extends AbstractCascadeService
17			{
18			/**
19			* @param EntityManagerInterface $entityManager
20			* @param string $entityName
21			* @param EntityInterface $entity
22			* @param array $deleteOptions
23			* @param array $deleteCollectionOptions
24			*
25			* @throws EntityRepositoryException
26			* @throws PersistenceException
27			*/
28			public function deleteAssociations(
29			EntityManagerInterface $entityManager,
30			string $entityName,
31			EntityInterface $entity,
32			array $deleteOptions = [],
33			array $deleteCollectionOptions = []
34			): void {
35			$deleteOptions = array_replace_recursive($this->options, $deleteOptions);
36			$deleteCollectionOptions = array_replace_recursive($this->collectionOptions, $deleteCollectionOptions);
37
38			$classMetadata = $this->getClassMetadata($entityManager, $entityName);
39			$mappings = $classMetadata->getAssociationMappings();
40
41			$this->logger->info(
42			sprintf('Processing cascade delete operations for for entity class \'%s\'', $entityName)
43			);
44
45			foreach ($mappings as $mapping) {
46			if (
47			!isset(
48			$mapping['targetEntity'],
49			$mapping['fieldName'],
50			$mapping['type'],
51			$mapping['isCascadeRemove']
52			)
53			\|\| true !== $mapping['isCascadeRemove']
54			) {
55			// We only want to save associations that are configured to cascade delete/remove
56			continue;
57			}
58
59			$this->logger->info(
60			sprintf(
61			'The entity field \'%s::%s\' is configured for cascade delete operations for target entity \'%s\'',
62			$entityName,
63			$mappings['fieldName'],
64			$mappings['targetEntity']
65			)
66			);
67
68			$targetEntityOrCollection = $this->resolveTargetEntityOrCollection(
69			$entity,
70			$mapping['fieldName'],
71			$classMetadata,
72			$this->getClassMetadata($entityManager, $mapping['targetEntity'])
73			);
74
75			if (!$this->isValidAssociation($targetEntityOrCollection, $mapping)) {
76			$errorMessage = sprintf(
77			'The entity field \'%s::%s\' value could not be resolved',
78			$entityName,
79			$mappings['fieldName']
80			);
81			$this->logger->error($errorMessage);
82
83			throw new PersistenceException($errorMessage);
84			continue;
			0 ignored issues – show Unused Code introduced 2020-06-16 13:02 UTC by Report Bug Copy Issue Report `ContinueNode` is not reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
85			}
86
87			$this->logger->info(
88			sprintf(
89			'Performing cascading delete operations for field \'%s::%s\'',
90			$entityName,
91			$mappings['fieldName']
92			)
93			);
94
95			$this->deleteAssociation(
96			$entityManager,
97			$mapping['targetEntity'],
98			$targetEntityOrCollection,
99			(is_iterable($targetEntityOrCollection) ? $deleteCollectionOptions : $deleteOptions)
100			);
101			}
102			}
103
104			/**
105			* @param EntityManagerInterface $entityManager
106			* @param string $targetEntityName
107			* @param $entityOrCollection
108			* @param array $options
109			*
110			* @throws PersistenceException
111			* @throws EntityRepositoryException
112			*/
113			public function deleteAssociation(
114			EntityManagerInterface $entityManager,
115			string $targetEntityName,
116			$entityOrCollection,
117			array $options = []
118			): void {
119			$targetRepository = $this->getTargetRepository($entityManager, $targetEntityName);
120
121			if (is_iterable($entityOrCollection)) {
122			$targetRepository->deleteCollection($entityOrCollection, $options);
123			} elseif ($entityOrCollection instanceof EntityInterface) {
124			$targetRepository->delete($entityOrCollection, $options);
125			} else {
126			$errorMessage = sprintf(
127			'Unable to cascade save target entity \'%s\': The entity or collection is of an invalid type \'%s\'',
128			$targetEntityName,
129			(is_object($entityOrCollection) ? get_class($entityOrCollection) : gettype($entityOrCollection))
130			);
131
132			$this->logger->error($errorMessage);
133
134			throw new PersistenceException($errorMessage);
135			}
136			}
137			}
138

alex-patterson-webdev / doctrine-entity-repository

Pull Request — master (#5)

CascadeDeleteService::deleteAssociations() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like