GcmAdapter::getErrorCodeFromException() - Code Metrics - juliangut/tify - Measure and Improve Code Quality continuously with Scrutinizer

GcmAdapter::getErrorCodeFromException() B
last analyzed 2016-09-21 09:44 UTC

↳ Parent: GcmAdapter

Complexity

Conditions	6
Paths	6

Size

Total Lines	26
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	26
rs	8.439
c	0
b	0
f	0
cc	6
eloc	13
nc	6
nop	1

<?php
/**
 * Push notification services abstraction (http://github.com/juliangut/tify)
 *
 * @link https://github.com/juliangut/tify for the canonical source repository
 *
 * @license https://github.com/juliangut/tify/blob/master/LICENSE
 */

namespace Jgut\Tify\Adapter\Gcm;

use Jgut\Tify\Adapter\AbstractAdapter;
use Jgut\Tify\Adapter\PushAdapter;
use Jgut\Tify\Notification;
use Jgut\Tify\Receiver\GcmReceiver;
use Jgut\Tify\Result;
use ZendService\Google\Exception\RuntimeException as GcmRuntimeException;

/**
 * Class GcmAdapter
 */
class GcmAdapter extends AbstractAdapter implements PushAdapter
{
    const RESPONSE_OK = 'OK';
    const RESPONSE_MISSING_REGISTRATION = 'MissingRegistration';
    const RESPONSE_INVALID_REGISTRATION = 'InvalidRegistration';
    const RESPONSE_NOT_REGISTERED = 'NotRegistered';
    const RESPONSE_INVALID_PACKAGE_NAME = 'InvalidPackageName';
    const RESPONSE_MISMATCH_SENDER_ID = 'MismatchSenderId';
    const RESPONSE_MESSAGE_TOO_BIG = 'MessageTooBig';
    const RESPONSE_INVALID_DATA_KEY = 'InvalidDataKey';
    const RESPONSE_INVALID_TTL = 'InvalidTtl';
    const RESPONSE_TIMEOUT = 'Timeout';
    const RESPONSE_INTERNAL_SERVER_ERROR = 'InternalServerError';
    const RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED = 'DeviceMessageRateExceeded';
    const RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED = 'TopicsMessageRateExceeded';
    const RESPONSE_SERVER_UNAVAILABLE = 'ServerUnavailable';
    const RESPONSE_AUTHENTICATION_ERROR = 'AuthenticationError';
    const RESPONSE_INVALID_MESSAGE = 'InvalidMessage';
    const RESPONSE_BADLY_FORMATTED_RESPONSE = 'BadlyFormattedResponse';
    const RESPONSE_UNKNOWN_ERROR = 'Unknown';

    /**
     * Status codes mapping.
     *
     * @var array
     */
    protected static $statusCodes = [
        self::RESPONSE_OK => Result::STATUS_SUCCESS,

        self::RESPONSE_MISSING_REGISTRATION => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_INVALID_PACKAGE_NAME => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_MISMATCH_SENDER_ID => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_MESSAGE_TOO_BIG => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_INVALID_DATA_KEY => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_INVALID_TTL => Result::STATUS_INVALID_MESSAGE,
        self::RESPONSE_INVALID_MESSAGE => Result::STATUS_INVALID_MESSAGE,

        self::RESPONSE_INVALID_REGISTRATION => Result::STATUS_INVALID_DEVICE,
        self::RESPONSE_NOT_REGISTERED => Result::STATUS_INVALID_DEVICE,

        self::RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED => Result::STATUS_RATE_ERROR,
        self::RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED => Result::STATUS_RATE_ERROR,

        self::RESPONSE_AUTHENTICATION_ERROR => Result::STATUS_AUTH_ERROR,

        self::RESPONSE_TIMEOUT => Result::STATUS_SERVER_ERROR,
        self::RESPONSE_INTERNAL_SERVER_ERROR => Result::STATUS_SERVER_ERROR,
        self::RESPONSE_SERVER_UNAVAILABLE => Result::STATUS_SERVER_ERROR,
        self::RESPONSE_BADLY_FORMATTED_RESPONSE => Result::STATUS_SERVER_ERROR,

        self::RESPONSE_UNKNOWN_ERROR => Result::STATUS_UNKNOWN_ERROR,
    ];

