AuditTrait::summarize() - Code Metrics - Inspection of "Refactoring" - DamienHarper/DoctrineAuditBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#188)

by Damien

created 2020-04-10 14:18 UTC

AuditTrait::summarize() A

↳ Parent: AuditTrait

Complexity

Conditions	4
Paths	4

Size

Total Lines	27
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	17
c	1
b	0
f	0
nc	4
nop	3
dl	0
loc	27
rs	9.7

<?php

namespace DH\DoctrineAuditBundle\Transaction;

use DH\DoctrineAuditBundle\Helper\DoctrineHelper;
use DH\DoctrineAuditBundle\User\UserInterface;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;

trait AuditTrait
{
    /**
     * Returns the primary key value of an entity.
     *
     * @param EntityManagerInterface $em
     * @param object                 $entity
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     *
     * @return mixed
     */
    private function id(EntityManagerInterface $em, $entity)
    {
        /** @var ClassMetadata $meta */
        $meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
        $pk = $meta->getSingleIdentifierFieldName();

        if (isset($meta->fieldMappings[$pk])) {
            $type = Type::getType($meta->fieldMappings[$pk]['type']);

            return $this->value($em, $type, $meta->getReflectionProperty($pk)->getValue($entity));
        }

        /**
         * Primary key is not part of fieldMapping.
         *
         * @see https://github.com/DamienHarper/DoctrineAuditBundle/issues/40
         * @see https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/composite-primary-keys.html#identity-through-foreign-entities
         * We try to get it from associationMapping (will throw a MappingException if not available)
         */
        $targetEntity = $meta->getReflectionProperty($pk)->getValue($entity);

        $mapping = $meta->getAssociationMapping($pk);

        /** @var ClassMetadata $meta */
        $meta = $em->getClassMetadata($mapping['targetEntity']);
        $pk = $meta->getSingleIdentifierFieldName();
        $type = Type::getType($meta->fieldMappings[$pk]['type']);

        return $this->value($em, $type, $meta->getReflectionProperty($pk)->getValue($targetEntity));
    }

    /**
     * Type converts the input value and returns it.
     *
     * @param EntityManagerInterface $em
     * @param Type                   $type
     * @param mixed                  $value
     *
     * @throws \Doctrine\DBAL\DBALException
     *
     * @return mixed
     */
    private function value(EntityManagerInterface $em, Type $type, $value)
    {
        if (null === $value) {
            return null;
        }

        $platform = $em->getConnection()->getDatabasePlatform();

        switch ($type->getName()) {
            case DoctrineHelper::getDoctrineType('BIGINT'):
                $convertedValue = (string) $value;

                break;
            case DoctrineHelper::getDoctrineType('INTEGER'):
            case DoctrineHelper::getDoctrineType('SMALLINT'):
                $convertedValue = (int) $value;

                break;
            case DoctrineHelper::getDoctrineType('DECIMAL'):
            case DoctrineHelper::getDoctrineType('FLOAT'):
            case DoctrineHelper::getDoctrineType('BOOLEAN'):
                $convertedValue = $type->convertToPHPValue($value, $platform);

                break;
            default:
                $convertedValue = $type->convertToDatabaseValue($value, $platform);
        }

        return $convertedValue;
    }

    /**
     * Computes a usable diff.
     *
     * @param EntityManagerInterface $em
     * @param object                 $entity
     * @param array                  $ch
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     *
     * @return array
     */
    private function diff(EntityManagerInterface $em, $entity, array $ch): array
    {
        /** @var ClassMetadata $meta */
        $meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
        $diff = [];

        foreach ($ch as $fieldName => list($old, $new)) {
            $o = null;
            $n = null;

            if (
                $meta->hasField($fieldName) &&
                !isset($meta->embeddedClasses[$fieldName]) &&
                $this->configuration->isAuditedField($entity, $fieldName)
            ) {
                $mapping = $meta->fieldMappings[$fieldName];
                $type = Type::getType($mapping['type']);
                $o = $this->value($em, $type, $old);
                $n = $this->value($em, $type, $new);
            } elseif (
                $meta->hasAssociation($fieldName) &&
                $meta->isSingleValuedAssociation($fieldName) &&
                $this->configuration->isAuditedField($entity, $fieldName)
            ) {
                $o = $this->summarize($em, $old);
                $n = $this->summarize($em, $new);
            }

            if ($o !== $n) {
                $diff[$fieldName] = [
                    'old' => $o,
                    'new' => $n,
                ];
            }
        }
        ksort($diff);

        return $diff;
    }

