OfferHistoryProjector::getApiKeyFromMetadata() - Code Metrics - Inspection of "Feature/iii 3113" - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#440)

unknown

created 2019-11-13 17:14 UTC

OfferHistoryProjector::getApiKeyFromMetadata() A

↳ Parent: OfferHistoryProjector

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

namespace CultuurNet\UDB3\Offer\ReadModel\History;

use Broadway\Domain\DateTime;
use Broadway\Domain\DomainMessage;
use Broadway\Domain\Metadata;
use CultuurNet\UDB3\Event\ReadModel\DocumentRepositoryInterface;
use CultuurNet\UDB3\Event\ReadModel\History\Log;
use CultuurNet\UDB3\EventHandling\DelegateEventHandlingToSpecificMethodTrait;
use CultuurNet\UDB3\Offer\Events\AbstractDescriptionTranslated;
use CultuurNet\UDB3\Offer\Events\AbstractLabelAdded;
use CultuurNet\UDB3\Offer\Events\AbstractLabelRemoved;
use CultuurNet\UDB3\Offer\Events\AbstractTitleTranslated;
use CultuurNet\UDB3\ReadModel\JsonDocument;
use ValueObjects\StringLiteral\StringLiteral;

abstract class OfferHistoryProjector
{
    use DelegateEventHandlingToSpecificMethodTrait {
        DelegateEventHandlingToSpecificMethodTrait::handle as handleUnknownEvents;
    }

    /**
     * @var DocumentRepositoryInterface
     */
    private $documentRepository;

    public function __construct(DocumentRepositoryInterface $documentRepository)
    {
        $this->documentRepository = $documentRepository;
    }

    /**
     * {@inheritdoc}
     */
    public function handle(DomainMessage $domainMessage)
    {
        $event = $domainMessage->getPayload();

        $eventName = get_class($event);
        $eventHandlers = $this->getEventHandlers();

        if (isset($eventHandlers[$eventName])) {
            $handler = $eventHandlers[$eventName];
            call_user_func(array($this, $handler), $event, $domainMessage);
        } else {
            $this->handleUnknownEvents($domainMessage);
        }
    }

    /**
     * @return string[]
     *   An associative array of commands and their handler methods.
     */
    protected function getEventHandlers()
    {
        $events = [];

        foreach (get_class_methods($this) as $method) {
            $matches = [];

            if (preg_match('/^apply(.+)$/', $method, $matches)) {
                $event = $matches[1];
                $classNameMethod = 'get' . $event . 'ClassName';

                if (method_exists($this, $classNameMethod)) {
                    $eventFullClassName = call_user_func(array($this, $classNameMethod));
                    $events[$eventFullClassName] = $method;
                }
            }
        }

        return $events;
    }

    /**
     * @return string
     */
    abstract protected function getLabelAddedClassName();

    /**
     * @return string
     */
    abstract protected function getLabelRemovedClassName();

    /**
     * @return string
     */
    abstract protected function getTitleTranslatedClassName();

    /**
     * @return string
     */
    abstract protected function getDescriptionTranslatedClassName();

    /**
     * @param AbstractLabelAdded $labelAdded
     * @param DomainMessage $domainMessage
     */
    protected function applyLabelAdded(
        AbstractLabelAdded $labelAdded,
        DomainMessage $domainMessage
    ) {
        $this->writeHistory(
            $labelAdded->getItemId(),
            new Log(
                $this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
                new StringLiteral("Label '{$labelAdded->getLabel()}' toegepast"),
                $this->getAuthorFromMetadata($domainMessage->getMetadata()),
                $this->getApiKeyFromMetadata($domainMessage->getMetadata())
            )
        );
    }

    /**
     * @param AbstractLabelRemoved $labelRemoved
     * @param DomainMessage $domainMessage
     */
    protected function applyLabelRemoved(
        AbstractLabelRemoved $labelRemoved,
        DomainMessage $domainMessage
    ) {
        $this->writeHistory(
            $labelRemoved->getItemId(),
            new Log(
                $this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
                new StringLiteral("Label '{$labelRemoved->getLabel()}' verwijderd"),
                $this->getAuthorFromMetadata($domainMessage->getMetadata()),
                $this->getApiKeyFromMetadata($domainMessage->getMetadata())
            )
        );
    }