    /**
     * Status messages mapping.
     *
     * @see https://developers.google.com/cloud-messaging/http-server-ref
     *
     * @var array
     */
    protected static $statusMessages = [
        self::RESPONSE_OK => 'OK',

        self::RESPONSE_MISSING_REGISTRATION => 'Missing Registration Token',
        self::RESPONSE_INVALID_PACKAGE_NAME => 'Invalid Package Name',
        self::RESPONSE_MISMATCH_SENDER_ID => 'Mismatched Sender',
        self::RESPONSE_MESSAGE_TOO_BIG => 'Message Too Big',
        self::RESPONSE_INVALID_DATA_KEY => 'Invalid Data Key',
        self::RESPONSE_INVALID_TTL => 'Invalid Time to Live',
        self::RESPONSE_INVALID_MESSAGE => 'Invalid message',

        self::RESPONSE_INVALID_REGISTRATION => 'Invalid Registration Token',
        self::RESPONSE_NOT_REGISTERED => 'Unregistered Device',

        self::RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED => 'Device Message Rate Exceeded',
        self::RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED => 'Topics Message Rate Exceeded',

        self::RESPONSE_AUTHENTICATION_ERROR => 'Authentication Error',

        self::RESPONSE_TIMEOUT => 'Timeout',
        self::RESPONSE_INTERNAL_SERVER_ERROR => 'Internal Server Error',
        self::RESPONSE_SERVER_UNAVAILABLE => 'Server Unavailable',
        self::RESPONSE_BADLY_FORMATTED_RESPONSE => 'Bad Formatted Response',

        self::RESPONSE_UNKNOWN_ERROR => 'Unknown Error',
    ];

    /**
     * GCM service builder.
     *
     * @var \Jgut\Tify\Adapter\Gcm\GcmBuilder
     */
    protected $builder;

    /**
     * @var \ZendService\Google\Gcm\Client
     */
    protected $pushClient;

    /**
     * @param array                                  $parameters
     * @param \Jgut\Tify\Adapter\Gcm\GcmBuilder|null $builder
     *
     * @throws \Jgut\Tify\Exception\AdapterException
     */
    public function __construct(array $parameters = [], GcmBuilder $builder = null)
    {
        parent::__construct($parameters, false);

        // @codeCoverageIgnoreStart
        if ($builder === null) {
            $builder = new GcmBuilder;
        }
        // @codeCoverageIgnoreEnd
        $this->builder = $builder;
    }

    /**
     * {@inheritdoc}
     *
     * @throws \InvalidArgumentException
     * @throws \ZendService\Google\Exception\InvalidArgumentException
     * @throws \ZendService\Google\Exception\RuntimeException
     */
    public function push(Notification $notification)
    {
        $client = $this->getPushClient();

        $pushResults = [];

        /* @var \ZendService\Google\Gcm\Message $message */
        foreach ($this->getPushMessages($notification) as $message) {
            $date = new \DateTime('now', new \DateTimeZone('UTC'));

            try {
                $pushResponses = $client->send($message)->getResults();

                foreach ($message->getRegistrationIds() as $token) {
                    $statusCode = self::RESPONSE_OK;

                    if (!array_key_exists($token, $pushResponses)) {
                        $statusCode = self::RESPONSE_UNKNOWN_ERROR;
                    } elseif (array_key_exists('error', $pushResponses[$token])) {
                        $statusCode = $pushResponses[$token]['error'];
                    }

                    $pushResults[] = new Result(
                        $token,
                        $date,
                        self::$statusCodes[$statusCode],
                        self::$statusMessages[$statusCode]
                    );
                }
            // @codeCoverageIgnoreStart
            } catch (GcmRuntimeException $exception) {
                $statusCode = $this->getErrorCodeFromException($exception);

                foreach ($message->getRegistrationIds() as $token) {
                    $pushResults[] = new Result(
                        $token,
                        $date,
                        self::$statusCodes[$statusCode],
                        self::$statusMessages[$statusCode]
                    );
                }
            }
            // @codeCoverageIgnoreEnd
        }

        return $pushResults;
    }

    /**
     * Get opened client.
     *
     * @return \ZendService\Google\Gcm\Client
     */
    protected function getPushClient()
    {
        if ($this->pushClient === null) {
            $this->pushClient = $this->builder->buildPushClient($this->getParameter('api_key'));
        }

        return $this->pushClient;
    }

