PublishableEventListener::__construct() - Code Metrics - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

PublishableEventListener::__construct() A
last analyzed 2024-02-03 11:14 UTC

↳ Parent: PublishableEventListener

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	3
dl	0
loc	6
ccs	0
cts	5
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

/*
 * This file is part of the Silverback API Components Bundle Project
 *
 * (c) Daniel West <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentsBundle\EventListener\Api;

use ApiPlatform\Metadata\CollectionOperationInterface;
use ApiPlatform\Symfony\Validator\Exception\ValidationException;
use ApiPlatform\Validator\ValidatorInterface;
use Doctrine\Persistence\ManagerRegistry;
use Silverback\ApiComponentsBundle\AttributeReader\PublishableAttributeReader;
use Silverback\ApiComponentsBundle\Entity\Utility\PublishableTrait;
use Silverback\ApiComponentsBundle\Helper\Publishable\PublishableStatusChecker;
use Silverback\ApiComponentsBundle\Utility\ClassMetadataTrait;
use Silverback\ApiComponentsBundle\Validator\PublishableValidator;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\Event\ViewEvent;
use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;

/**
 * @author Vincent Chalamon <[email protected]>
 */
final class PublishableEventListener
{
    use ApiEventListenerTrait;

    use ClassMetadataTrait;

    public const VALID_TO_PUBLISH_HEADER = 'valid-to-publish';
    public const VALID_PUBLISHED_QUERY = 'validate_published';

    private PublishableStatusChecker $publishableStatusChecker;
    private ValidatorInterface $validator;
    private PublishableAttributeReader $publishableAnnotationReader;

    public function __construct(PublishableStatusChecker $publishableStatusChecker, ManagerRegistry $registry, ValidatorInterface $validator)
    {
        $this->publishableAnnotationReader = $publishableStatusChecker->getAttributeReader();
        $this->publishableStatusChecker = $publishableStatusChecker;
        $this->initRegistry($registry);
        $this->validator = $validator;
    }

    public function onPreWrite(ViewEvent $event): void
    {
        $request = $event->getRequest();
        $attributes = $this->getAttributes($request);
        if (
            empty($attributes['data'])
            || !$this->publishableAnnotationReader->isConfigured($attributes['class'])
            || $request->isMethod(Request::METHOD_DELETE)
            || $attributes['operation'] instanceof CollectionOperationInterface
        ) {
            return;
        }

        $publishable = $this->checkMergeDraftIntoPublished($request, $attributes['data']);
        $event->setControllerResult($publishable);
    }

    public function onPostRead(RequestEvent $event): void
    {
        $request = $event->getRequest();
        $attributes = $this->getAttributes($request);
        if (
            empty($attributes['data'])
            || !$this->publishableAnnotationReader->isConfigured($attributes['class'])
            || !$request->isMethod(Request::METHOD_GET)
            || $attributes['operation'] instanceof CollectionOperationInterface
        ) {
            return;
        }

        $this->checkMergeDraftIntoPublished($request, $attributes['data'], true);
    }

    public function onPostDeserialize(RequestEvent $event): void
    {
        $request = $event->getRequest();
        $attributes = $this->getAttributes($request);
        if (
            empty($attributes['data'])
            || !$this->publishableAnnotationReader->isConfigured($attributes['class'])
            || !($request->isMethod(Request::METHOD_PUT) || $request->isMethod(Request::METHOD_PATCH))
        ) {
            return;
        }

        $configuration = $this->publishableAnnotationReader->getConfiguration($attributes['class']);

        // User cannot change the publication date of the original resource
        if (
            true === $this->publishableStatusChecker->isRequestForPublished($request)
            && $this->getValue($request->attributes->get('previous_data'), $configuration->fieldName) !== $this->getValue($attributes['data'], $configuration->fieldName)
        ) {
            throw new UnprocessableEntityHttpException('You cannot change the publication date of a published resource.');
        }
    }