    protected function applyTitleTranslated(
        AbstractTitleTranslated $titleTranslated,
        DomainMessage $domainMessage
    ) {
        $this->writeHistory(
            $titleTranslated->getItemId(),
            new Log(
                $this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
                new StringLiteral("Titel vertaald ({$titleTranslated->getLanguage()})"),
                $this->getAuthorFromMetadata($domainMessage->getMetadata()),
                $this->getApiKeyFromMetadata($domainMessage->getMetadata())
            )
        );
    }

    protected function applyDescriptionTranslated(
        AbstractDescriptionTranslated $descriptionTranslated,
        DomainMessage $domainMessage
    ) {
        $this->writeHistory(
            $descriptionTranslated->getItemId(),
            new Log(
                $this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
                new StringLiteral("Beschrijving vertaald ({$descriptionTranslated->getLanguage()})"),
                $this->getAuthorFromMetadata($domainMessage->getMetadata()),
                $this->getApiKeyFromMetadata($domainMessage->getMetadata())
            )
        );
    }

    /**
     * @param DateTime $date
     * @return \DateTime
     */
    protected function domainMessageDateToNativeDate(DateTime $date)
    {
        $dateString = $date->toString();
        return \DateTime::createFromFormat(

            DateTime::FORMAT_STRING,
            $dateString
        );
    }

    /**
     * @param $dateString
     * @return \DateTime
     */
    protected function dateFromUdb2DateString($dateString)
    {
        return \DateTime::createFromFormat(

            'Y-m-d?H:i:s',
            $dateString,
            new \DateTimeZone('Europe/Brussels')
        );
    }

    /**
     * @param Metadata $metadata
     * @return String|null
     */
    protected function getAuthorFromMetadata(Metadata $metadata)
    {
        $properties = $metadata->serialize();

        if (isset($properties['user_nick'])) {
            return new StringLiteral($properties['user_nick']);
        }
    }

    /**
     * @param Metadata $metadata
     * @return String|null
     */
    protected function getConsumerFromMetadata(Metadata $metadata)
    {
        $properties = $metadata->serialize();

        if (isset($properties['consumer']['name'])) {
            return new StringLiteral($properties['consumer']['name']);
        }
    }

    /**
     * @param string $eventId
     * @return JsonDocument
     */
    protected function loadDocumentFromRepositoryByEventId($eventId)
    {
        $historyDocument = $this->documentRepository->get($eventId);

        if (!$historyDocument) {
            $historyDocument = new JsonDocument($eventId, '[]');
        }

        return $historyDocument;
    }

    /**
     * @param string $eventId
     * @param Log[]|Log $logs
     */
    protected function writeHistory($eventId, $logs)
    {
        $historyDocument = $this->loadDocumentFromRepositoryByEventId($eventId);

        $history = $historyDocument->getBody();

        if (!is_array($logs)) {
            $logs = [$logs];
        }

        // Append most recent one to the top.
        foreach ($logs as $log) {
            array_unshift($history, $log);
        }

        $this->documentRepository->save(
            $historyDocument->withBody($history)
        );
    }

    protected function getApiKeyFromMetadata(Metadata $metadata): ?string
    {
        $properties = $metadata->serialize();

        if (isset($properties['auth_api_key'])) {
            return $properties['auth_api_key'];
        }

        return null;
    }
}