    /**
     * Get service formatted push messages.
     *
     * @param \Jgut\Tify\Notification $notification
     *
     * @throws \ZendService\Google\Exception\InvalidArgumentException
     * @throws \ZendService\Google\Exception\RuntimeException
     *
     * @return \Generator
     */
    protected function getPushMessages(Notification $notification)
    {
        foreach (array_chunk($notification->getReceivers(), 100) as $receivers) {
            $tokens = array_map(
                function ($receiver) {
                    return $receiver instanceof GcmReceiver ? $receiver->getToken() : null;
                },
                $receivers
            );

            yield $this->builder->buildPushMessage(array_filter($tokens), $notification);
        }
    }

    /**
     * Extract error code from exception.
     *
     * @param \ZendService\Google\Exception\RuntimeException $exception
     *
     * @return string
     */
    protected function getErrorCodeFromException(GcmRuntimeException $exception)
    {
        $message = $exception->getMessage();

        if (preg_match('/^500 Internal Server Error/', $message)) {
            return self::RESPONSE_INTERNAL_SERVER_ERROR;
        }

        if (preg_match('/^503 Server Unavailable/', $message)) {
            return self::RESPONSE_SERVER_UNAVAILABLE;
        }

        if (preg_match('/^400 Bad Request/', $message)) {
            return self::RESPONSE_INVALID_MESSAGE;
        }

        if (preg_match('/^401 Forbidden/', $message)) {
            return self::RESPONSE_AUTHENTICATION_ERROR;
        }

        if (preg_match('/^Response body did not contain a valid JSON response$/', $message)) {
            return self::RESPONSE_BADLY_FORMATTED_RESPONSE;
        }

        return self::RESPONSE_UNKNOWN_ERROR;
    }

    /**
     * {@inheritdoc}
     */
    protected function getDefinedParameters()
    {
        return ['api_key'];
    }

    /**
     * {@inheritdoc}
     */
    protected function getRequiredParameters()
    {
        return ['api_key'];
    }
}