    public function onPostRespond(ResponseEvent $event): void
    {
        $request = $event->getRequest();

        $attributes = $this->getAttributes($request);

        /**
         * @var PublishableTrait|null $data
         */
        $data = $attributes['data'];

        if (
            null === $data
            || !$this->publishableAnnotationReader->isConfigured($attributes['class'])
            || $attributes['operation'] instanceof CollectionOperationInterface
        ) {
            return;
        }
        $response = $event->getResponse();

        $configuration = $this->publishableAnnotationReader->getConfiguration($attributes['class']);
        $classMetadata = $this->getClassMetadata($attributes['class']);
        $draftResource = $classMetadata->getFieldValue($data, $configuration->reverseAssociationName) ?? $data;

        // Add Expires HTTP header
        /** @var \DateTime|null $publishedAt */
        $publishedAt = $classMetadata->getFieldValue($draftResource, $configuration->fieldName);
        if ($publishedAt && $publishedAt > new \DateTime()) {
            $response->setExpires($publishedAt);
        }

        if (!$this->publishableStatusChecker->isGranted($attributes['class'])) {
            return;
        }

        if ($response->isClientError()) {
            $response->headers->set(self::VALID_TO_PUBLISH_HEADER, '0');

            return;
        }

        // Force validation from querystring, and/or add validate-to-publish custom HTTP header
        try {
            $this->validator->validate($data, [PublishableValidator::PUBLISHED_KEY => true]);
            $response->headers->set(self::VALID_TO_PUBLISH_HEADER, '1');
        } catch (ValidationException $exception) {
            $response->headers->set(self::VALID_TO_PUBLISH_HEADER, '0');

            if (
                true === $request->query->getBoolean(self::VALID_PUBLISHED_QUERY, false)
                && \in_array($request->getMethod(), [Request::METHOD_POST, Request::METHOD_PUT], true)
            ) {
                throw $exception;
            }
        }
    }

    private function getValue(object $object, string $property)
    {
        return $this->getClassMetadata($object)->getFieldValue($object, $property);
    }

    private function checkMergeDraftIntoPublished(Request $request, object $data, bool $flushDatabase = false): object
    {
        if (!$this->publishableStatusChecker->isActivePublishedAt($data)) {
            return $data;
        }

        $configuration = $this->publishableAnnotationReader->getConfiguration($data);
        $classMetadata = $this->getClassMetadata($data);

        $publishedResourceAssociation = $classMetadata->getFieldValue($data, $configuration->associationName);
        $draftResourceAssociation = $classMetadata->getFieldValue($data, $configuration->reverseAssociationName);
        if (
            !$publishedResourceAssociation
            && (!$draftResourceAssociation || !$this->publishableStatusChecker->isActivePublishedAt($draftResourceAssociation))
        ) {
            return $data;
        }

        // the request is for a resource with an active publish date
        // either a draft, if so it may be a published version we need to replace with
        // or a published resource which may have a draft that has an active publish date
        $entityManager = $this->getEntityManager($data);

        $meta = $entityManager->getClassMetadata($data::class);
        $identifierFieldName = $meta->getSingleIdentifierFieldName();

        if ($publishedResourceAssociation) {
            // retrieving a draft that is now published
            $draftResource = $data;
            $publishedResource = $publishedResourceAssociation;

            $publishedId = $classMetadata->getFieldValue($publishedResource, $identifierFieldName);
            $request->attributes->set('id', $publishedId);
            $request->attributes->set('data', $publishedResource);
            $request->attributes->set('previous_data', clone $publishedResource);
        } else {
            // retrieving a published resource and draft should now replace it
            $publishedResource = $data;
            $draftResource = $draftResourceAssociation;
        }

        $classMetadata->setFieldValue($publishedResource, $configuration->reverseAssociationName, null);
        $classMetadata->setFieldValue($draftResource, $configuration->associationName, null);

        $this->mergeDraftIntoPublished($identifierFieldName, $draftResource, $publishedResource, $flushDatabase);

        return $publishedResource;
    }