1			<?php
2
3			namespace CultuurNet\UDB3\Offer\ReadModel\History;
4
5			use Broadway\Domain\DateTime;
6			use Broadway\Domain\DomainMessage;
7			use Broadway\Domain\Metadata;
8			use CultuurNet\UDB3\Event\ReadModel\DocumentRepositoryInterface;
9			use CultuurNet\UDB3\Event\ReadModel\History\Log;
10			use CultuurNet\UDB3\EventHandling\DelegateEventHandlingToSpecificMethodTrait;
11			use CultuurNet\UDB3\Offer\Events\AbstractDescriptionTranslated;
12			use CultuurNet\UDB3\Offer\Events\AbstractLabelAdded;
13			use CultuurNet\UDB3\Offer\Events\AbstractLabelRemoved;
14			use CultuurNet\UDB3\Offer\Events\AbstractTitleTranslated;
15			use CultuurNet\UDB3\ReadModel\JsonDocument;
16			use ValueObjects\StringLiteral\StringLiteral;
17
18			abstract class OfferHistoryProjector
19			{
20			use DelegateEventHandlingToSpecificMethodTrait {
21			DelegateEventHandlingToSpecificMethodTrait::handle as handleUnknownEvents;
22			}
23
24			/**
25			* @var DocumentRepositoryInterface
26			*/
27			private $documentRepository;
28
29			public function __construct(DocumentRepositoryInterface $documentRepository)
30			{
31			$this->documentRepository = $documentRepository;
32			}
33
34			/**
35			* {@inheritdoc}
36			*/
37			public function handle(DomainMessage $domainMessage)
38			{
39			$event = $domainMessage->getPayload();
40
41			$eventName = get_class($event);
42			$eventHandlers = $this->getEventHandlers();
43
44			if (isset($eventHandlers[$eventName])) {
45			$handler = $eventHandlers[$eventName];
46			call_user_func(array($this, $handler), $event, $domainMessage);
47			} else {
48			$this->handleUnknownEvents($domainMessage);
49			}
50			}
51
52			/**
53			* @return string[]
54			* An associative array of commands and their handler methods.
55			*/
56			protected function getEventHandlers()
57			{
58			$events = [];
59
60			foreach (get_class_methods($this) as $method) {
61			$matches = [];
62
63			if (preg_match('/^apply(.+)$/', $method, $matches)) {
64			$event = $matches[1];
65			$classNameMethod = 'get' . $event . 'ClassName';
66
67			if (method_exists($this, $classNameMethod)) {
68			$eventFullClassName = call_user_func(array($this, $classNameMethod));
69			$events[$eventFullClassName] = $method;
70			}
71			}
72			}
73
74			return $events;
75			}
76
77			/**
78			* @return string
79			*/
80			abstract protected function getLabelAddedClassName();
81
82			/**
83			* @return string
84			*/
85			abstract protected function getLabelRemovedClassName();
86
87			/**
88			* @return string
89			*/
90			abstract protected function getTitleTranslatedClassName();
91
92			/**
93			* @return string
94			*/
95			abstract protected function getDescriptionTranslatedClassName();
96
97			/**
98			* @param AbstractLabelAdded $labelAdded
99			* @param DomainMessage $domainMessage
100			*/
101			protected function applyLabelAdded(
102			AbstractLabelAdded $labelAdded,
103			DomainMessage $domainMessage
104			) {
105			$this->writeHistory(
106			$labelAdded->getItemId(),
107			new Log(
108			$this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
109			new StringLiteral("Label '{$labelAdded->getLabel()}' toegepast"),
110			$this->getAuthorFromMetadata($domainMessage->getMetadata()),
111			$this->getApiKeyFromMetadata($domainMessage->getMetadata())
112			)
113			);
114			}
115
116			/**
117			* @param AbstractLabelRemoved $labelRemoved
118			* @param DomainMessage $domainMessage
119			*/
120			protected function applyLabelRemoved(
121			AbstractLabelRemoved $labelRemoved,
122			DomainMessage $domainMessage
123			) {
124			$this->writeHistory(
125			$labelRemoved->getItemId(),
126			new Log(
127			$this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
128			new StringLiteral("Label '{$labelRemoved->getLabel()}' verwijderd"),
129			$this->getAuthorFromMetadata($domainMessage->getMetadata()),
130			$this->getApiKeyFromMetadata($domainMessage->getMetadata())
131			)
132			);
133			}
134
135			protected function applyTitleTranslated(
136			AbstractTitleTranslated $titleTranslated,
137			DomainMessage $domainMessage
138			) {
139			$this->writeHistory(
140			$titleTranslated->getItemId(),
141			new Log(
142			$this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
143			new StringLiteral("Titel vertaald ({$titleTranslated->getLanguage()})"),
144			$this->getAuthorFromMetadata($domainMessage->getMetadata()),
145			$this->getApiKeyFromMetadata($domainMessage->getMetadata())
146			)
147			);
148			}
149
150			protected function applyDescriptionTranslated(
151			AbstractDescriptionTranslated $descriptionTranslated,
152			DomainMessage $domainMessage
153			) {
154			$this->writeHistory(
155			$descriptionTranslated->getItemId(),
156			new Log(
157			$this->domainMessageDateToNativeDate($domainMessage->getRecordedOn()),
158			new StringLiteral("Beschrijving vertaald ({$descriptionTranslated->getLanguage()})"),
159			$this->getAuthorFromMetadata($domainMessage->getMetadata()),
160			$this->getApiKeyFromMetadata($domainMessage->getMetadata())
161			)
162			);
163			}
164
165			/**
166			* @param DateTime $date
167			* @return \DateTime
168			*/
169			protected function domainMessageDateToNativeDate(DateTime $date)
170			{
171			$dateString = $date->toString();
172			return \DateTime::createFromFormat(
			0 ignored issues – show Comprehensibility Best Practice introduced 2016-02-05 15:19 UTC by Report Bug Copy Issue Report The expression `\DateTime::createFromFor...T_STRING, $dateString);` of type `DateTime\|false` adds `false` to the return on line 172 which is incompatible with the return type documented by `CultuurNet\UDB3\Offer\Re...MessageDateToNativeDate` of type `DateTime`. It seems like you forgot to handle an error condition. Loading history...
173			DateTime::FORMAT_STRING,
174			$dateString
175			);
176			}
177
178			/**
179			* @param $dateString
180			* @return \DateTime
181			*/
182			protected function dateFromUdb2DateString($dateString)
183			{
184			return \DateTime::createFromFormat(
			0 ignored issues – show Comprehensibility Best Practice introduced 2016-02-05 15:19 UTC by Report Bug Copy Issue Report The expression `\DateTime::createFromFor...ne('Europe/Brussels'));` of type `DateTime\|false` adds `false` to the return on line 184 which is incompatible with the return type documented by `CultuurNet\UDB3\Offer\Re...:dateFromUdb2DateString` of type `DateTime`. It seems like you forgot to handle an error condition. Loading history...
185			'Y-m-d?H:i:s',
186			$dateString,
187			new \DateTimeZone('Europe/Brussels')
188			);
189			}
190
191			/**
192			* @param Metadata $metadata
193			* @return String\|null
194			*/
195			protected function getAuthorFromMetadata(Metadata $metadata)
196			{
197			$properties = $metadata->serialize();
198
199			if (isset($properties['user_nick'])) {
200			return new StringLiteral($properties['user_nick']);
201			}
202			}
203
204			/**
205			* @param Metadata $metadata
206			* @return String\|null
207			*/
208			protected function getConsumerFromMetadata(Metadata $metadata)
209			{
210			$properties = $metadata->serialize();
211
212			if (isset($properties['consumer']['name'])) {
213			return new StringLiteral($properties['consumer']['name']);
214			}
215			}
216
217			/**
218			* @param string $eventId
219			* @return JsonDocument
220			*/
221			protected function loadDocumentFromRepositoryByEventId($eventId)
222			{
223			$historyDocument = $this->documentRepository->get($eventId);
224
225			if (!$historyDocument) {
226			$historyDocument = new JsonDocument($eventId, '[]');
227			}
228
229			return $historyDocument;
230			}
231
232			/**
233			* @param string $eventId
234			* @param Log[]\|Log $logs
235			*/
236			protected function writeHistory($eventId, $logs)
237			{
238			$historyDocument = $this->loadDocumentFromRepositoryByEventId($eventId);
239
240			$history = $historyDocument->getBody();
241
242			if (!is_array($logs)) {
243			$logs = [$logs];
244			}
245
246			// Append most recent one to the top.
247			foreach ($logs as $log) {
248			array_unshift($history, $log);
249			}
250
251			$this->documentRepository->save(
252			$historyDocument->withBody($history)
253			);
254			}
255
256			protected function getApiKeyFromMetadata(Metadata $metadata): ?string
257			{
258			$properties = $metadata->serialize();
259
260			if (isset($properties['auth_api_key'])) {
261			return $properties['auth_api_key'];
262			}
263
264			return null;
265			}
266			}
267

cultuurnet / udb3-php

Pull Request — master (#440)

OfferHistoryProjector::getApiKeyFromMetadata() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like