1			<?php
2			/**
3			* Push notification services abstraction (http://github.com/juliangut/tify)
4			*
5			* @link https://github.com/juliangut/tify for the canonical source repository
6			*
7			* @license https://github.com/juliangut/tify/blob/master/LICENSE
8			*/
9
10			namespace Jgut\Tify\Adapter\Gcm;
11
12			use Jgut\Tify\Adapter\AbstractAdapter;
13			use Jgut\Tify\Adapter\PushAdapter;
14			use Jgut\Tify\Notification;
15			use Jgut\Tify\Receiver\GcmReceiver;
16			use Jgut\Tify\Result;
17			use ZendService\Google\Exception\RuntimeException as GcmRuntimeException;
18
19			/**
20			* Class GcmAdapter
21			*/
22			class GcmAdapter extends AbstractAdapter implements PushAdapter
23			{
24			const RESPONSE_OK = 'OK';
25			const RESPONSE_MISSING_REGISTRATION = 'MissingRegistration';
26			const RESPONSE_INVALID_REGISTRATION = 'InvalidRegistration';
27			const RESPONSE_NOT_REGISTERED = 'NotRegistered';
28			const RESPONSE_INVALID_PACKAGE_NAME = 'InvalidPackageName';
29			const RESPONSE_MISMATCH_SENDER_ID = 'MismatchSenderId';
30			const RESPONSE_MESSAGE_TOO_BIG = 'MessageTooBig';
31			const RESPONSE_INVALID_DATA_KEY = 'InvalidDataKey';
32			const RESPONSE_INVALID_TTL = 'InvalidTtl';
33			const RESPONSE_TIMEOUT = 'Timeout';
34			const RESPONSE_INTERNAL_SERVER_ERROR = 'InternalServerError';
35			const RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED = 'DeviceMessageRateExceeded';
36			const RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED = 'TopicsMessageRateExceeded';
37			const RESPONSE_SERVER_UNAVAILABLE = 'ServerUnavailable';
38			const RESPONSE_AUTHENTICATION_ERROR = 'AuthenticationError';
39			const RESPONSE_INVALID_MESSAGE = 'InvalidMessage';
40			const RESPONSE_BADLY_FORMATTED_RESPONSE = 'BadlyFormattedResponse';
41			const RESPONSE_UNKNOWN_ERROR = 'Unknown';
42
43			/**
44			* Status codes mapping.
45			*
46			* @var array
47			*/
48			protected static $statusCodes = [
49			self::RESPONSE_OK => Result::STATUS_SUCCESS,
50
51			self::RESPONSE_MISSING_REGISTRATION => Result::STATUS_INVALID_MESSAGE,
52			self::RESPONSE_INVALID_PACKAGE_NAME => Result::STATUS_INVALID_MESSAGE,
53			self::RESPONSE_MISMATCH_SENDER_ID => Result::STATUS_INVALID_MESSAGE,
54			self::RESPONSE_MESSAGE_TOO_BIG => Result::STATUS_INVALID_MESSAGE,
55			self::RESPONSE_INVALID_DATA_KEY => Result::STATUS_INVALID_MESSAGE,
56			self::RESPONSE_INVALID_TTL => Result::STATUS_INVALID_MESSAGE,
57			self::RESPONSE_INVALID_MESSAGE => Result::STATUS_INVALID_MESSAGE,
58
59			self::RESPONSE_INVALID_REGISTRATION => Result::STATUS_INVALID_DEVICE,
60			self::RESPONSE_NOT_REGISTERED => Result::STATUS_INVALID_DEVICE,
61
62			self::RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED => Result::STATUS_RATE_ERROR,
63			self::RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED => Result::STATUS_RATE_ERROR,
64
65			self::RESPONSE_AUTHENTICATION_ERROR => Result::STATUS_AUTH_ERROR,
66
67			self::RESPONSE_TIMEOUT => Result::STATUS_SERVER_ERROR,
68			self::RESPONSE_INTERNAL_SERVER_ERROR => Result::STATUS_SERVER_ERROR,
69			self::RESPONSE_SERVER_UNAVAILABLE => Result::STATUS_SERVER_ERROR,
70			self::RESPONSE_BADLY_FORMATTED_RESPONSE => Result::STATUS_SERVER_ERROR,
71
72			self::RESPONSE_UNKNOWN_ERROR => Result::STATUS_UNKNOWN_ERROR,
73			];
74
75			/**
76			* Status messages mapping.
77			*
78			* @see https://developers.google.com/cloud-messaging/http-server-ref
79			*
80			* @var array
81			*/
82			protected static $statusMessages = [
83			self::RESPONSE_OK => 'OK',
84
85			self::RESPONSE_MISSING_REGISTRATION => 'Missing Registration Token',
86			self::RESPONSE_INVALID_PACKAGE_NAME => 'Invalid Package Name',
87			self::RESPONSE_MISMATCH_SENDER_ID => 'Mismatched Sender',
88			self::RESPONSE_MESSAGE_TOO_BIG => 'Message Too Big',
89			self::RESPONSE_INVALID_DATA_KEY => 'Invalid Data Key',
90			self::RESPONSE_INVALID_TTL => 'Invalid Time to Live',
91			self::RESPONSE_INVALID_MESSAGE => 'Invalid message',
92
93			self::RESPONSE_INVALID_REGISTRATION => 'Invalid Registration Token',
94			self::RESPONSE_NOT_REGISTERED => 'Unregistered Device',
95
96			self::RESPONSE_DEVICE_MESSAGE_RATE_EXCEEDED => 'Device Message Rate Exceeded',
97			self::RESPONSE_TOPIC_MESSAGE_RATE_EXCEEDED => 'Topics Message Rate Exceeded',
98
99			self::RESPONSE_AUTHENTICATION_ERROR => 'Authentication Error',
100
101			self::RESPONSE_TIMEOUT => 'Timeout',
102			self::RESPONSE_INTERNAL_SERVER_ERROR => 'Internal Server Error',
103			self::RESPONSE_SERVER_UNAVAILABLE => 'Server Unavailable',
104			self::RESPONSE_BADLY_FORMATTED_RESPONSE => 'Bad Formatted Response',
105
106			self::RESPONSE_UNKNOWN_ERROR => 'Unknown Error',
107			];
108
109			/**
110			* GCM service builder.
111			*
112			* @var \Jgut\Tify\Adapter\Gcm\GcmBuilder
113			*/
114			protected $builder;
115
116			/**
117			* @var \ZendService\Google\Gcm\Client
118			*/
119			protected $pushClient;
120
121			/**
122			* @param array $parameters
123			* @param \Jgut\Tify\Adapter\Gcm\GcmBuilder\|null $builder
124			*
125			* @throws \Jgut\Tify\Exception\AdapterException
126			*/
127			public function __construct(array $parameters = [], GcmBuilder $builder = null)
128			{
129			parent::__construct($parameters, false);
130
131			// @codeCoverageIgnoreStart
132			if ($builder === null) {
133			$builder = new GcmBuilder;
134			}
135			// @codeCoverageIgnoreEnd
136			$this->builder = $builder;
137			}
138
139			/**
140			* {@inheritdoc}
141			*
142			* @throws \InvalidArgumentException
143			* @throws \ZendService\Google\Exception\InvalidArgumentException
144			* @throws \ZendService\Google\Exception\RuntimeException
145			*/
146			public function push(Notification $notification)
147			{
148			$client = $this->getPushClient();
149
150			$pushResults = [];
151
152			/* @var \ZendService\Google\Gcm\Message $message */
153			foreach ($this->getPushMessages($notification) as $message) {
154			$date = new \DateTime('now', new \DateTimeZone('UTC'));
155
156			try {
157			$pushResponses = $client->send($message)->getResults();
158
159			foreach ($message->getRegistrationIds() as $token) {
160			$statusCode = self::RESPONSE_OK;
161
162			if (!array_key_exists($token, $pushResponses)) {
163			$statusCode = self::RESPONSE_UNKNOWN_ERROR;
164			} elseif (array_key_exists('error', $pushResponses[$token])) {
165			$statusCode = $pushResponses[$token]['error'];
166			}
167
168			$pushResults[] = new Result(
169			$token,
170			$date,
171			self::$statusCodes[$statusCode],
172			self::$statusMessages[$statusCode]
173			);
174			}
175			// @codeCoverageIgnoreStart
176			} catch (GcmRuntimeException $exception) {
177			$statusCode = $this->getErrorCodeFromException($exception);
178
179			foreach ($message->getRegistrationIds() as $token) {
180			$pushResults[] = new Result(
181			$token,
182			$date,
183			self::$statusCodes[$statusCode],
184			self::$statusMessages[$statusCode]
185			);
186			}
187			}
188			// @codeCoverageIgnoreEnd
189			}
190
191			return $pushResults;
192			}
193
194			/**
195			* Get opened client.
196			*
197			* @return \ZendService\Google\Gcm\Client
198			*/
199			protected function getPushClient()
200			{
201			if ($this->pushClient === null) {
202			$this->pushClient = $this->builder->buildPushClient($this->getParameter('api_key'));
203			}
204
205			return $this->pushClient;
206			}
207
208			/**
209			* Get service formatted push messages.
210			*
211			* @param \Jgut\Tify\Notification $notification
212			*
213			* @throws \ZendService\Google\Exception\InvalidArgumentException
214			* @throws \ZendService\Google\Exception\RuntimeException
215			*
216			* @return \Generator
217			*/
218			protected function getPushMessages(Notification $notification)
219			{
220			foreach (array_chunk($notification->getReceivers(), 100) as $receivers) {
221			$tokens = array_map(
222			function ($receiver) {
223			return $receiver instanceof GcmReceiver ? $receiver->getToken() : null;
224			},
225			$receivers
226			);
227
228			yield $this->builder->buildPushMessage(array_filter($tokens), $notification);
229			}
230			}
231
232			/**
233			* Extract error code from exception.
234			*
235			* @param \ZendService\Google\Exception\RuntimeException $exception
236			*
237			* @return string
238			*/
239			protected function getErrorCodeFromException(GcmRuntimeException $exception)
240			{
241			$message = $exception->getMessage();
242
243			if (preg_match('/^500 Internal Server Error/', $message)) {
244			return self::RESPONSE_INTERNAL_SERVER_ERROR;
245			}
246
247			if (preg_match('/^503 Server Unavailable/', $message)) {
248			return self::RESPONSE_SERVER_UNAVAILABLE;
249			}
250
251			if (preg_match('/^400 Bad Request/', $message)) {
252			return self::RESPONSE_INVALID_MESSAGE;
253			}
254
255			if (preg_match('/^401 Forbidden/', $message)) {
256			return self::RESPONSE_AUTHENTICATION_ERROR;
257			}
258
259			if (preg_match('/^Response body did not contain a valid JSON response$/', $message)) {
260			return self::RESPONSE_BADLY_FORMATTED_RESPONSE;
261			}
262
263			return self::RESPONSE_UNKNOWN_ERROR;
264			}
265
266			/**
267			* {@inheritdoc}
268			*/
269			protected function getDefinedParameters()
270			{
271			return ['api_key'];
272			}
273
274			/**
275			* {@inheritdoc}
276			*/
277			protected function getRequiredParameters()
278			{
279			return ['api_key'];
280			}
281			}
282

juliangut / tify

GcmAdapter::getErrorCodeFromException() B last analyzed 2016-09-21 09:44 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GcmAdapter::getErrorCodeFromException() B
last analyzed 2016-09-21 09:44 UTC