Domain::index() - Code Metrics - Inspection of "added tests" - mailgun/mailgun-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b30417...4641cf )

by David

created 2020-08-14 00:06 UTC

Domain::index() A

↳ Parent: Domain

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	6
cts	6
cp	1
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	1

<?php

declare(strict_types=1);

/*
 * Copyright (C) 2013 Mailgun
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file for details.
 */

namespace Mailgun\Api;

use Mailgun\Assert;
use Mailgun\Model\Domain\ConnectionResponse;
use Mailgun\Model\Domain\CreateCredentialResponse;
use Mailgun\Model\Domain\CreateResponse;
use Mailgun\Model\Domain\CredentialResponse;
use Mailgun\Model\Domain\DeleteCredentialResponse;
use Mailgun\Model\Domain\DeleteResponse;
use Mailgun\Model\Domain\IndexResponse;
use Mailgun\Model\Domain\ShowResponse;
use Mailgun\Model\Domain\UpdateConnectionResponse;
use Mailgun\Model\Domain\UpdateCredentialResponse;
use Mailgun\Model\Domain\VerifyResponse;
use Psr\Http\Message\ResponseInterface;

/**
 * @see https://documentation.mailgun.com/api-domains.html
 *
 * @author Sean Johnson <[email protected]>
 */
class Domain extends HttpApi
{
    /**
     * Returns a list of domains on the account.
     *
     * @return IndexResponse
     */
    public function index(int $limit = 100, int $skip = 0)
    {
        Assert::range($limit, 1, 1000);

        $params = [
            'limit' => $limit,
            'skip' => $skip,
        ];

        $response = $this->httpGet('/v3/domains', $params);

        return $this->hydrateResponse($response, IndexResponse::class);
    }

    /**
     * Returns a single domain.
     *
     * @param string $domain name of the domain
     *
     * @return ShowResponse|array|ResponseInterface
     */
    public function show(string $domain)
    {
        Assert::stringNotEmpty($domain);

        $response = $this->httpGet(sprintf('/v3/domains/%s', $domain));

        return $this->hydrateResponse($response, ShowResponse::class);
    }

    /**
     * Creates a new domain for the account.
     * See below for spam filtering parameter information.
     * {@link https://documentation.mailgun.com/user_manual.html#um-spam-filter}.
     *
     * @see https://documentation.mailgun.com/en/latest/api-domains.html#domains
     *
     * @param string $domain     name of the domain
     * @param string $smtpPass   password for SMTP authentication
     * @param string $spamAction `disable` or `tag` - inbound spam filtering
     * @param bool   $wildcard   domain will accept email for subdomains
     * @param bool   $forceDkimAuthority force DKIM authority
     *
     * @return CreateResponse|array|ResponseInterface
     */
    public function create(string $domain, string $smtpPass = null, string $spamAction = null, bool $wildcard = null, bool $forceDkimAuthority = null)
    {
        Assert::stringNotEmpty($domain);

        $params['name'] = $domain;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

        if (!empty($smtpPass)) {
            Assert::stringNotEmpty($smtpPass);

            $params['smtp_password'] = $smtpPass;
        }

        if (!empty($spamAction)) {
            // TODO(sean.johnson): Extended spam filter input validation.
            Assert::stringNotEmpty($spamAction);

            $params['spam_action'] = $spamAction;
        }

        if (null !== $wildcard) {
            Assert::boolean($wildcard);

            $params['wildcard'] = $wildcard ? 'true' : 'false';
        }

        if (null !== $forceDkimAuthority) {
            Assert::boolean($forceDkimAuthority);

            $params['force_dkim_authority'] = $forceDkimAuthority ? 'true' : 'false';
        }

        $response = $this->httpPost('/v3/domains', $params);

        return $this->hydrateResponse($response, CreateResponse::class);
    }

    /**
     * Removes a domain from the account.
     * WARNING: This action is irreversible! Be cautious!
     *
     * @param string $domain name of the domain
     *
     * @return DeleteResponse|array|ResponseInterface
     */
    public function delete(string $domain)
    {
        Assert::stringNotEmpty($domain);

        $response = $this->httpDelete(sprintf('/v3/domains/%s', $domain));

        return $this->hydrateResponse($response, DeleteResponse::class);
    }

    /**
     * Returns a list of SMTP credentials for the specified domain.
     *
     * @param string $domain name of the domain
     * @param int    $limit  Number of credentials to return
     * @param int    $skip   Number of credentials to omit from the list
     *
     * @return CredentialResponse
     */
    public function credentials(string $domain, int $limit = 100, int $skip = 0)
    {
        Assert::stringNotEmpty($domain);
        $params = [
            'limit' => $limit,
            'skip' => $skip,
        ];

        $response = $this->httpGet(sprintf('/v3/domains/%s/credentials', $domain), $params);

        return $this->hydrateResponse($response, CredentialResponse::class);
    }