    /**
     * Returns an array describing an entity.
     *
     * @param EntityManagerInterface $em
     * @param object                 $entity
     * @param mixed                  $id
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     *
     * @return array
     */
    private function summarize(EntityManagerInterface $em, $entity = null, $id = null): ?array
    {
        if (null === $entity) {
            return null;
        }

        $em->getUnitOfWork()->initializeObject($entity); // ensure that proxies are initialized
        /** @var ClassMetadata $meta */
        $meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
        $pkName = $meta->getSingleIdentifierFieldName();
        $pkValue = $id ?? $this->id($em, $entity);
        // An added guard for proxies that fail to initialize.
        if (null === $pkValue) {
            return null;
        }

        if (method_exists($entity, '__toString')) {
            $label = (string) $entity;
        } else {
            $label = DoctrineHelper::getRealClassName($entity).'#'.$pkValue;
        }

        return [
            'label' => $label,
            'class' => $meta->name,
            'table' => $meta->getTableName(),
            $pkName => $pkValue,
        ];
    }

    /**
     * Blames an audit operation.
     *
     * @return array
     */
    private function blame(): array
    {
        $user_id = null;
        $username = null;
        $client_ip = null;
        $user_fqdn = null;
        $user_firewall = null;

        $request = $this->configuration->getRequestStack()->getCurrentRequest();
        if (null !== $request) {
            $client_ip = $request->getClientIp();
            $user_firewall = null === $this->configuration->getFirewallMap()->getFirewallConfig($request) ? null : $this->configuration->getFirewallMap()->getFirewallConfig($request)->getName();
        }

        $user = null === $this->configuration->getUserProvider() ? null : $this->configuration->getUserProvider()->getUser();
        if ($user instanceof UserInterface) {
            $user_id = $user->getId();
            $username = $user->getUsername();
            $user_fqdn = DoctrineHelper::getRealClassName($user);
        }

        return [
            'user_id' => $user_id,
            'username' => $username,
            'client_ip' => $client_ip,
            'user_fqdn' => $user_fqdn,
            'user_firewall' => $user_firewall,
        ];
    }
}