    private function mergeDraftIntoPublished(string $identifierFieldName, object $draftResource, object $publishedResource, bool $flushDatabase): void
    {
        $draftReflection = new \ReflectionClass($draftResource);
        $publishedReflection = new \ReflectionClass($publishedResource);
        $properties = $publishedReflection->getProperties();

        foreach ($properties as $property) {
            $property->setAccessible(true);
            $name = $property->getName();
            if ($identifierFieldName === $name) {
                continue;
            }
            $draftProperty = $draftReflection->hasProperty($name) ? $draftReflection->getProperty($name) : null;
            if ($draftProperty) {
                $draftProperty->setAccessible(true);
                $draftValue = $draftProperty->getValue($draftResource);
                $property->setValue($publishedResource, $draftValue);
            }
        }

        $entityManager = $this->getEntityManager($draftResource);
        $entityManager->remove($draftResource);

        if ($flushDatabase) {
            $entityManager->flush();
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the Silverback API Components Bundle Project
5			*
6			* (c) Daniel West <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Silverback\ApiComponentsBundle\EventListener\Api;
15
16			use ApiPlatform\Metadata\CollectionOperationInterface;
17			use ApiPlatform\Symfony\Validator\Exception\ValidationException;
18			use ApiPlatform\Validator\ValidatorInterface;
19			use Doctrine\Persistence\ManagerRegistry;
20			use Silverback\ApiComponentsBundle\AttributeReader\PublishableAttributeReader;
21			use Silverback\ApiComponentsBundle\Entity\Utility\PublishableTrait;
22			use Silverback\ApiComponentsBundle\Helper\Publishable\PublishableStatusChecker;
23			use Silverback\ApiComponentsBundle\Utility\ClassMetadataTrait;
24			use Silverback\ApiComponentsBundle\Validator\PublishableValidator;
25			use Symfony\Component\HttpFoundation\Request;
26			use Symfony\Component\HttpKernel\Event\RequestEvent;
27			use Symfony\Component\HttpKernel\Event\ResponseEvent;
28			use Symfony\Component\HttpKernel\Event\ViewEvent;
29			use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
30
31			/**
32			* @author Vincent Chalamon <[email protected]>
33			*/
34			final class PublishableEventListener
35			{
36			use ApiEventListenerTrait;
			0 ignored issues – show Bug introduced 2022-04-24 19:43 UTC by Report Bug Copy Issue Report The trait `Silverback\ApiComponents...i\ApiEventListenerTrait` requires the property `$attributes` which is not provided by `Silverback\ApiComponents...ublishableEventListener`. Loading history...
37			use ClassMetadataTrait;
38
39			public const VALID_TO_PUBLISH_HEADER = 'valid-to-publish';
40			public const VALID_PUBLISHED_QUERY = 'validate_published';
41
42			private PublishableStatusChecker $publishableStatusChecker;
43			private ValidatorInterface $validator;
44			private PublishableAttributeReader $publishableAnnotationReader;
45
46			public function __construct(PublishableStatusChecker $publishableStatusChecker, ManagerRegistry $registry, ValidatorInterface $validator)
47			{
48			$this->publishableAnnotationReader = $publishableStatusChecker->getAttributeReader();
49			$this->publishableStatusChecker = $publishableStatusChecker;
50			$this->initRegistry($registry);
51			$this->validator = $validator;
52			}
53
54			public function onPreWrite(ViewEvent $event): void
55			{
56			$request = $event->getRequest();
57			$attributes = $this->getAttributes($request);
58			if (
59			empty($attributes['data'])
60			\|\| !$this->publishableAnnotationReader->isConfigured($attributes['class'])
61			\|\| $request->isMethod(Request::METHOD_DELETE)
62			\|\| $attributes['operation'] instanceof CollectionOperationInterface
63			) {
64			return;
65			}
66
67			$publishable = $this->checkMergeDraftIntoPublished($request, $attributes['data']);
68			$event->setControllerResult($publishable);
69			}
70
71			public function onPostRead(RequestEvent $event): void
72			{
73			$request = $event->getRequest();
74			$attributes = $this->getAttributes($request);
75			if (
76			empty($attributes['data'])
77			\|\| !$this->publishableAnnotationReader->isConfigured($attributes['class'])
78			\|\| !$request->isMethod(Request::METHOD_GET)
79			\|\| $attributes['operation'] instanceof CollectionOperationInterface
80			) {
81			return;
82			}
83
84			$this->checkMergeDraftIntoPublished($request, $attributes['data'], true);
85			}
86
87			public function onPostDeserialize(RequestEvent $event): void
88			{
89			$request = $event->getRequest();
90			$attributes = $this->getAttributes($request);
91			if (
92			empty($attributes['data'])
93			\|\| !$this->publishableAnnotationReader->isConfigured($attributes['class'])
94			\|\| !($request->isMethod(Request::METHOD_PUT) \|\| $request->isMethod(Request::METHOD_PATCH))
95			) {
96			return;
97			}
98
99			$configuration = $this->publishableAnnotationReader->getConfiguration($attributes['class']);
100
101			// User cannot change the publication date of the original resource
102			if (
103			true === $this->publishableStatusChecker->isRequestForPublished($request)
104			&& $this->getValue($request->attributes->get('previous_data'), $configuration->fieldName) !== $this->getValue($attributes['data'], $configuration->fieldName)
105			) {
106			throw new UnprocessableEntityHttpException('You cannot change the publication date of a published resource.');
107			}
108			}
109
110			public function onPostRespond(ResponseEvent $event): void
111			{
112			$request = $event->getRequest();
113
114			$attributes = $this->getAttributes($request);
115
116			/**
117			* @var PublishableTrait\|null $data
118			*/
119			$data = $attributes['data'];
120
121			if (
122			null === $data
123			\|\| !$this->publishableAnnotationReader->isConfigured($attributes['class'])
124			\|\| $attributes['operation'] instanceof CollectionOperationInterface
125			) {
126			return;
127			}
128			$response = $event->getResponse();
129
130			$configuration = $this->publishableAnnotationReader->getConfiguration($attributes['class']);
131			$classMetadata = $this->getClassMetadata($attributes['class']);
132			$draftResource = $classMetadata->getFieldValue($data, $configuration->reverseAssociationName) ?? $data;
133
134			// Add Expires HTTP header
135			/** @var \DateTime\|null $publishedAt */
136			$publishedAt = $classMetadata->getFieldValue($draftResource, $configuration->fieldName);
137			if ($publishedAt && $publishedAt > new \DateTime()) {
138			$response->setExpires($publishedAt);
139			}
140
141			if (!$this->publishableStatusChecker->isGranted($attributes['class'])) {
142			return;
143			}
144
145			if ($response->isClientError()) {
146			$response->headers->set(self::VALID_TO_PUBLISH_HEADER, '0');
147
148			return;
149			}
150
151			// Force validation from querystring, and/or add validate-to-publish custom HTTP header
152			try {
153			$this->validator->validate($data, [PublishableValidator::PUBLISHED_KEY => true]);
154			$response->headers->set(self::VALID_TO_PUBLISH_HEADER, '1');
155			} catch (ValidationException $exception) {
156			$response->headers->set(self::VALID_TO_PUBLISH_HEADER, '0');
157
158			if (
159			true === $request->query->getBoolean(self::VALID_PUBLISHED_QUERY, false)
160			&& \in_array($request->getMethod(), [Request::METHOD_POST, Request::METHOD_PUT], true)
161			) {
162			throw $exception;
163			}
164			}
165			}
166
167			private function getValue(object $object, string $property)
168			{
169			return $this->getClassMetadata($object)->getFieldValue($object, $property);
170			}
171
172			private function checkMergeDraftIntoPublished(Request $request, object $data, bool $flushDatabase = false): object
173			{
174			if (!$this->publishableStatusChecker->isActivePublishedAt($data)) {
175			return $data;
176			}
177
178			$configuration = $this->publishableAnnotationReader->getConfiguration($data);
179			$classMetadata = $this->getClassMetadata($data);
180
181			$publishedResourceAssociation = $classMetadata->getFieldValue($data, $configuration->associationName);
182			$draftResourceAssociation = $classMetadata->getFieldValue($data, $configuration->reverseAssociationName);
183			if (
184			!$publishedResourceAssociation
185			&& (!$draftResourceAssociation \|\| !$this->publishableStatusChecker->isActivePublishedAt($draftResourceAssociation))
186			) {
187			return $data;
188			}
189
190			// the request is for a resource with an active publish date
191			// either a draft, if so it may be a published version we need to replace with
192			// or a published resource which may have a draft that has an active publish date
193			$entityManager = $this->getEntityManager($data);
194
195			$meta = $entityManager->getClassMetadata($data::class);
196			$identifierFieldName = $meta->getSingleIdentifierFieldName();
197
198			if ($publishedResourceAssociation) {
199			// retrieving a draft that is now published
200			$draftResource = $data;
201			$publishedResource = $publishedResourceAssociation;
202
203			$publishedId = $classMetadata->getFieldValue($publishedResource, $identifierFieldName);
204			$request->attributes->set('id', $publishedId);
205			$request->attributes->set('data', $publishedResource);
206			$request->attributes->set('previous_data', clone $publishedResource);
207			} else {
208			// retrieving a published resource and draft should now replace it
209			$publishedResource = $data;
210			$draftResource = $draftResourceAssociation;
211			}
212
213			$classMetadata->setFieldValue($publishedResource, $configuration->reverseAssociationName, null);
214			$classMetadata->setFieldValue($draftResource, $configuration->associationName, null);
215
216			$this->mergeDraftIntoPublished($identifierFieldName, $draftResource, $publishedResource, $flushDatabase);
217
218			return $publishedResource;
219			}
220
221			private function mergeDraftIntoPublished(string $identifierFieldName, object $draftResource, object $publishedResource, bool $flushDatabase): void
222			{
223			$draftReflection = new \ReflectionClass($draftResource);
224			$publishedReflection = new \ReflectionClass($publishedResource);
225			$properties = $publishedReflection->getProperties();
226
227			foreach ($properties as $property) {
228			$property->setAccessible(true);
229			$name = $property->getName();
230			if ($identifierFieldName === $name) {
231			continue;
232			}
233			$draftProperty = $draftReflection->hasProperty($name) ? $draftReflection->getProperty($name) : null;
234			if ($draftProperty) {
235			$draftProperty->setAccessible(true);
236			$draftValue = $draftProperty->getValue($draftResource);
237			$property->setValue($publishedResource, $draftValue);
238			}
239			}
240
241			$entityManager = $this->getEntityManager($draftResource);
242			$entityManager->remove($draftResource);
243
244			if ($flushDatabase) {
245			$entityManager->flush();
246			}
247			}
248			}
249

components-web-app / api-components-bundle

PublishableEventListener::__construct() A last analyzed 2024-02-03 11:14 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

PublishableEventListener::__construct() A
last analyzed 2024-02-03 11:14 UTC