    /**
     * Create a new SMTP credential pair for the specified domain.
     *
     * @param string $domain   name of the domain
     * @param string $login    SMTP Username
     * @param string $password SMTP Password. Length min 5, max 32.
     *
     * @return CreateCredentialResponse|array|ResponseInterface
     */
    public function createCredential(string $domain, string $login, string $password)
    {
        Assert::stringNotEmpty($domain);
        Assert::stringNotEmpty($login);
        Assert::stringNotEmpty($password);
        Assert::lengthBetween($password, 5, 32, 'SMTP password must be between 5 and 32 characters.');

        $params = [
            'login' => $login,
            'password' => $password,
        ];

        $response = $this->httpPost(sprintf('/v3/domains/%s/credentials', $domain), $params);

        return $this->hydrateResponse($response, CreateCredentialResponse::class);
    }

    /**
     * Update a set of SMTP credentials for the specified domain.
     *
     * @param string $domain name of the domain
     * @param string $login  SMTP Username
     * @param string $pass   New SMTP Password. Length min 5, max 32.
     *
     * @return UpdateCredentialResponse|array|ResponseInterface
     */
    public function updateCredential(string $domain, string $login, string $pass)
    {
        Assert::stringNotEmpty($domain);
        Assert::stringNotEmpty($login);
        Assert::stringNotEmpty($pass);
        Assert::lengthBetween($pass, 5, 32, 'SMTP password must be between 5 and 32 characters.');

        $params = [
            'password' => $pass,
        ];

        $response = $this->httpPut(sprintf('/v3/domains/%s/credentials/%s', $domain, $login), $params);

        return $this->hydrateResponse($response, UpdateCredentialResponse::class);
    }

    /**
     * Remove a set of SMTP credentials from the specified domain.
     *
     * @param string $domain name of the domain
     * @param string $login  SMTP Username
     *
     * @return DeleteCredentialResponse|array|ResponseInterface
     */
    public function deleteCredential(string $domain, string $login)
    {
        Assert::stringNotEmpty($domain);
        Assert::stringNotEmpty($login);

        $response = $this->httpDelete(
            sprintf(
                '/v3/domains/%s/credentials/%s',
                $domain,
                $login
            )
        );

        return $this->hydrateResponse($response, DeleteCredentialResponse::class);
    }

    /**
     * Returns delivery connection settings for the specified domain.
     *
     * @param string $domain name of the domain
     *
     * @return ConnectionResponse|ResponseInterface
     */
    public function connection(string $domain)
    {
        Assert::stringNotEmpty($domain);

        $response = $this->httpGet(sprintf('/v3/domains/%s/connection', $domain));

        return $this->hydrateResponse($response, ConnectionResponse::class);
    }

    /**
     * Updates the specified delivery connection settings for the specified domain.
     * If a parameter is passed in as null, it will not be updated.
     *
     * @param string    $domain     name of the domain
     * @param bool|null $requireTLS enforces that messages are sent only over a TLS connection
     * @param bool|null $noVerify   disables TLS certificate and hostname verification
     *
     * @return UpdateConnectionResponse|array|ResponseInterface
     */
    public function updateConnection(string $domain, ?bool $requireTLS, ?bool $noVerify)
    {
        Assert::stringNotEmpty($domain);
        $params = [];

        if (null !== $requireTLS) {
            $params['require_tls'] = $requireTLS ? 'true' : 'false';
        }

        if (null !== $noVerify) {
            $params['skip_verification'] = $noVerify ? 'true' : 'false';
        }

        $response = $this->httpPut(sprintf('/v3/domains/%s/connection', $domain), $params);

        return $this->hydrateResponse($response, UpdateConnectionResponse::class);
    }

