Miliooo\Messaging\Manager\ReadStatusManagerEventAware

Complexity

Total Complexity

5

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	updateReadStatusForMessageCollection()	0	16	1
A	maybeDispatchMessages()	0	6	2
A	dispatchMessage()	0	5	1

<?php

/*
 * This file is part of the MilioooMessageBundle package.
 *
 * (c) Michiel boeckaert <boeckaert@gmail.com>
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Miliooo\Messaging\Manager;

use Miliooo\Messaging\User\ParticipantInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Miliooo\Messaging\Event\MilioooMessagingEvents;
use Miliooo\Messaging\Model\MessageInterface;
use Miliooo\Messaging\Event\ReadStatusMessageEvent;
use Miliooo\Messaging\ValueObjects\ReadStatus;

/**
 * Read status manager who dispatches read status updates events.
 *
 * This class uses the decorator pattern.
 * The read status manager returns an array with updated messages.
 * This class uses this array to dispatch events for these updated messages.
 * Since it implements the same interface it also has to return this array.
 *
 * @author Michiel Boeckaert <boeckaert@gmail.com>
 */
class ReadStatusManagerEventAware implements ReadStatusManagerInterface
{
    /**
     * A read status manager instance.
     *
     * @var ReadStatusManagerInterface
     */
    private $readStatusManager;

    /**
     * An event dispatcher instance.
     *
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * Constructor.
     *
     * @param ReadStatusManagerInterface $readStatusManager
     * @param EventDispatcherInterface   $eventDispatcher
     */
    public function __construct(
        ReadStatusManagerInterface $readStatusManager,
        EventDispatcherInterface $eventDispatcher
    ) {
        $this->readStatusManager = $readStatusManager;
        $this->eventDispatcher = $eventDispatcher;
    }

    /**
     * {@inheritdoc}
     */
    public function updateReadStatusForMessageCollection(

The return type could not be reliably inferred; please add a @return annotation.

        ReadStatus $updatedReadStatus,
        ParticipantInterface $participant,
        $messages = []
    ) {

        $updatedMessages = $this->readStatusManager->updateReadStatusForMessageCollection(
            $updatedReadStatus,
            $participant,
            $messages
        );

        $this->maybeDispatchMessages($updatedMessages, $participant);

        return $updatedMessages;
    }

    /**
     * Looping over the updated messages (if any) and dispatching them.
     *
     * @param MessageInterface[]|[] $updatedMessages An array with message interfaces or an empty array if none updated

The doc-type MessageInterface[]|[] could not be parsed: Unknown type name "" at position 19. [(view supported doc-types)

     * @param ParticipantInterface  $participant     The participant for whom we updated the messages
     */
    protected function maybeDispatchMessages($updatedMessages, $participant)
    {
        foreach ($updatedMessages as $message) {
            $this->dispatchMessage($message, $participant);
        }
    }

    /**
     * Dispatch a read status changed event.
     *
     * @param MessageInterface     $message     The message whom read status is changed for the participant
     * @param ParticipantInterface $participant The participant for whom the read status is changed.
     */
    protected function dispatchMessage(MessageInterface $message, ParticipantInterface $participant)
    {
        $event = new ReadStatusMessageEvent($message, $participant);
        $this->eventDispatcher->dispatch(MilioooMessagingEvents::READ_STATUS_CHANGED, $event);
    }
}