Application::addMessage() - Code Metrics - Inspection of "ServiceClient credentials abstraction" - zbox/UnifiedPush - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 15375f...2893b6 )

by Alexander

created 2016-03-27 19:44 UTC

Application::addMessage() A

↳ Parent: Application

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	1
eloc	4
nc	1
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,
    Zbox\UnifiedPush\Message\RecipientDevice;
use Zbox\UnifiedPush\NotificationService\NotificationServices;
use Zbox\UnifiedPush\Utils\ClientCredentials\CredentialsMapper;
use Zbox\UnifiedPush\Exception\DomainException,
    Zbox\UnifiedPush\Exception\InvalidArgumentException;

/**
 * Class Application
 * @package Zbox\UnifiedPush
 */
class Application
{
    /**
     * @var CredentialsMapper
     */
    private $credentialsMapper;

    /**
     * @var string
     */
    private $credentialsFilePath;

    /**
     * @var string
     */
    private $applicationName;

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

    /**
     * @var \ArrayObject
     */
    private $messages;

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

    /**
     * @param string $applicationName
     * @param CredentialsMapper $credentialsMapper
     */
    public function __construct($applicationName, CredentialsMapper $credentialsMapper)
    {
        $this->setApplicationName($applicationName);
        $this->credentialsMapper = $credentialsMapper;
        $this->messages = new \ArrayObject();

        return $this;
    }

    /**
     * Returns path to application-based notification services credentials
     *
     * @return string
     */
    public function getCredentialsFilePath()
    {
        if (!file_exists($this->credentialsFilePath)) {
            throw new InvalidArgumentException(
                sprintf(
                    "Application credentials file '%s' not exists",
                    $this->credentialsFilePath
                )
            );
        }
        return $this->credentialsFilePath;
    }

    /**
     * @param string $filePath
     * @return $this
     */
    public function setCredentialsFilePath($filePath)
    {
        $this->credentialsFilePath = $filePath;
        return $this;
    }

    /**
     * @return string
     */
    public function getApplicationName()
    {
        return $this->applicationName;
    }

    /**
     * @param string $applicationName
     * @return $this
     */
    public function setApplicationName($applicationName)
    {
        $this->applicationName = $applicationName;
        return $this;
    }

    /**
     * Gets an iterator from an ArrayObject instance
     *
     * @return \ArrayIterator
     */
    public function getMessagesIterator()
    {
        return $this->messages->getIterator();
    }

    /**
     * Adds a message to collection
     *
     * @param MessageInterface $message
     * @return $this
     */
    public function addMessage(MessageInterface $message)
    {
        $messageId = $message->getMessageIdentifier();
        $this->messages->offsetSet($messageId, $message);
        return $this;
    }

    /**
     * Removes the given message from collection
     *
     * @param MessageInterface $message
     * @return $this
     */
    public function unsetMessage(MessageInterface $message)
    {
        $messageId = $message->getMessageIdentifier();
        $this->messages->offsetUnset($messageId);
        return $this;
    }

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

    /**
     * Adds a invalid recipient to collection
     *
     * @param string $serviceName
     * @param RecipientDevice|string $recipient
     * @return $this
     */
    public function addInvalidRecipient($serviceName, $recipient)
    {
        if (!in_array($serviceName, $this->getInitializedServices())) {
            throw new DomainException(
                sprintf("Recipient of an unsupported service '%s'", $serviceName)
            );
        }

        if (is_string($recipient)) {
            $messageClassName = 'Zbox\UnifiedPush\Message\Type\\' . $serviceName;
            $recipient        = new RecipientDevice($recipient, $messageClassName());

            $recipient->setIdentifierStatus(RecipientDevice::DEVICE_NOT_REGISTERED);
        }

        $this->invalidRecipients->append($recipient);

        return $this;
    }

    /**
     * Returns the list of names of notification services available for the application
     *
     * @return array
     */
    public function getInitializedServices()
    {
        return array_keys($this->config);
    }

    /**
     * Returns credentials for notification service
     *
     * @param string $serviceName
     * @throws DomainException
     * @return array
     */
    public function getCredentialsByService($serviceName)
    {
        if ($this->getApplicationName() && empty($this->config)) {
            $this->loadApplicationConfig();
        }

        if (!in_array($serviceName, $this->getInitializedServices())) {
            throw new DomainException(
                sprintf("Credentials for service '%s' was not initialized", $serviceName)
            );
        }

        $credentials = NotificationServices::getCredentialsTypeByService($serviceName);

        return
            $this
                ->credentialsMapper
                ->mapCredentials(
                    $credentials,
                    $this->config[$serviceName]
                )
            ;
    }

