Zbox\UnifiedPush\Dispatcher

Complexity

Total Complexity

24

Size/Duplication

Total Lines	233
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	9
Bugs	3	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	setLogger()	0	5	1
A	setDevelopmentMode()	0	5	1
A	getServiceCredentials()	0	4	1
A	getConnection()	0	8	2
A	initConnection()	0	8	1
A	createFeedbackConnection()	0	5	1
B	sendNotifications()	0	27	6
B	dispatch()	0	34	6
B	loadFeedback()	0	29	4

<?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;

use Zbox\UnifiedPush\Message\MessageInterface,
    Zbox\UnifiedPush\Notification\NotificationBuilder;
use Zbox\UnifiedPush\NotificationService\NotificationServices,
    Zbox\UnifiedPush\NotificationService\ServiceClientInterface,
    Zbox\UnifiedPush\NotificationService\ServiceClientFactory;
use Zbox\UnifiedPush\Exception\InvalidRecipientException,
    Zbox\UnifiedPush\Exception\DispatchMessageException,
    Zbox\UnifiedPush\Exception\MalformedNotificationException,
    Zbox\UnifiedPush\Exception\ClientException,
    Zbox\UnifiedPush\Exception\RuntimeException;
use Psr\Log\LoggerAwareInterface,
    Psr\Log\LoggerInterface,
    Psr\Log\NullLogger;

/**
 * Class Dispatcher
 * @package Zbox\UnifiedPush
 */
class Dispatcher implements LoggerAwareInterface
{
    /**
     * @var Application
     */
    private $application;

    /**
     * @var NotificationBuilder
     */
    private $notificationBuilder;

    /**
     * @var array
     */
    private $connectionPool;

    /**
     * @var ServiceClientFactory
     */
    private $clientFactory;

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

    /**
     * @param Application $application
     * @param ServiceClientFactory $clientFactory
     * @param NotificationBuilder $notificationBuilder
     */
    public function __construct(
        Application $application,
        ServiceClientFactory $clientFactory,
        NotificationBuilder $notificationBuilder
    ){
        $this->application    = $application;
        $this->clientFactory  = $clientFactory;
        $this->notificationBuilder = $notificationBuilder;

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

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

    /**
     * @param bool $isDevelopment
     * @return $this
     */
    public function setDevelopmentMode($isDevelopment)
    {
        $this->clientFactory->setDevelopmentMode($isDevelopment);
        return $this;
    }

    /**
     * Returns credentials for notification service
     *
     * @param string $serviceName
     * @return array
     */
    private function getServiceCredentials($serviceName)
    {
        return $this->application->getCredentialsByService($serviceName);
    }

    /**
     * Gets a service client connection by service name
     *
     * @param string $serviceName
     * @return ServiceClientInterface
     */
    public function getConnection($serviceName)
    {
        if (empty($this->connectionPool[$serviceName])) {
            $this->initConnection($serviceName);
        }

        return $this->connectionPool[$serviceName];
    }

    /**
     * Initialize service client connection by service name
     *
     * @param string $serviceName
     * @return $this
     */
    public function initConnection($serviceName)
    {
        $credentials  = $this->getServiceCredentials($serviceName);
        $connection   = $this->clientFactory->createServiceClient($serviceName, $credentials);
        $this->connectionPool[$serviceName] = $connection;

        return $this;
    }

    /**
     * Creates a feedback service connection
     *
     * @param string $serviceName
     * @return ServiceClientInterface
     */
    private function createFeedbackConnection($serviceName)
    {
        $credentials  = $this->getServiceCredentials($serviceName);
        return $this->clientFactory->createServiceClient($serviceName, $credentials, true);
    }

    /**
     * Tries to connect and send a message to notification service
     *
     * @return bool
     * @throws Zbox\UnifiedPush\Exception\InvalidRecipientException
     * @throws Zbox\UnifiedPush\Exception\DispatchMessageException
     * @throws Zbox\UnifiedPush\Exception\MalformedNotificationException
     */
    private function sendNotifications()
    {
        while ($notification = $this->notificationBuilder->getNotification()) {
            try {
                $connection = $this->getConnection($notification->getType());
                $connection->setNotification($notification);
                $connection->sendRequest();

            } catch (InvalidRecipientException $e) {
                while ($recipient = $e->getRecipientDevice()) {
                    $this->application->addInvalidRecipient($notification->getType(), $recipient);
                }

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

            } catch (MalformedNotificationException $e) {
                $this->logger->error(
                    sprintf("Malformed Notification error: %s", $e->getMessage())
                );
                return false;
            }
        }
        return true;
    }

    /**
     * Tries to dispatch all messages to notification service
     *
     * @return bool
     * @throws Zbox\UnifiedPush\Exception\ClientException
     * @throws Zbox\UnifiedPush\Exception\RuntimeException
     * @throws \Exception
     */
    public function dispatch()
    {
        $messages = $this->application->getMessagesIterator();

        try {
            while ($messages->valid()) {
                $message = $messages->current();
                if ($this->notificationBuilder->buildNotifications($message)) {
                    $messages->offsetUnset($message->getMessageIdentifier());
                }
                $messages->next();
            }

            $this->sendNotifications();

        } catch (ClientException $e) {
            $this->logger->error(
                sprintf("Client connection error: %s", $e->getMessage())
            );
            return;

        } catch (RuntimeException $e) {
            $this->logger->error(
                sprintf("Runtime error: %s", $e->getMessage())
            );
            return;

        } catch (\Exception $e) {
            $this->logger->error(
                sprintf("Error occurs: %s", $e->getMessage())
            );
            return;
        }
    }

    /**
     * Tries to connect and load feedback data
     *
     * @return $this
     * @throws RuntimeException
     * @throws \Exception
     */
    public function loadFeedback()
    {
        $serviceName = NotificationServices::APPLE_PUSH_NOTIFICATIONS_SERVICE;

        try {
            $this->logger->info(sprintf("Querying the feedback service '%s'", $serviceName));

            $connection = $this->createFeedbackConnection($serviceName);
            $invalidRecipients = $connection->sendRequest();

            while ($invalidRecipients->valid()) {
                $recipient = $invalidRecipients->current();
                $this->application->addInvalidRecipient($serviceName, $recipient);
                $invalidRecipients->next();
            }

        } catch (RuntimeException $e) {
            $this->logger->error(
                sprintf("Runtime error while acquiring feedback: %s", $e->getMessage())
            );

        } catch (\Exception $e) {
            $this->logger->error(
                sprintf("Error occurs while acquiring feedback: %s", $e->getMessage())
            );
        }

        return $this;
    }
}