Dispatcher::sendNotification() - Code Metrics - zbox/UnifiedPush - Measure and Improve Code Quality continuously with Scrutinizer

Dispatcher::sendNotification() B
last analyzed 2016-09-29 17:57 UTC

↳ Parent: Dispatcher

Complexity

Conditions	4
Paths	13

Size

Total Lines	40
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	40
rs	8.5806
c	0
b	0
f	0
cc	4
eloc	24
nc	13
nop	1

<?php

/*
 * (c) Alexander Zhukov <[email protected]>
 *
 * 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;
use Zbox\UnifiedPush\Message\MessageCollection;
use Zbox\UnifiedPush\Notification\Notification;
use Zbox\UnifiedPush\Notification\NotificationBuilder;
use Zbox\UnifiedPush\NotificationService\NotificationServices,
    Zbox\UnifiedPush\NotificationService\ServiceClientInterface,
    Zbox\UnifiedPush\NotificationService\ServiceClientFactory,
    Zbox\UnifiedPush\NotificationService\ResponseHandler;
use 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 array
     */
    private $connectionPool;

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

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

    /**
     * @var ResponseHandler
     */
    private $responseHandler;

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

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

        $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;
    }

    /**
     * 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)
    {
        $connection = $this->clientFactory->createServiceClient($serviceName);
        $this->connectionPool[$serviceName] = $connection;

        return $this;
    }

    /**
     * Creates a feedback service connection
     *
     * @param string $serviceName
     * @return ServiceClientInterface
     */
    public function initFeedbackConnection($serviceName)
    {
        return $this->clientFactory->createServiceClient($serviceName, true);
    }

    /**
     * @return ResponseHandler
     */
    public function getResponseHandler()
    {
        return $this->responseHandler;
    }

    /**
     * Build notification and send it to notification service
     *
     * @param MessageInterface $message
     * @return $this
     */
    public function dispatch(MessageInterface $message)
    {
        $builder = $this->notificationBuilder;

        $notifications = $builder->buildNotifications($message);

        /** @var Notification $notification */
        foreach ($notifications as $notification) {
            $this->sendNotification($notification);
        }

        return $this;
    }

    /**
     * Tries to dispatch all messages to notification service
     *
     * @param MessageCollection $messages
     * @return $this
     */
    public function dispatchAll(MessageCollection $messages)
    {
        $collection = $messages->getMessageCollection();

        while ($collection->valid()) {
            $message = $collection->current();
            $this->dispatch($message);
            $collection->next();
        }

        return $this;
    }

    /**
     * Tries to connect and send a notification
     *
     * @param Notification $notification
     * @return bool
     */
    public function sendNotification(Notification $notification)
    {
        try {
            $connection = $this->getConnection($notification->getType());
            $connection->setNotification($notification);

            $this->logger->info(
                sprintf(
                    "Dispatching notification id: %s",
                    $notification->getIdentifier()
                )
            );

            $this
                ->responseHandler
                ->addIdentifiedResponse(
                    $notification->getIdentifier(),
                    $connection->sendRequest()
                );

            return true;

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

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

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

        return false;
    }

    /**
     * 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->initFeedbackConnection($serviceName);

            $this
                ->responseHandler
                ->addResponse(
                    $connection->sendRequest()
                );

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


1			<?php
2
3			/*
4			* (c) Alexander Zhukov <[email protected]>
5			*
6			* For the full copyright and license information, please view the LICENSE
7			* file that was distributed with this source code.
8			*/
9
10			namespace Zbox\UnifiedPush;
11
12			use Zbox\UnifiedPush\Message\MessageInterface;
13			use Zbox\UnifiedPush\Message\MessageCollection;
14			use Zbox\UnifiedPush\Notification\Notification;
15			use Zbox\UnifiedPush\Notification\NotificationBuilder;
16			use Zbox\UnifiedPush\NotificationService\NotificationServices,
17			Zbox\UnifiedPush\NotificationService\ServiceClientInterface,
18			Zbox\UnifiedPush\NotificationService\ServiceClientFactory,
19			Zbox\UnifiedPush\NotificationService\ResponseHandler;
20			use Zbox\UnifiedPush\Exception\ClientException,
21			Zbox\UnifiedPush\Exception\RuntimeException;
22			use Psr\Log\LoggerAwareInterface,
23			Psr\Log\LoggerInterface,
24			Psr\Log\NullLogger;
25
26			/**
27			* Class Dispatcher
28			* @package Zbox\UnifiedPush
29			*/
30			class Dispatcher implements LoggerAwareInterface
31			{
32			/**
33			* @var array
34			*/
35			private $connectionPool;
36
37			/**
38			* @var ServiceClientFactory
39			*/
40			private $clientFactory;
41
42			/**
43			* @var NotificationBuilder
44			*/
45			private $notificationBuilder;
46
47			/**
48			* @var ResponseHandler
49			*/
50			private $responseHandler;
51
52			/**
53			* @var LoggerInterface
54			*/
55			private $logger;
56
57			/**
58			* @param ServiceClientFactory $clientFactory
59			* @param NotificationBuilder $notificationBuilder
60			* @param ResponseHandler $responseHandler
61			*/
62			public function __construct(
63			ServiceClientFactory $clientFactory,
64			NotificationBuilder $notificationBuilder,
65			ResponseHandler $responseHandler
66			){
67			$this->clientFactory = $clientFactory;
68			$this->notificationBuilder = $notificationBuilder;
69			$this->responseHandler = $responseHandler;
70
71			$this->setLogger(new NullLogger());
72			}
73
74			/**
75			* @param LoggerInterface $logger
76			* @return $this
77			*/
78			public function setLogger(LoggerInterface $logger)
79			{
80			$this->logger = $logger;
81			return $this;
82			}
83
84			/**
85			* @param bool $isDevelopment
86			* @return $this
87			*/
88			public function setDevelopmentMode($isDevelopment)
89			{
90			$this->clientFactory->setDevelopmentMode($isDevelopment);
91			return $this;
92			}
93
94			/**
95			* Gets a service client connection by service name
96			*
97			* @param string $serviceName
98			* @return ServiceClientInterface
99			*/
100			public function getConnection($serviceName)
101			{
102			if (empty($this->connectionPool[$serviceName])) {
103			$this->initConnection($serviceName);
104			}
105
106			return $this->connectionPool[$serviceName];
107			}
108
109			/**
110			* Initialize service client connection by service name
111			*
112			* @param string $serviceName
113			* @return $this
114			*/
115			public function initConnection($serviceName)
116			{
117			$connection = $this->clientFactory->createServiceClient($serviceName);
118			$this->connectionPool[$serviceName] = $connection;
119
120			return $this;
121			}
122
123			/**
124			* Creates a feedback service connection
125			*
126			* @param string $serviceName
127			* @return ServiceClientInterface
128			*/
129			public function initFeedbackConnection($serviceName)
130			{
131			return $this->clientFactory->createServiceClient($serviceName, true);
132			}
133
134			/**
135			* @return ResponseHandler
136			*/
137			public function getResponseHandler()
138			{
139			return $this->responseHandler;
140			}
141
142			/**
143			* Build notification and send it to notification service
144			*
145			* @param MessageInterface $message
146			* @return $this
147			*/
148			public function dispatch(MessageInterface $message)
149			{
150			$builder = $this->notificationBuilder;
151
152			$notifications = $builder->buildNotifications($message);
153
154			/** @var Notification $notification */
155			foreach ($notifications as $notification) {
156			$this->sendNotification($notification);
157			}
158
159			return $this;
160			}
161
162			/**
163			* Tries to dispatch all messages to notification service
164			*
165			* @param MessageCollection $messages
166			* @return $this
167			*/
168			public function dispatchAll(MessageCollection $messages)
169			{
170			$collection = $messages->getMessageCollection();
171
172			while ($collection->valid()) {
173			$message = $collection->current();
174			$this->dispatch($message);
175			$collection->next();
176			}
177
178			return $this;
179			}
180
181			/**
182			* Tries to connect and send a notification
183			*
184			* @param Notification $notification
185			* @return bool
186			*/
187			public function sendNotification(Notification $notification)
188			{
189			try {
190			$connection = $this->getConnection($notification->getType());
191			$connection->setNotification($notification);
192
193			$this->logger->info(
194			sprintf(
195			"Dispatching notification id: %s",
196			$notification->getIdentifier()
197			)
198			);
199
200			$this
201			->responseHandler
202			->addIdentifiedResponse(
203			$notification->getIdentifier(),
204			$connection->sendRequest()
205			);
206
207			return true;
208
209			} catch (ClientException $e) {
210			$this->logger->error(
211			sprintf("Client connection error: %s", $e->getMessage())
212			);
213
214			} catch (RuntimeException $e) {
215			$this->logger->error(
216			sprintf("Runtime error: %s", $e->getMessage())
217			);
218
219			} catch (\Exception $e) {
220			$this->logger->error(
221			sprintf("Error occurs: %s", $e->getMessage())
222			);
223			}
224
225			return false;
226			}
227
228			/**
229			* Tries to connect and load feedback data
230			*
231			* @return $this
232			* @throws RuntimeException
233			* @throws \Exception
234			*/
235			public function loadFeedback()
236			{
237			$serviceName = NotificationServices::APPLE_PUSH_NOTIFICATIONS_SERVICE;
238
239			try {
240			$this->logger->info(sprintf("Querying the feedback service '%s'", $serviceName));
241
242			$connection = $this->initFeedbackConnection($serviceName);
243
244			$this
245			->responseHandler
246			->addResponse(
247			$connection->sendRequest()
248			);
249
250			} catch (RuntimeException $e) {
251			$this->logger->error(
252			sprintf("Runtime error while acquiring feedback: %s", $e->getMessage())
253			);
254
255			} catch (\Exception $e) {
256			$this->logger->error(
257			sprintf("Error occurs while acquiring feedback: %s", $e->getMessage())
258			);
259			}
260
261			return $this;
262			}
263			}
264

zbox / UnifiedPush

GitHub Access Token became invalid

Dispatcher::sendNotification() B last analyzed 2016-09-29 17:57 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Dispatcher::sendNotification() B
last analyzed 2016-09-29 17:57 UTC