Surfnet\StepupMiddleware\CommandHandlingBundle\SensitiveData\EventSourcing\SensitiveDataMessageStream

Complexity

Total Complexity

18

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	5
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getIterator()	0	4	1
A	applyToDomainEventStream()	0	21	4
A	forget()	0	6	2
C	setSensitiveData()	0	35	8
A	createSensitiveDataMap()	0	9	2

<?php

/**
 * Copyright 2014 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Surfnet\StepupMiddleware\CommandHandlingBundle\SensitiveData\EventSourcing;

use ArrayIterator;
use Broadway\Domain\DomainEventStreamInterface;
use Broadway\Domain\DomainMessage;
use IteratorAggregate;
use Surfnet\StepupMiddleware\CommandHandlingBundle\SensitiveData\Exception\SensitiveDataApplicationException;
use Surfnet\StepupMiddleware\CommandHandlingBundle\SensitiveData\Forgettable;

class SensitiveDataMessageStream implements IteratorAggregate
{
    /**
     * @var array
     */
    private $messages;

    /**
     * @param SensitiveDataMessage[] $messages
     */
    public function __construct(array $messages)
    {
        $this->messages = $messages;
    }

    public function applyToDomainEventStream(DomainEventStreamInterface $domainEventStream)
    {
        $sensitiveDataMap = $this->createSensitiveDataMap($this->messages);

        /** @var DomainMessage $domainMessage */
        foreach ($domainEventStream as $domainMessage) {
            $sensitiveDataMessage = isset($sensitiveDataMap[$domainMessage->getPlayhead()])
                ? $sensitiveDataMap[$domainMessage->getPlayhead()]
                : null;
            unset($sensitiveDataMap[$domainMessage->getPlayhead()]);

            $this->setSensitiveData($domainMessage, $sensitiveDataMessage);
        }

        if (count($sensitiveDataMap) > 0) {
            throw new SensitiveDataApplicationException(sprintf(
                '%d sensitive data messages are still to be matched to events',
                count($sensitiveDataMap)
            ));
        }
    }

    public function forget()
    {
        foreach ($this->messages as $message) {
            $message->forget();
        }
    }

    public function getIterator()
    {
        return new ArrayIterator($this->messages);
    }

    /**
     * @param DomainMessage $domainMessage
     * @param SensitiveDataMessage|null $sensitiveDataMessage
     */
    private function setSensitiveData(DomainMessage $domainMessage, SensitiveDataMessage $sensitiveDataMessage = null)
    {
        $event = $domainMessage->getPayload();
        $eventIsForgettable = $event instanceof Forgettable;

        if (!$eventIsForgettable && !$sensitiveDataMessage) {
            return;
        }

        if ($eventIsForgettable && !$sensitiveDataMessage) {
            throw new SensitiveDataApplicationException(sprintf(
                'Sensitive data is missing for event with UUID %s, playhead %d',
                $domainMessage->getId(),
                $domainMessage->getPlayhead()
            ));
        }

        if (!$eventIsForgettable && $sensitiveDataMessage) {
            throw new SensitiveDataApplicationException(sprintf(
                'Encountered sensitive data for event which does not support sensitive data, UUID %s, playhead %d',
                $domainMessage->getId(),
                $domainMessage->getPlayhead()
            ));
        }

        if ($domainMessage->getId() != $sensitiveDataMessage->getIdentityId()) {
            throw new SensitiveDataApplicationException(sprintf(
                'Encountered sensitive data from stream %s for event from stream %s',
                $sensitiveDataMessage->getIdentityId(),

It seems like $sensitiveDataMessage is not always an object, but can also be of type null. Maybe add an additional type check?

                $domainMessage->getId()
            ));
        }

        $event->setSensitiveData($sensitiveDataMessage->getSensitiveData());
    }

    /**
     * @param SensitiveDataMessage[] $messages
     * @return SensitiveDataMessage[] The same messages, but indexed by their playheads.
     */
    private function createSensitiveDataMap(array $messages)
    {
        $map = [];
        foreach ($messages as $message) {
            $map[$message->getPlayhead()] = $message;
        }

        return $map;
    }
}