    /**
     * Load sender`s notification services credentials by application name
     *
     * @return $this
     * @throws DomainException
     */
    public function loadApplicationConfig()
    {
        $configFilePath = $this->getCredentialsFilepath();
        $applicationsConfig = json_decode(file_get_contents($configFilePath), true);

        $applicationName = $this->getApplicationName();

        if (!array_key_exists($applicationName, $applicationsConfig)) {
            throw new DomainException(
                sprintf("Application '%s' is not defined.", $applicationName)
            );
        }
        $this->config = $applicationsConfig[$applicationName];

        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			Zbox\UnifiedPush\Message\RecipientDevice;
14			use Zbox\UnifiedPush\NotificationService\NotificationServices;
15			use Zbox\UnifiedPush\Utils\ClientCredentials\CredentialsMapper;
16			use Zbox\UnifiedPush\Exception\DomainException,
17			Zbox\UnifiedPush\Exception\InvalidArgumentException;
18
19			/**
20			* Class Application
21			* @package Zbox\UnifiedPush
22			*/
23			class Application
24			{
25			/**
26			* @var CredentialsMapper
27			*/
28			private $credentialsMapper;
29
30			/**
31			* @var string
32			*/
33			private $credentialsFilePath;
34
35			/**
36			* @var string
37			*/
38			private $applicationName;
39
40			/**
41			* @var array
42			*/
43			private $config;
44
45			/**
46			* @var \ArrayObject
47			*/
48			private $messages;
49
50			/**
51			* @var \ArrayIterator
52			*/
53			private $invalidRecipients;
54
55			/**
56			* @param string $applicationName
57			* @param CredentialsMapper $credentialsMapper
58			*/
59			public function __construct($applicationName, CredentialsMapper $credentialsMapper)
60			{
61			$this->setApplicationName($applicationName);
62			$this->credentialsMapper = $credentialsMapper;
63			$this->messages = new \ArrayObject();
64
65			return $this;
66			}
67
68			/**
69			* Returns path to application-based notification services credentials
70			*
71			* @return string
72			*/
73			public function getCredentialsFilePath()
74			{
75			if (!file_exists($this->credentialsFilePath)) {
76			throw new InvalidArgumentException(
77			sprintf(
78			"Application credentials file '%s' not exists",
79			$this->credentialsFilePath
80			)
81			);
82			}
83			return $this->credentialsFilePath;
84			}
85
86			/**
87			* @param string $filePath
88			* @return $this
89			*/
90			public function setCredentialsFilePath($filePath)
91			{
92			$this->credentialsFilePath = $filePath;
93			return $this;
94			}
95
96			/**
97			* @return string
98			*/
99			public function getApplicationName()
100			{
101			return $this->applicationName;
102			}
103
104			/**
105			* @param string $applicationName
106			* @return $this
107			*/
108			public function setApplicationName($applicationName)
109			{
110			$this->applicationName = $applicationName;
111			return $this;
112			}
113
114			/**
115			* Gets an iterator from an ArrayObject instance
116			*
117			* @return \ArrayIterator
118			*/
119			public function getMessagesIterator()
120			{
121			return $this->messages->getIterator();
122			}
123
124			/**
125			* Adds a message to collection
126			*
127			* @param MessageInterface $message
128			* @return $this
129			*/
130			public function addMessage(MessageInterface $message)
131			{
132			$messageId = $message->getMessageIdentifier();
133			$this->messages->offsetSet($messageId, $message);
134			return $this;
135			}
136
137			/**
138			* Removes the given message from collection
139			*
140			* @param MessageInterface $message
141			* @return $this
142			*/
143			public function unsetMessage(MessageInterface $message)
144			{
145			$messageId = $message->getMessageIdentifier();
146			$this->messages->offsetUnset($messageId);
147			return $this;
148			}
149
150			/**
151			* @return \ArrayIterator
152			*/
153			public function getInvalidRecipients()
154			{
155			return $this->invalidRecipients;
156			}
157
158			/**
159			* Adds a invalid recipient to collection
160			*
161			* @param string $serviceName
162			* @param RecipientDevice\|string $recipient
163			* @return $this
164			*/
165			public function addInvalidRecipient($serviceName, $recipient)
166			{
167			if (!in_array($serviceName, $this->getInitializedServices())) {
168			throw new DomainException(
169			sprintf("Recipient of an unsupported service '%s'", $serviceName)
170			);
171			}
172
173			if (is_string($recipient)) {
174			$messageClassName = 'Zbox\UnifiedPush\Message\Type\\' . $serviceName;
175			$recipient = new RecipientDevice($recipient, $messageClassName());
176
177			$recipient->setIdentifierStatus(RecipientDevice::DEVICE_NOT_REGISTERED);
178			}
179
180			$this->invalidRecipients->append($recipient);
181
182			return $this;
183			}
184
185			/**
186			* Returns the list of names of notification services available for the application
187			*
188			* @return array
189			*/
190			public function getInitializedServices()
191			{
192			return array_keys($this->config);
193			}
194
195			/**
196			* Returns credentials for notification service
197			*
198			* @param string $serviceName
199			* @throws DomainException
200			* @return array
201			*/
202			public function getCredentialsByService($serviceName)
203			{
204			if ($this->getApplicationName() && empty($this->config)) {
205			$this->loadApplicationConfig();
206			}
207
208			if (!in_array($serviceName, $this->getInitializedServices())) {
209			throw new DomainException(
210			sprintf("Credentials for service '%s' was not initialized", $serviceName)
211			);
212			}
213
214			$credentials = NotificationServices::getCredentialsTypeByService($serviceName);
215
216			return
217			$this
218			->credentialsMapper
219			->mapCredentials(
220			$credentials,
221			$this->config[$serviceName]
222			)
223			;
224			}
225
226			/**
227			* Load sender`s notification services credentials by application name
228			*
229			* @return $this
230			* @throws DomainException
231			*/
232			public function loadApplicationConfig()
233			{
234			$configFilePath = $this->getCredentialsFilepath();
235			$applicationsConfig = json_decode(file_get_contents($configFilePath), true);
236
237			$applicationName = $this->getApplicationName();
238
239			if (!array_key_exists($applicationName, $applicationsConfig)) {
240			throw new DomainException(
241			sprintf("Application '%s' is not defined.", $applicationName)
242			);
243			}
244			$this->config = $applicationsConfig[$applicationName];
245
246			return $this;
247			}
248			}
249

zbox / UnifiedPush

GitHub Access Token became invalid

Push — master ( 15375f...2893b6 )

Application::addMessage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like