1			<?php
2
3			namespace DH\DoctrineAuditBundle\Transaction;
4
5			use DH\DoctrineAuditBundle\Helper\DoctrineHelper;
6			use DH\DoctrineAuditBundle\User\UserInterface;
7			use Doctrine\DBAL\Types\Type;
8			use Doctrine\ORM\EntityManagerInterface;
9			use Doctrine\ORM\Mapping\ClassMetadata;
10
11			trait AuditTrait
12			{
13			/**
14			* Returns the primary key value of an entity.
15			*
16			* @param EntityManagerInterface $em
17			* @param object $entity
18			*
19			* @throws \Doctrine\DBAL\DBALException
20			* @throws \Doctrine\ORM\Mapping\MappingException
21			*
22			* @return mixed
23			*/
24			private function id(EntityManagerInterface $em, $entity)
25			{
26			/** @var ClassMetadata $meta */
27			$meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
28			$pk = $meta->getSingleIdentifierFieldName();
29
30			if (isset($meta->fieldMappings[$pk])) {
31			$type = Type::getType($meta->fieldMappings[$pk]['type']);
32
33			return $this->value($em, $type, $meta->getReflectionProperty($pk)->getValue($entity));
34			}
35
36			/**
37			* Primary key is not part of fieldMapping.
38			*
39			* @see https://github.com/DamienHarper/DoctrineAuditBundle/issues/40
40			* @see https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/composite-primary-keys.html#identity-through-foreign-entities
41			* We try to get it from associationMapping (will throw a MappingException if not available)
42			*/
43			$targetEntity = $meta->getReflectionProperty($pk)->getValue($entity);
44
45			$mapping = $meta->getAssociationMapping($pk);
46
47			/** @var ClassMetadata $meta */
48			$meta = $em->getClassMetadata($mapping['targetEntity']);
49			$pk = $meta->getSingleIdentifierFieldName();
50			$type = Type::getType($meta->fieldMappings[$pk]['type']);
51
52			return $this->value($em, $type, $meta->getReflectionProperty($pk)->getValue($targetEntity));
53			}
54
55			/**
56			* Type converts the input value and returns it.
57			*
58			* @param EntityManagerInterface $em
59			* @param Type $type
60			* @param mixed $value
61			*
62			* @throws \Doctrine\DBAL\DBALException
63			*
64			* @return mixed
65			*/
66			private function value(EntityManagerInterface $em, Type $type, $value)
67			{
68			if (null === $value) {
69			return null;
70			}
71
72			$platform = $em->getConnection()->getDatabasePlatform();
73
74			switch ($type->getName()) {
75			case DoctrineHelper::getDoctrineType('BIGINT'):
76			$convertedValue = (string) $value;
77
78			break;
79			case DoctrineHelper::getDoctrineType('INTEGER'):
80			case DoctrineHelper::getDoctrineType('SMALLINT'):
81			$convertedValue = (int) $value;
82
83			break;
84			case DoctrineHelper::getDoctrineType('DECIMAL'):
85			case DoctrineHelper::getDoctrineType('FLOAT'):
86			case DoctrineHelper::getDoctrineType('BOOLEAN'):
87			$convertedValue = $type->convertToPHPValue($value, $platform);
88
89			break;
90			default:
91			$convertedValue = $type->convertToDatabaseValue($value, $platform);
92			}
93
94			return $convertedValue;
95			}
96
97			/**
98			* Computes a usable diff.
99			*
100			* @param EntityManagerInterface $em
101			* @param object $entity
102			* @param array $ch
103			*
104			* @throws \Doctrine\DBAL\DBALException
105			* @throws \Doctrine\ORM\Mapping\MappingException
106			*
107			* @return array
108			*/
109			private function diff(EntityManagerInterface $em, $entity, array $ch): array
110			{
111			/** @var ClassMetadata $meta */
112			$meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
113			$diff = [];
114
115			foreach ($ch as $fieldName => list($old, $new)) {
116			$o = null;
117			$n = null;
118
119			if (
120			$meta->hasField($fieldName) &&
121			!isset($meta->embeddedClasses[$fieldName]) &&
122			$this->configuration->isAuditedField($entity, $fieldName)
123			) {
124			$mapping = $meta->fieldMappings[$fieldName];
125			$type = Type::getType($mapping['type']);
126			$o = $this->value($em, $type, $old);
127			$n = $this->value($em, $type, $new);
128			} elseif (
129			$meta->hasAssociation($fieldName) &&
130			$meta->isSingleValuedAssociation($fieldName) &&
131			$this->configuration->isAuditedField($entity, $fieldName)
132			) {
133			$o = $this->summarize($em, $old);
134			$n = $this->summarize($em, $new);
135			}
136
137			if ($o !== $n) {
138			$diff[$fieldName] = [
139			'old' => $o,
140			'new' => $n,
141			];
142			}
143			}
144			ksort($diff);
145
146			return $diff;
147			}
148
149			/**
150			* Returns an array describing an entity.
151			*
152			* @param EntityManagerInterface $em
153			* @param object $entity
154			* @param mixed $id
155			*
156			* @throws \Doctrine\DBAL\DBALException
157			* @throws \Doctrine\ORM\Mapping\MappingException
158			*
159			* @return array
160			*/
161			private function summarize(EntityManagerInterface $em, $entity = null, $id = null): ?array
162			{
163			if (null === $entity) {
164			return null;
165			}
166
167			$em->getUnitOfWork()->initializeObject($entity); // ensure that proxies are initialized
168			/** @var ClassMetadata $meta */
169			$meta = $em->getClassMetadata(DoctrineHelper::getRealClassName($entity));
170			$pkName = $meta->getSingleIdentifierFieldName();
171			$pkValue = $id ?? $this->id($em, $entity);
172			// An added guard for proxies that fail to initialize.
173			if (null === $pkValue) {
174			return null;
175			}
176
177			if (method_exists($entity, '__toString')) {
178			$label = (string) $entity;
179			} else {
180			$label = DoctrineHelper::getRealClassName($entity).'#'.$pkValue;
181			}
182
183			return [
184			'label' => $label,
185			'class' => $meta->name,
186			'table' => $meta->getTableName(),
187			$pkName => $pkValue,
188			];
189			}
190
191			/**
192			* Blames an audit operation.
193			*
194			* @return array
195			*/
196			private function blame(): array
197			{
198			$user_id = null;
199			$username = null;
200			$client_ip = null;
201			$user_fqdn = null;
202			$user_firewall = null;
203
204			$request = $this->configuration->getRequestStack()->getCurrentRequest();
205			if (null !== $request) {
206			$client_ip = $request->getClientIp();
207			$user_firewall = null === $this->configuration->getFirewallMap()->getFirewallConfig($request) ? null : $this->configuration->getFirewallMap()->getFirewallConfig($request)->getName();
208			}
209
210			$user = null === $this->configuration->getUserProvider() ? null : $this->configuration->getUserProvider()->getUser();
211			if ($user instanceof UserInterface) {
212			$user_id = $user->getId();
213			$username = $user->getUsername();
214			$user_fqdn = DoctrineHelper::getRealClassName($user);
215			}
216
217			return [
218			'user_id' => $user_id,
219			'username' => $username,
220			'client_ip' => $client_ip,
221			'user_fqdn' => $user_fqdn,
222			'user_firewall' => $user_firewall,
223			];
224			}
225			}
226

DamienHarper / DoctrineAuditBundle

Pull Request — master (#188)

AuditTrait::summarize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like