    /**
     * Returns a single domain.
     *
     * @param string $domain name of the domain
     *
     * @return VerifyResponse|array|ResponseInterface
     */
    public function verify(string $domain)
    {
        Assert::stringNotEmpty($domain);

        $response = $this->httpPut(sprintf('/v3/domains/%s/verify', $domain));

        return $this->hydrateResponse($response, VerifyResponse::class);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* Copyright (C) 2013 Mailgun
7		*
8		* This software may be modified and distributed under the terms
9		* of the MIT license. See the LICENSE file for details.
10		*/
11
12		namespace Mailgun\Api;
13
14		use Mailgun\Assert;
15		use Mailgun\Model\Domain\ConnectionResponse;
16		use Mailgun\Model\Domain\CreateCredentialResponse;
17		use Mailgun\Model\Domain\CreateResponse;
18		use Mailgun\Model\Domain\CredentialResponse;
19		use Mailgun\Model\Domain\DeleteCredentialResponse;
20		use Mailgun\Model\Domain\DeleteResponse;
21		use Mailgun\Model\Domain\IndexResponse;
22		use Mailgun\Model\Domain\ShowResponse;
23		use Mailgun\Model\Domain\UpdateConnectionResponse;
24		use Mailgun\Model\Domain\UpdateCredentialResponse;
25		use Mailgun\Model\Domain\VerifyResponse;
26		use Psr\Http\Message\ResponseInterface;
27
28		/**
29		* @see https://documentation.mailgun.com/api-domains.html
30		*
31		* @author Sean Johnson <[email protected]>
32		*/
33		class Domain extends HttpApi
34		{
35		/**
36		* Returns a list of domains on the account.
37		*
38		* @return IndexResponse
39		*/
40	1	public function index(int $limit = 100, int $skip = 0)
41		{
42	1	Assert::range($limit, 1, 1000);
43
44		$params = [
45	1	'limit' => $limit,
46	1	'skip' => $skip,
47		];
48
49	1	$response = $this->httpGet('/v3/domains', $params);
50
51	1	return $this->hydrateResponse($response, IndexResponse::class);
52		}
53
54		/**
55		* Returns a single domain.
56		*
57		* @param string $domain name of the domain
58		*
59		* @return ShowResponse\|array\|ResponseInterface
60		*/
61	1	public function show(string $domain)
62		{
63	1	Assert::stringNotEmpty($domain);
64
65	1	$response = $this->httpGet(sprintf('/v3/domains/%s', $domain));
66
67	1	return $this->hydrateResponse($response, ShowResponse::class);
68		}
69
70		/**
71		* Creates a new domain for the account.
72		* See below for spam filtering parameter information.
73		* {@link https://documentation.mailgun.com/user_manual.html#um-spam-filter}.
74		*
75		* @see https://documentation.mailgun.com/en/latest/api-domains.html#domains
76		*
77		* @param string $domain name of the domain
78		* @param string $smtpPass password for SMTP authentication
79		* @param string $spamAction `disable` or `tag` - inbound spam filtering
80		* @param bool $wildcard domain will accept email for subdomains
81		* @param bool $forceDkimAuthority force DKIM authority
82		*
83		* @return CreateResponse\|array\|ResponseInterface
84		*/
85	6	public function create(string $domain, string $smtpPass = null, string $spamAction = null, bool $wildcard = null, bool $forceDkimAuthority = null)
86		{
87	6	Assert::stringNotEmpty($domain);
88
89	6	$params['name'] = $domain;
		0 ignored issues – show Coding Style Comprehensibility introduced 2019-08-29 21:27 UTC by Report Bug Copy Issue Report `$params` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$params = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
90
91	6	if (!empty($smtpPass)) {
92	5	Assert::stringNotEmpty($smtpPass);
93
94	5	$params['smtp_password'] = $smtpPass;
95		}
96
97	6	if (!empty($spamAction)) {
98		// TODO(sean.johnson): Extended spam filter input validation.
99	3	Assert::stringNotEmpty($spamAction);
100
101	3	$params['spam_action'] = $spamAction;
102		}
103
104	6	if (null !== $wildcard) {
105	2	Assert::boolean($wildcard);
106
107	2	$params['wildcard'] = $wildcard ? 'true' : 'false';
108		}
109
110	6	if (null !== $forceDkimAuthority) {
111	2	Assert::boolean($forceDkimAuthority);
112
113	2	$params['force_dkim_authority'] = $forceDkimAuthority ? 'true' : 'false';
114		}
115
116	6	$response = $this->httpPost('/v3/domains', $params);
117
118	6	return $this->hydrateResponse($response, CreateResponse::class);
119		}
120
121		/**
122		* Removes a domain from the account.
123		* WARNING: This action is irreversible! Be cautious!
124		*
125		* @param string $domain name of the domain
126		*
127		* @return DeleteResponse\|array\|ResponseInterface
128		*/
129	1	public function delete(string $domain)
130		{
131	1	Assert::stringNotEmpty($domain);
132
133	1	$response = $this->httpDelete(sprintf('/v3/domains/%s', $domain));
134
135	1	return $this->hydrateResponse($response, DeleteResponse::class);
136		}
137
138		/**
139		* Returns a list of SMTP credentials for the specified domain.
140		*
141		* @param string $domain name of the domain
142		* @param int $limit Number of credentials to return
143		* @param int $skip Number of credentials to omit from the list
144		*
145		* @return CredentialResponse
146		*/
147		public function credentials(string $domain, int $limit = 100, int $skip = 0)
148		{
149		Assert::stringNotEmpty($domain);
150		$params = [
151		'limit' => $limit,
152		'skip' => $skip,
153		];
154
155		$response = $this->httpGet(sprintf('/v3/domains/%s/credentials', $domain), $params);
156
157		return $this->hydrateResponse($response, CredentialResponse::class);
158		}
159
160		/**
161		* Create a new SMTP credential pair for the specified domain.
162		*
163		* @param string $domain name of the domain
164		* @param string $login SMTP Username
165		* @param string $password SMTP Password. Length min 5, max 32.
166		*
167		* @return CreateCredentialResponse\|array\|ResponseInterface
168		*/
169	1	public function createCredential(string $domain, string $login, string $password)
170		{
171	1	Assert::stringNotEmpty($domain);
172	1	Assert::stringNotEmpty($login);
173	1	Assert::stringNotEmpty($password);
174	1	Assert::lengthBetween($password, 5, 32, 'SMTP password must be between 5 and 32 characters.');
175
176		$params = [
177	1	'login' => $login,
178	1	'password' => $password,
179		];
180
181	1	$response = $this->httpPost(sprintf('/v3/domains/%s/credentials', $domain), $params);
182
183	1	return $this->hydrateResponse($response, CreateCredentialResponse::class);
184		}
185
186		/**
187		* Update a set of SMTP credentials for the specified domain.
188		*
189		* @param string $domain name of the domain
190		* @param string $login SMTP Username
191		* @param string $pass New SMTP Password. Length min 5, max 32.
192		*
193		* @return UpdateCredentialResponse\|array\|ResponseInterface
194		*/
195	1	public function updateCredential(string $domain, string $login, string $pass)
196		{
197	1	Assert::stringNotEmpty($domain);
198	1	Assert::stringNotEmpty($login);
199	1	Assert::stringNotEmpty($pass);
200	1	Assert::lengthBetween($pass, 5, 32, 'SMTP password must be between 5 and 32 characters.');
201
202		$params = [
203	1	'password' => $pass,
204		];
205
206	1	$response = $this->httpPut(sprintf('/v3/domains/%s/credentials/%s', $domain, $login), $params);
207
208	1	return $this->hydrateResponse($response, UpdateCredentialResponse::class);
209		}
210
211		/**
212		* Remove a set of SMTP credentials from the specified domain.
213		*
214		* @param string $domain name of the domain
215		* @param string $login SMTP Username
216		*
217		* @return DeleteCredentialResponse\|array\|ResponseInterface
218		*/
219	1	public function deleteCredential(string $domain, string $login)
220		{
221	1	Assert::stringNotEmpty($domain);
222	1	Assert::stringNotEmpty($login);
223
224	1	$response = $this->httpDelete(
225	1	sprintf(
226	1	'/v3/domains/%s/credentials/%s',
227	1	$domain,
228	1	$login
229		)
230		);
231
232	1	return $this->hydrateResponse($response, DeleteCredentialResponse::class);
233		}
234
235		/**
236		* Returns delivery connection settings for the specified domain.
237		*
238		* @param string $domain name of the domain
239		*
240		* @return ConnectionResponse\|ResponseInterface
241		*/
242	1	public function connection(string $domain)
243		{
244	1	Assert::stringNotEmpty($domain);
245
246	1	$response = $this->httpGet(sprintf('/v3/domains/%s/connection', $domain));
247
248	1	return $this->hydrateResponse($response, ConnectionResponse::class);
249		}
250
251		/**
252		* Updates the specified delivery connection settings for the specified domain.
253		* If a parameter is passed in as null, it will not be updated.
254		*
255		* @param string $domain name of the domain
256		* @param bool\|null $requireTLS enforces that messages are sent only over a TLS connection
257		* @param bool\|null $noVerify disables TLS certificate and hostname verification
258		*
259		* @return UpdateConnectionResponse\|array\|ResponseInterface
260		*/
261	1	public function updateConnection(string $domain, ?bool $requireTLS, ?bool $noVerify)
262		{
263	1	Assert::stringNotEmpty($domain);
264	1	$params = [];
265
266	1	if (null !== $requireTLS) {
267	1	$params['require_tls'] = $requireTLS ? 'true' : 'false';
268		}
269
270	1	if (null !== $noVerify) {
271	1	$params['skip_verification'] = $noVerify ? 'true' : 'false';
272		}
273
274	1	$response = $this->httpPut(sprintf('/v3/domains/%s/connection', $domain), $params);
275
276	1	return $this->hydrateResponse($response, UpdateConnectionResponse::class);
277		}
278
279		/**
280		* Returns a single domain.
281		*
282		* @param string $domain name of the domain
283		*
284		* @return VerifyResponse\|array\|ResponseInterface
285		*/
286	1	public function verify(string $domain)
287		{
288	1	Assert::stringNotEmpty($domain);
289
290	1	$response = $this->httpPut(sprintf('/v3/domains/%s/verify', $domain));
291
292	1	return $this->hydrateResponse($response, VerifyResponse::class);
293		}
294		}
295

mailgun / mailgun-php

Push — master ( b30417...4641cf )

Domain::index() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like