Zbox\UnifiedPush\NotificationService\ResponseHandler

Complexity

Total Complexity

14

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	addMessageResponse()	0	7	1
A	addResponse()	0	5	1
A	handleResponseCollection()	0	11	2
B	handleResponse()	0	28	6
A	getMessageExceptions()	0	4	1
A	getInvalidRecipients()	0	4	1
A	setLogger()	0	5	1

<?php

/*
 * (c) Alexander Zhukov <zbox82@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zbox\UnifiedPush\NotificationService;

use Zbox\UnifiedPush\NotificationService\APNS\ResponseFeedback;
use Zbox\UnifiedPush\Exception\InvalidRecipientException,
    Zbox\UnifiedPush\Exception\DispatchMessageException,
    Zbox\UnifiedPush\Exception\MalformedNotificationException;
use Psr\Log\LoggerAwareInterface,
    Psr\Log\LoggerInterface,
    Psr\Log\NullLogger;

class ResponseHandler implements LoggerAwareInterface
{
    /**
     * @var \SplObjectStorage
     */
    private $responseCollection;

    /**
     * @var \ArrayIterator
     */
    private $invalidRecipients;

    /**
     * @var \ArrayIterator
     */
    private $messageExceptions;

    /**
     * @var LoggerInterface
     */
    private $logger;

    public function __construct()
    {
        $this->responseCollection = new \ArrayIterator();

It seems like new \ArrayIterator() of type object<ArrayIterator> is incompatible with the declared type object<SplObjectStorage> of property $responseCollection.

        $this->setLogger(new NullLogger());
    }

    /**
     * @param string $messageIdentifier
     * @param ResponseInterface $response
     * @return $this
     */
    public function addMessageResponse($messageIdentifier, ResponseInterface $response)
    {
        $this->addResponse($response);
        $this->responseCollection->setInfo($messageIdentifier);

        return $this;
    }

    /**
     * @param ResponseInterface $response
     * @return $this
     */
    public function addResponse(ResponseInterface $response)
    {
        $this->responseCollection->append($response);
        return $this;
    }

    public function handleResponseCollection()
    {
        $responses = $this->responseCollection;

        while ($responses->valid()) {
            $response   = $responses->current();
            $messageId  = $responses->getInfo();
            $this->handleResponse($response, $messageId);
            $responses->next();
        }
    }

    /**
     * @param ResponseInterface $response
     * @param string $messageIdentifier
     */
    public function handleResponse(ResponseInterface $response, $messageIdentifier)
    {
        try {
            $response->processResponse();

            if ($response instanceof ResponseFeedback) {
                throw new InvalidRecipientException(null, $response->getRecipients());
            }
        } catch (InvalidRecipientException $e) {
            while ($recipient = $e->getRecipientDevice()) {
                $this->invalidRecipients->append($recipient);
            }

        } catch (DispatchMessageException $e) {
            $this->messageExceptions->offsetSet($messageIdentifier, $e->getCode());

            $this->logger->warning(
                sprintf("Dispatch message warning with code %d  '%s'", $e->getCode(), $e->getMessage())
            );

        } catch (MalformedNotificationException $e) {
            $this->messageExceptions->offsetSet($messageIdentifier, $e->getCode());

            $this->logger->error(
                sprintf("Malformed Notification error: %s", $e->getMessage())
            );
        }
    }

    /**
     * @return \ArrayIterator
     */
    public function getMessageExceptions()
    {
        return $this->messageExceptions;
    }

    /**
     * @return \ArrayIterator
     */
    public function getInvalidRecipients()
    {
        return $this->invalidRecipients;
    }

    /**
     * @param LoggerInterface $logger
     * @return $this
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
        return $this;
    }
}