DynadotApi::getDomainList() - Code Metrics - Inspection of "Updated packages. We now require php version 7.3 o..." - level23/dynadot-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#3)

by Teye

created 2021-06-11 12:22 UTC

DynadotApi::getDomainList() C

↳ Parent: DynadotApi

Complexity

Conditions	11
Paths	7

Size

Total Lines	99
Code Lines	59

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	47
CRAP Score	12.4626

Importance

Changes

Metric	Value
eloc	59
dl	0
loc	99
c	0
b	0
f	0
ccs	47
cts	61
cp	0.7705
rs	6.7478
cc	11
nc	7
nop	0
crap	12.4626

How to fix Long Method Complexity

<?php

namespace Level23\Dynadot;

use Psr\Log\LogLevel;
use Sabre\Xml\Reader;
use GuzzleHttp\Client;
use Sabre\Xml\Service;
use Psr\Log\LoggerInterface;
use Psr\Http\Message\StreamInterface;
use Level23\Dynadot\ResultObjects\SetNsResponse;
use Level23\Dynadot\ResultObjects\DomainResponse;
use Level23\Dynadot\Exception\DynadotApiException;
use Level23\Dynadot\ResultObjects\GeneralResponse;
use Level23\Dynadot\ResultObjects\DomainInfoResponse;
use Level23\Dynadot\ResultObjects\GetContactResponse;
use Level23\Dynadot\Exception\ApiHttpCallFailedException;
use Level23\Dynadot\ResultObjects\ListDomainInfoResponse;
use Level23\Dynadot\Exception\ApiLimitationExceededException;

/**
 * Class DynadotApi
 *
 * @package Level23\Dynadot
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class DynadotApi
{
    const DYNADOT_API_URL = 'https://api.dynadot.com/api3.xml';

    /**
     * This options array is used by Guzzle.
     *
     * We currently use it to set the Mock Handler in unit testing.
     *
     * @var array
     */
    protected $guzzleOptions = [];

    /**
     * Dynadot's API key we should use for HTTP calls.
     *
     * @var string
     */
    protected $apiKey;

    /**
     * Logger for writing debug info
     *
     * @var LoggerInterface|null
     */
    protected $logger;

    /**
     * Changes boolean values like "no" and "yes" into false and true.
     *
     * @return bool
     * @throws DynadotApiException
     * @var \Closure
     */
    protected $booleanDeserializer;

    /**
     * Return the contact id
     *
     * @param Reader $reader
     *
     * @return int
     * @var \Closure
     */
    protected $contactIdDeserializer;

    /**
     * DynadotApi constructor.
     *
     * @param string                        $apiKey The API key we should use while communicating with the Dynadot API.
     * @param \Psr\Log\LoggerInterface|null $logger
     *
     * @internal param $Logger
     */
    public function __construct(string $apiKey, LoggerInterface $logger = null)
    {
        $this->setApiKey($apiKey);
        $this->logger = $logger;

        /**
         * Set the default guzzle options
         */
        $this->setGuzzleOptions([
            'max'             => 5,
            'referer'         => false,
            'protocols'       => ['https'],
            'connect_timeout' => 30,
        ]);

        /**
         * Changes boolean values like "no" and "yes" into false and true.
         *
         * @param \Sabre\Xml\Reader $reader
         *
         * @return bool
         * @throws \Level23\Dynadot\Exception\DynadotApiException
         * @throws \Sabre\Xml\LibXMLException
         * @throws \Sabre\Xml\ParseException
         */
        $this->booleanDeserializer = function (Reader $reader) {
            $value = $reader->parseInnerTree();

            if ($value != 'yes' && $value != 'no') {
                throw new DynadotApiException('Error, received incorrect boolean value ' . var_export($value, true));
            }

            return ($value !== 'no');
        };

        /**
         * Return the contact id
         *
         * @param Reader $reader
         *
         * @return int
         * @throws \Sabre\Xml\LibXMLException
         * @throws \Sabre\Xml\ParseException
         */
        $this->contactIdDeserializer = function (Reader $reader) {
            $children = (array)$reader->parseInnerTree();

            return $children[0]['value'];
        };
    }

    /**
     * @param array $optionsArray
     */
    public function setGuzzleOptions(array $optionsArray)
    {
        $this->guzzleOptions = $optionsArray;
    }

    /**
     * Get info about a domain
     *
     * @param string $domain
     *
     * @return DomainResponse\Domain
     * @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
     * @throws \Level23\Dynadot\Exception\DynadotApiException
     * @throws \Sabre\Xml\ParseException
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function getDomainInfo(string $domain): DomainResponse\Domain
    {
        $this->log(LogLevel::INFO, 'Retrieve info for domain: ' . $domain);

        $requestData = [
            'domain'  => $domain,
            'command' => 'domain_info',
        ];

        // perform the API call
        $response = $this->performRawApiCall($requestData);

        // start parsing XML data using Sabre
        $sabreService = new Service();

        // set mapping
        $sabreService->elementMap = [
            '{}NameServers'          => function (Reader $reader) {

                $nameservers = [];
                $id          = '';

                $children = (array)$reader->parseInnerTree();

                foreach ($children as $child) {
                    if ($child['name'] == '{}ServerId') {
                        $id = $child['value'];
                    } elseif ($child['name'] == '{}ServerName') {
                        if (!empty($id) && !empty($child['value'])) {
                            $nameserver = new DomainResponse\NameServer();

                            $nameserver->ServerId   = $id;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
                            $nameserver->ServerName = $child['value'];

                            $nameservers[] = $nameserver;
                        }
                        $id = null;
                    }
                }

                return $nameservers;
            },
            '{}Registrant'           => $this->contactIdDeserializer,
            '{}Admin'                => $this->contactIdDeserializer,
            '{}Technical'            => $this->contactIdDeserializer,
            '{}Billing'              => $this->contactIdDeserializer,
            '{}isForSale'            => $this->booleanDeserializer,
            '{}Hold'                 => $this->booleanDeserializer,
            '{}RegistrantUnverified' => $this->booleanDeserializer,
            '{}UdrpLocked'           => $this->booleanDeserializer,
            '{}Disabled'             => $this->booleanDeserializer,
            '{}Locked'               => $this->booleanDeserializer,
            '{}WithAds'              => $this->booleanDeserializer,
        ];

        // map certain values to objects
        $sabreService->mapValueObject('{}DomainInfoResponse', DomainInfoResponse\DomainInfoResponse::class);
        $sabreService->mapValueObject('{}DomainInfoResponseHeader', DomainInfoResponse\DomainInfoResponseHeader::class);
        $sabreService->mapValueObject('{}DomainInfoContent', DomainInfoResponse\DomainInfoContent::class);
        $sabreService->mapValueObject('{}Domain', DomainResponse\Domain::class);
        $sabreService->mapValueObject('{}NameServerSettings', DomainResponse\NameServerSettings::class);
        $sabreService->mapValueObject('{}Whois', DomainResponse\Whois::class);
        $sabreService->mapValueObject('{}Folder', DomainResponse\Folder::class);
        $sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
        $sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);

        $this->log(LogLevel::DEBUG, 'Start parsing response XML');

        // parse the data
        $resultData = $sabreService->parse($response->getContents());

        // General error, like incorrect api key
        if ($resultData instanceof GeneralResponse\Response) {
            $code = $resultData->ResponseHeader->ResponseCode;
            if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
                throw new DynadotApiException($resultData->ResponseHeader->Error);
            }
        }

        if (!$resultData instanceof DomainInfoResponse\DomainInfoResponse) {
            throw new DynadotApiException('We failed to parse the response');
        }

        /**
         * Check if the API call was successful. If not, return the error
         */
        $code = $resultData->DomainInfoResponseHeader->SuccessCode;
        if ($code != DomainInfoResponse\DomainInfoResponseHeader::SUCCESSCODE_OK) {
            throw new DynadotApiException($resultData->DomainInfoResponseHeader->Error);
        }

        $this->log(LogLevel::DEBUG, 'Returning domain info');

        // Here we know our API call was succesful, return the domain info.
        return $resultData->DomainInfoContent->Domain;
    }

    /**
     * Log a message to our logger, if we have any.
     *
     * @param string $level
     * @param string $message
     */
    protected function log(string $level, string $message): void
    {
        if ($this->logger instanceof LoggerInterface) {
            $this->logger->log($level, $message);
        }
    }

    /**
     * Performs the actual API call (internal method)
     *
     * @param array $requestData
     *
     * @return \Psr\Http\Message\StreamInterface
     * @throws \GuzzleHttp\Exception\GuzzleException
     * @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
     */
    protected function performRawApiCall(array $requestData): StreamInterface
    {
        $this->log(LogLevel::DEBUG, 'Perform raw call: ' . var_export($requestData, true));

        // transform the request data into a valid query string
        $requestDataHttp = http_build_query($requestData);

        // spawn Guzzle
        $client = new Client($this->guzzleOptions);

        $url = self::DYNADOT_API_URL .
            '?key=' . urlencode($this->getApiKey()) .
            ($requestDataHttp ? '&' . $requestDataHttp : '');

        $this->log(LogLevel::DEBUG, 'Start new guzzle request with URL: ' . $url);

        // start a request with out API key and optionally our request data
        $response = $client->request('GET', $url);

        $this->log(LogLevel::DEBUG, 'Received response with status code ' . $response->getStatusCode());

        // if we did not get a HTTP 200 response, our HTTP call failed (which is different from a failed API call)
        if ($response->getStatusCode() != 200) {
            $this->log(LogLevel::ALERT, 'Received wrong HTTP status code: ' . $response->getStatusCode());
            // not ok
            throw new ApiHttpCallFailedException(
                'HTTP API call failed, expected 200 status, got ' . $response->getStatusCode()
            );
        }

        // Return the response body (which is a stream coming from Guzzle).
        // Sabre XML semi-handles streams (it will just get the contents of the stream using stream_get_contents) so
        // this should work! ;)
        return $response->getBody();
    }

    /**
     * @return string
     */
    public function getApiKey(): string
    {
        return $this->apiKey;
    }

    /**
     * @param string $apiKey
     */
    public function setApiKey(string $apiKey)
    {
        $this->apiKey = $apiKey;
    }

    /**
     * Set nameservers for a domain (max 13). An exception will be thrown in case of an error.
     *
     * @param string $domain The domain where to set the nameservers for.
     * @param array  $nameservers
     *
     * @throws \GuzzleHttp\Exception\GuzzleException
     * @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
     * @throws \Level23\Dynadot\Exception\ApiLimitationExceededException
     * @throws \Level23\Dynadot\Exception\DynadotApiException
     * @throws \Sabre\Xml\ParseException
     */
    public function setNameserversForDomain(string $domain, array $nameservers)
    {
        $this->log(LogLevel::DEBUG, 'Set ' . sizeof($nameservers) . ' nameservers for domain ' . $domain);
        $requestData = [
            'command' => 'set_ns',
            'domain'  => $domain,
        ];

        if (sizeof($nameservers) > 13) {
            // index starts at 0, so we should check if the index is greater than 12 (which is 13 nameservers)
            throw new ApiLimitationExceededException(
                'Can not define more than 13 nameservers through the API'
            );
        }

        $idx = 0;
        // check if there are more than 13 nameservers defined
        foreach ($nameservers as $nameserver) {
            $requestData['ns' . $idx++] = $nameserver;
        }

        // perform the API call
        $response = $this->performRawApiCall($requestData);

        $this->log(LogLevel::DEBUG, 'API call execured, parsing response...');

        // start parsing XML data using Sabre
        $sabreService = new Service();

        // map certain values to objects
        $sabreService->mapValueObject('{}SetNsResponse', SetNsResponse\SetNsResponse::class);
        $sabreService->mapValueObject('{}SetNsHeader', SetNsResponse\SetNsHeader::class);
        $sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
        $sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);

        // parse the data
        $resultData = $sabreService->parse($response->getContents());

        // General error, like incorrect api key
        if ($resultData instanceof GeneralResponse\Response) {
            $code = $resultData->ResponseHeader->ResponseCode;
            if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
                throw new DynadotApiException($resultData->ResponseHeader->Error);
            }
        }

        if (!$resultData instanceof SetNsResponse\SetNsResponse) {
            throw new DynadotApiException('We failed to parse the response');
        }

        /**
         * Check if the API call was successful. If not, return the error
         */
        $code = $resultData->SetNsHeader->SuccessCode;
        if ($code != SetNsResponse\SetNsHeader::SUCCESSCODE_OK) {
            throw new DynadotApiException($resultData->SetNsHeader->Error);
        }

        $this->log(LogLevel::DEBUG, 'Received correct response. Everything is ok!');
    }

    /**
     * List all domains in the account. We will return an array with Domain objects
     *
     * @return DomainResponse\Domain[]
     * @throws \GuzzleHttp\Exception\GuzzleException
     * @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
     * @throws \Level23\Dynadot\Exception\DynadotApiException
     * @throws \Sabre\Xml\ParseException
     */
    public function getDomainList(): array
    {
        $this->log(LogLevel::DEBUG, 'Start retrieving all domains');
        $requestData = [
            'command' => 'list_domain',
        ];

        // perform the API call
        $response = $this->performRawApiCall($requestData);

        $this->log(LogLevel::DEBUG, 'Start parsing response XML');

        // start parsing XML data using Sabre
        $sabreService = new Service();

        // set mapping
        $sabreService->elementMap = [
            '{}NameServers'          => function (Reader $reader) {

                $nameservers = [];
                $id          = '';

                $children = (array)$reader->parseInnerTree();

                foreach ($children as $child) {
                    if ($child['name'] == '{}ServerId') {
                        $id = $child['value'];
                    } elseif ($child['name'] == '{}ServerName') {
                        if (!empty($id) && !empty($child['value'])) {
                            $nameserver             = new DomainResponse\NameServer();
                            $nameserver->ServerId   = $id;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
                            $nameserver->ServerName = $child['value'];

                            $nameservers[] = $nameserver;
                        }
                        $id = null;
                    }
                }

                return $nameservers;
            },
            '{}DomainInfoList'       => function (Reader $reader) {
                $domains = [];

                $tree = (array)$reader->parseInnerTree();
                foreach ($tree as $item) {
                    $domains[] = $item['value'][0]['value'];
                }

                return $domains;
            },
            '{}Registrant'           => $this->contactIdDeserializer,
            '{}Admin'                => $this->contactIdDeserializer,
            '{}Technical'            => $this->contactIdDeserializer,
            '{}Billing'              => $this->contactIdDeserializer,
            '{}isForSale'            => $this->booleanDeserializer,
            '{}Hold'                 => $this->booleanDeserializer,
            '{}RegistrantUnverified' => $this->booleanDeserializer,
            '{}UdrpLocked'           => $this->booleanDeserializer,
            '{}Disabled'             => $this->booleanDeserializer,
            '{}Locked'               => $this->booleanDeserializer,
            '{}WithAds'              => $this->booleanDeserializer,
        ];

        // map certain values to objects
        $sabreService->mapValueObject('{}ListDomainInfoResponse', ListDomainInfoResponse\ListDomainInfoResponse::class);
        $sabreService->mapValueObject('{}ListDomainInfoHeader', ListDomainInfoResponse\ListDomainInfoHeader::class);
        $sabreService->mapValueObject('{}ListDomainInfoContent', ListDomainInfoResponse\ListDomainInfoContent::class);
        $sabreService->mapValueObject('{}Domain', DomainResponse\Domain::class);
        $sabreService->mapValueObject('{}NameServerSettings', DomainResponse\NameServerSettings::class);
        $sabreService->mapValueObject('{}Whois', DomainResponse\Whois::class);
        $sabreService->mapValueObject('{}Folder', DomainResponse\Folder::class);
        $sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
        $sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);

        // parse the data
        $resultData = $sabreService->parse($response->getContents());

        // General error, like incorrect api key
        if ($resultData instanceof GeneralResponse\Response) {
            $code = $resultData->ResponseHeader->ResponseCode;
            if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
                throw new DynadotApiException($resultData->ResponseHeader->Error);
            }
        }

        if (!$resultData instanceof ListDomainInfoResponse\ListDomainInfoResponse) {
            throw new DynadotApiException('We failed to parse the response');
        }

        /**
         * Check if the API call was successful. If not, return the error
         */
        $code = $resultData->ListDomainInfoHeader->ResponseCode;
        if ($code != ListDomainInfoResponse\ListDomainInfoHeader::RESPONSECODE_OK) {
            throw new DynadotApiException($resultData->ListDomainInfoHeader->Error);
        }

        return $resultData->ListDomainInfoContent->DomainInfoList;
    }

    /**
     * Get contact information for a specific contact ID
     *
     * @param int $contactId The contact ID we should request
     *
     * @return GetContactResponse\Contact
     * @throws \GuzzleHttp\Exception\GuzzleException
     * @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
     * @throws \Level23\Dynadot\Exception\DynadotApiException
     * @throws \Sabre\Xml\ParseException
     */
    public function getContactInfo(int $contactId): GetContactResponse\Contact
    {
        $this->log(LogLevel::DEBUG, 'Fetch contact details for id ' . $contactId);

        $requestData = [
            'command'    => 'get_contact',
            'contact_id' => $contactId,
        ];

        // perform the API call
        $response = $this->performRawApiCall($requestData);

        $this->log(LogLevel::DEBUG, 'Start parsing result');

        // start parsing XML data using Sabre
        $sabreService = new Service();

        // map certain values to objects
        $sabreService->mapValueObject('{}GetContactResponse', GetContactResponse\GetContactResponse::class);
        $sabreService->mapValueObject('{}GetContactHeader', GetContactResponse\GetContactHeader::class);
        $sabreService->mapValueObject('{}GetContactContent', GetContactResponse\GetContactContent::class);
        $sabreService->mapValueObject('{}Contact', GetContactResponse\Contact::class);
        $sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
        $sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);

        // parse the data
        $resultData = $sabreService->parse($response->getContents());

        // General error, like incorrect api key
        if ($resultData instanceof GeneralResponse\Response) {
            $code = $resultData->ResponseHeader->ResponseCode;
            if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
                throw new DynadotApiException($resultData->ResponseHeader->Error);
            }
        }

        if (!$resultData instanceof GetContactResponse\GetContactResponse) {
            throw new DynadotApiException('We failed to parse the response');
        }

        /**
         * Check if the API call was successful. If not, return the error
         */
        $code = $resultData->GetContactHeader->ResponseCode;
        if ($code != GetContactResponse\GetContactHeader::RESPONSECODE_OK) {
            throw new DynadotApiException($resultData->GetContactHeader->Error);
        }

        return $resultData->GetContactContent->Contact;
    }
}


1		<?php
2
3		namespace Level23\Dynadot;
4
5		use Psr\Log\LogLevel;
6		use Sabre\Xml\Reader;
7		use GuzzleHttp\Client;
8		use Sabre\Xml\Service;
9		use Psr\Log\LoggerInterface;
10		use Psr\Http\Message\StreamInterface;
11		use Level23\Dynadot\ResultObjects\SetNsResponse;
12		use Level23\Dynadot\ResultObjects\DomainResponse;
13		use Level23\Dynadot\Exception\DynadotApiException;
14		use Level23\Dynadot\ResultObjects\GeneralResponse;
15		use Level23\Dynadot\ResultObjects\DomainInfoResponse;
16		use Level23\Dynadot\ResultObjects\GetContactResponse;
17		use Level23\Dynadot\Exception\ApiHttpCallFailedException;
18		use Level23\Dynadot\ResultObjects\ListDomainInfoResponse;
19		use Level23\Dynadot\Exception\ApiLimitationExceededException;
20
21		/**
22		* Class DynadotApi
23		*
24		* @package Level23\Dynadot
25		* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
26		*/
27		class DynadotApi
28		{
29		const DYNADOT_API_URL = 'https://api.dynadot.com/api3.xml';
30
31		/**
32		* This options array is used by Guzzle.
33		*
34		* We currently use it to set the Mock Handler in unit testing.
35		*
36		* @var array
37		*/
38		protected $guzzleOptions = [];
39
40		/**
41		* Dynadot's API key we should use for HTTP calls.
42		*
43		* @var string
44		*/
45		protected $apiKey;
46
47		/**
48		* Logger for writing debug info
49		*
50		* @var LoggerInterface\|null
51		*/
52		protected $logger;
53
54		/**
55		* Changes boolean values like "no" and "yes" into false and true.
56		*
57		* @return bool
58		* @throws DynadotApiException
59		* @var \Closure
60		*/
61		protected $booleanDeserializer;
62
63		/**
64		* Return the contact id
65		*
66		* @param Reader $reader
67		*
68		* @return int
69		* @var \Closure
70		*/
71		protected $contactIdDeserializer;
72
73		/**
74		* DynadotApi constructor.
75		*
76		* @param string $apiKey The API key we should use while communicating with the Dynadot API.
77		* @param \Psr\Log\LoggerInterface\|null $logger
78		*
79		* @internal param $Logger
80		*/
81	24	public function __construct(string $apiKey, LoggerInterface $logger = null)
82		{
83	24	$this->setApiKey($apiKey);
84	24	$this->logger = $logger;
85
86		/**
87		* Set the default guzzle options
88		*/
89	24	$this->setGuzzleOptions([
90	24	'max' => 5,
91		'referer' => false,
92		'protocols' => ['https'],
93		'connect_timeout' => 30,
94		]);
95
96		/**
97		* Changes boolean values like "no" and "yes" into false and true.
98		*
99		* @param \Sabre\Xml\Reader $reader
100		*
101		* @return bool
102		* @throws \Level23\Dynadot\Exception\DynadotApiException
103		* @throws \Sabre\Xml\LibXMLException
104		* @throws \Sabre\Xml\ParseException
105		*/
106	24	$this->booleanDeserializer = function (Reader $reader) {
107	3	$value = $reader->parseInnerTree();
108
109	3	if ($value != 'yes' && $value != 'no') {
110		throw new DynadotApiException('Error, received incorrect boolean value ' . var_export($value, true));
111		}
112
113	3	return ($value !== 'no');
114		};
115
116		/**
117		* Return the contact id
118		*
119		* @param Reader $reader
120		*
121		* @return int
122		* @throws \Sabre\Xml\LibXMLException
123		* @throws \Sabre\Xml\ParseException
124		*/
125	24	$this->contactIdDeserializer = function (Reader $reader) {
126	3	$children = (array)$reader->parseInnerTree();
127
128	3	return $children[0]['value'];
129		};
130	24	}
131
132		/**
133		* @param array $optionsArray
134		*/
135	24	public function setGuzzleOptions(array $optionsArray)
136		{
137	24	$this->guzzleOptions = $optionsArray;
138	24	}
139
140		/**
141		* Get info about a domain
142		*
143		* @param string $domain
144		*
145		* @return DomainResponse\Domain
146		* @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
147		* @throws \Level23\Dynadot\Exception\DynadotApiException
148		* @throws \Sabre\Xml\ParseException
149		* @throws \GuzzleHttp\Exception\GuzzleException
150		*/
151	7	public function getDomainInfo(string $domain): DomainResponse\Domain
152		{
153	7	$this->log(LogLevel::INFO, 'Retrieve info for domain: ' . $domain);
154
155		$requestData = [
156	7	'domain' => $domain,
157	7	'command' => 'domain_info',
158		];
159
160		// perform the API call
161	7	$response = $this->performRawApiCall($requestData);
162
163		// start parsing XML data using Sabre
164	6	$sabreService = new Service();
165
166		// set mapping
167	6	$sabreService->elementMap = [
168	6	'{}NameServers' => function (Reader $reader) {
169
170	2	$nameservers = [];
171	2	$id = '';
172
173	2	$children = (array)$reader->parseInnerTree();
174
175	2	foreach ($children as $child) {
176	2	if ($child['name'] == '{}ServerId') {
177	2	$id = $child['value'];
178	2	} elseif ($child['name'] == '{}ServerName') {
179	2	if (!empty($id) && !empty($child['value'])) {
180	2	$nameserver = new DomainResponse\NameServer();
181
182	2	$nameserver->ServerId = $id;
		0 ignored issues – show Documentation Bug introduced 2021-06-11 10:07 UTC by Report Bug Copy Issue Report The property `$ServerId` was declared of type `integer`, but `$id` is of type `string`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
183	2	$nameserver->ServerName = $child['value'];
184
185	2	$nameservers[] = $nameserver;
186		}
187	2	$id = null;
188		}
189		}
190
191	2	return $nameservers;
192	6	},
193	6	'{}Registrant' => $this->contactIdDeserializer,
194	6	'{}Admin' => $this->contactIdDeserializer,
195	6	'{}Technical' => $this->contactIdDeserializer,
196	6	'{}Billing' => $this->contactIdDeserializer,
197	6	'{}isForSale' => $this->booleanDeserializer,
198	6	'{}Hold' => $this->booleanDeserializer,
199	6	'{}RegistrantUnverified' => $this->booleanDeserializer,
200	6	'{}UdrpLocked' => $this->booleanDeserializer,
201	6	'{}Disabled' => $this->booleanDeserializer,
202	6	'{}Locked' => $this->booleanDeserializer,
203	6	'{}WithAds' => $this->booleanDeserializer,
204		];
205
206		// map certain values to objects
207	6	$sabreService->mapValueObject('{}DomainInfoResponse', DomainInfoResponse\DomainInfoResponse::class);
208	6	$sabreService->mapValueObject('{}DomainInfoResponseHeader', DomainInfoResponse\DomainInfoResponseHeader::class);
209	6	$sabreService->mapValueObject('{}DomainInfoContent', DomainInfoResponse\DomainInfoContent::class);
210	6	$sabreService->mapValueObject('{}Domain', DomainResponse\Domain::class);
211	6	$sabreService->mapValueObject('{}NameServerSettings', DomainResponse\NameServerSettings::class);
212	6	$sabreService->mapValueObject('{}Whois', DomainResponse\Whois::class);
213	6	$sabreService->mapValueObject('{}Folder', DomainResponse\Folder::class);
214	6	$sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
215	6	$sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);
216
217	6	$this->log(LogLevel::DEBUG, 'Start parsing response XML');
218
219		// parse the data
220	6	$resultData = $sabreService->parse($response->getContents());
221
222		// General error, like incorrect api key
223	5	if ($resultData instanceof GeneralResponse\Response) {
224	1	$code = $resultData->ResponseHeader->ResponseCode;
225	1	if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
226	1	throw new DynadotApiException($resultData->ResponseHeader->Error);
227		}
228		}
229
230	4	if (!$resultData instanceof DomainInfoResponse\DomainInfoResponse) {
231	1	throw new DynadotApiException('We failed to parse the response');
232		}
233
234		/**
235		* Check if the API call was successful. If not, return the error
236		*/
237	3	$code = $resultData->DomainInfoResponseHeader->SuccessCode;
238	3	if ($code != DomainInfoResponse\DomainInfoResponseHeader::SUCCESSCODE_OK) {
239	1	throw new DynadotApiException($resultData->DomainInfoResponseHeader->Error);
240		}
241
242	2	$this->log(LogLevel::DEBUG, 'Returning domain info');
243
244		// Here we know our API call was succesful, return the domain info.
245	2	return $resultData->DomainInfoContent->Domain;
246		}
247
248		/**
249		* Log a message to our logger, if we have any.
250		*
251		* @param string $level
252		* @param string $message
253		*/
254	23	protected function log(string $level, string $message): void
255		{
256	23	if ($this->logger instanceof LoggerInterface) {
257	1	$this->logger->log($level, $message);
258		}
259	23	}
260
261		/**
262		* Performs the actual API call (internal method)
263		*
264		* @param array $requestData
265		*
266		* @return \Psr\Http\Message\StreamInterface
267		* @throws \GuzzleHttp\Exception\GuzzleException
268		* @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
269		*/
270	22	protected function performRawApiCall(array $requestData): StreamInterface
271		{
272	22	$this->log(LogLevel::DEBUG, 'Perform raw call: ' . var_export($requestData, true));
273
274		// transform the request data into a valid query string
275	22	$requestDataHttp = http_build_query($requestData);
276
277		// spawn Guzzle
278	22	$client = new Client($this->guzzleOptions);
279
280	22	$url = self::DYNADOT_API_URL .
281	22	'?key=' . urlencode($this->getApiKey()) .
282	22	($requestDataHttp ? '&' . $requestDataHttp : '');
283
284	22	$this->log(LogLevel::DEBUG, 'Start new guzzle request with URL: ' . $url);
285
286		// start a request with out API key and optionally our request data
287	22	$response = $client->request('GET', $url);
288
289	22	$this->log(LogLevel::DEBUG, 'Received response with status code ' . $response->getStatusCode());
290
291		// if we did not get a HTTP 200 response, our HTTP call failed (which is different from a failed API call)
292	22	if ($response->getStatusCode() != 200) {
293	1	$this->log(LogLevel::ALERT, 'Received wrong HTTP status code: ' . $response->getStatusCode());
294		// not ok
295	1	throw new ApiHttpCallFailedException(
296	1	'HTTP API call failed, expected 200 status, got ' . $response->getStatusCode()
297		);
298		}
299
300		// Return the response body (which is a stream coming from Guzzle).
301		// Sabre XML semi-handles streams (it will just get the contents of the stream using stream_get_contents) so
302		// this should work! ;)
303	21	return $response->getBody();
304		}
305
306		/**
307		* @return string
308		*/
309	23	public function getApiKey(): string
310		{
311	23	return $this->apiKey;
312		}
313
314		/**
315		* @param string $apiKey
316		*/
317	24	public function setApiKey(string $apiKey)
318		{
319	24	$this->apiKey = $apiKey;
320	24	}
321
322		/**
323		* Set nameservers for a domain (max 13). An exception will be thrown in case of an error.
324		*
325		* @param string $domain The domain where to set the nameservers for.
326		* @param array $nameservers
327		*
328		* @throws \GuzzleHttp\Exception\GuzzleException
329		* @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
330		* @throws \Level23\Dynadot\Exception\ApiLimitationExceededException
331		* @throws \Level23\Dynadot\Exception\DynadotApiException
332		* @throws \Sabre\Xml\ParseException
333		*/
334	6	public function setNameserversForDomain(string $domain, array $nameservers)
335		{
336	6	$this->log(LogLevel::DEBUG, 'Set ' . sizeof($nameservers) . ' nameservers for domain ' . $domain);
337		$requestData = [
338	6	'command' => 'set_ns',
339	6	'domain' => $domain,
340		];
341
342	6	if (sizeof($nameservers) > 13) {
343		// index starts at 0, so we should check if the index is greater than 12 (which is 13 nameservers)
344	1	throw new ApiLimitationExceededException(
345	1	'Can not define more than 13 nameservers through the API'
346		);
347		}
348
349	5	$idx = 0;
350		// check if there are more than 13 nameservers defined
351	5	foreach ($nameservers as $nameserver) {
352	5	$requestData['ns' . $idx++] = $nameserver;
353		}
354
355		// perform the API call
356	5	$response = $this->performRawApiCall($requestData);
357
358	5	$this->log(LogLevel::DEBUG, 'API call execured, parsing response...');
359
360		// start parsing XML data using Sabre
361	5	$sabreService = new Service();
362
363		// map certain values to objects
364	5	$sabreService->mapValueObject('{}SetNsResponse', SetNsResponse\SetNsResponse::class);
365	5	$sabreService->mapValueObject('{}SetNsHeader', SetNsResponse\SetNsHeader::class);
366	5	$sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
367	5	$sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);
368
369		// parse the data
370	5	$resultData = $sabreService->parse($response->getContents());
371
372		// General error, like incorrect api key
373	4	if ($resultData instanceof GeneralResponse\Response) {
374	1	$code = $resultData->ResponseHeader->ResponseCode;
375	1	if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
376	1	throw new DynadotApiException($resultData->ResponseHeader->Error);
377		}
378		}
379
380	3	if (!$resultData instanceof SetNsResponse\SetNsResponse) {
381	1	throw new DynadotApiException('We failed to parse the response');
382		}
383
384		/**
385		* Check if the API call was successful. If not, return the error
386		*/
387	2	$code = $resultData->SetNsHeader->SuccessCode;
388	2	if ($code != SetNsResponse\SetNsHeader::SUCCESSCODE_OK) {
389	1	throw new DynadotApiException($resultData->SetNsHeader->Error);
390		}
391
392	1	$this->log(LogLevel::DEBUG, 'Received correct response. Everything is ok!');
393	1	}
394
395		/**
396		* List all domains in the account. We will return an array with Domain objects
397		*
398		* @return DomainResponse\Domain[]
399		* @throws \GuzzleHttp\Exception\GuzzleException
400		* @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
401		* @throws \Level23\Dynadot\Exception\DynadotApiException
402		* @throws \Sabre\Xml\ParseException
403		*/
404	5	public function getDomainList(): array
405		{
406	5	$this->log(LogLevel::DEBUG, 'Start retrieving all domains');
407		$requestData = [
408	5	'command' => 'list_domain',
409		];
410
411		// perform the API call
412	5	$response = $this->performRawApiCall($requestData);
413
414	5	$this->log(LogLevel::DEBUG, 'Start parsing response XML');
415
416		// start parsing XML data using Sabre
417	5	$sabreService = new Service();
418
419		// set mapping
420	5	$sabreService->elementMap = [
421	5	'{}NameServers' => function (Reader $reader) {
422
423		$nameservers = [];
424		$id = '';
425
426		$children = (array)$reader->parseInnerTree();
427
428		foreach ($children as $child) {
429		if ($child['name'] == '{}ServerId') {
430		$id = $child['value'];
431		} elseif ($child['name'] == '{}ServerName') {
432		if (!empty($id) && !empty($child['value'])) {
433		$nameserver = new DomainResponse\NameServer();
434		$nameserver->ServerId = $id;
		0 ignored issues – show Documentation Bug introduced 2021-06-11 10:07 UTC by Report Bug Copy Issue Report The property `$ServerId` was declared of type `integer`, but `$id` is of type `string`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
435		$nameserver->ServerName = $child['value'];
436
437		$nameservers[] = $nameserver;
438		}
439		$id = null;
440		}
441		}
442
443		return $nameservers;
444	5	},
445	5	'{}DomainInfoList' => function (Reader $reader) {
446	1	$domains = [];
447
448	1	$tree = (array)$reader->parseInnerTree();
449	1	foreach ($tree as $item) {
450	1	$domains[] = $item['value'][0]['value'];
451		}
452
453	1	return $domains;
454	5	},
455	5	'{}Registrant' => $this->contactIdDeserializer,
456	5	'{}Admin' => $this->contactIdDeserializer,
457	5	'{}Technical' => $this->contactIdDeserializer,
458	5	'{}Billing' => $this->contactIdDeserializer,
459	5	'{}isForSale' => $this->booleanDeserializer,
460	5	'{}Hold' => $this->booleanDeserializer,
461	5	'{}RegistrantUnverified' => $this->booleanDeserializer,
462	5	'{}UdrpLocked' => $this->booleanDeserializer,
463	5	'{}Disabled' => $this->booleanDeserializer,
464	5	'{}Locked' => $this->booleanDeserializer,
465	5	'{}WithAds' => $this->booleanDeserializer,
466		];
467
468		// map certain values to objects
469	5	$sabreService->mapValueObject('{}ListDomainInfoResponse', ListDomainInfoResponse\ListDomainInfoResponse::class);
470	5	$sabreService->mapValueObject('{}ListDomainInfoHeader', ListDomainInfoResponse\ListDomainInfoHeader::class);
471	5	$sabreService->mapValueObject('{}ListDomainInfoContent', ListDomainInfoResponse\ListDomainInfoContent::class);
472	5	$sabreService->mapValueObject('{}Domain', DomainResponse\Domain::class);
473	5	$sabreService->mapValueObject('{}NameServerSettings', DomainResponse\NameServerSettings::class);
474	5	$sabreService->mapValueObject('{}Whois', DomainResponse\Whois::class);
475	5	$sabreService->mapValueObject('{}Folder', DomainResponse\Folder::class);
476	5	$sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
477	5	$sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);
478
479		// parse the data
480	5	$resultData = $sabreService->parse($response->getContents());
481
482		// General error, like incorrect api key
483	4	if ($resultData instanceof GeneralResponse\Response) {
484	1	$code = $resultData->ResponseHeader->ResponseCode;
485	1	if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
486	1	throw new DynadotApiException($resultData->ResponseHeader->Error);
487		}
488		}
489
490	3	if (!$resultData instanceof ListDomainInfoResponse\ListDomainInfoResponse) {
491	1	throw new DynadotApiException('We failed to parse the response');
492		}
493
494		/**
495		* Check if the API call was successful. If not, return the error
496		*/
497	2	$code = $resultData->ListDomainInfoHeader->ResponseCode;
498	2	if ($code != ListDomainInfoResponse\ListDomainInfoHeader::RESPONSECODE_OK) {
499	1	throw new DynadotApiException($resultData->ListDomainInfoHeader->Error);
500		}
501
502	1	return $resultData->ListDomainInfoContent->DomainInfoList;
503		}
504
505		/**
506		* Get contact information for a specific contact ID
507		*
508		* @param int $contactId The contact ID we should request
509		*
510		* @return GetContactResponse\Contact
511		* @throws \GuzzleHttp\Exception\GuzzleException
512		* @throws \Level23\Dynadot\Exception\ApiHttpCallFailedException
513		* @throws \Level23\Dynadot\Exception\DynadotApiException
514		* @throws \Sabre\Xml\ParseException
515		*/
516	5	public function getContactInfo(int $contactId): GetContactResponse\Contact
517		{
518	5	$this->log(LogLevel::DEBUG, 'Fetch contact details for id ' . $contactId);
519
520		$requestData = [
521	5	'command' => 'get_contact',
522	5	'contact_id' => $contactId,
523		];
524
525		// perform the API call
526	5	$response = $this->performRawApiCall($requestData);
527
528	5	$this->log(LogLevel::DEBUG, 'Start parsing result');
529
530		// start parsing XML data using Sabre
531	5	$sabreService = new Service();
532
533		// map certain values to objects
534	5	$sabreService->mapValueObject('{}GetContactResponse', GetContactResponse\GetContactResponse::class);
535	5	$sabreService->mapValueObject('{}GetContactHeader', GetContactResponse\GetContactHeader::class);
536	5	$sabreService->mapValueObject('{}GetContactContent', GetContactResponse\GetContactContent::class);
537	5	$sabreService->mapValueObject('{}Contact', GetContactResponse\Contact::class);
538	5	$sabreService->mapValueObject('{}Response', GeneralResponse\Response::class);
539	5	$sabreService->mapValueObject('{}ResponseHeader', GeneralResponse\ResponseHeader::class);
540
541		// parse the data
542	5	$resultData = $sabreService->parse($response->getContents());
543
544		// General error, like incorrect api key
545	4	if ($resultData instanceof GeneralResponse\Response) {
546	1	$code = $resultData->ResponseHeader->ResponseCode;
547	1	if ($code != GeneralResponse\ResponseHeader::RESPONSECODE_OK) {
548	1	throw new DynadotApiException($resultData->ResponseHeader->Error);
549		}
550		}
551
552	3	if (!$resultData instanceof GetContactResponse\GetContactResponse) {
553	1	throw new DynadotApiException('We failed to parse the response');
554		}
555
556		/**
557		* Check if the API call was successful. If not, return the error
558		*/
559	2	$code = $resultData->GetContactHeader->ResponseCode;
560	2	if ($code != GetContactResponse\GetContactHeader::RESPONSECODE_OK) {
561	1	throw new DynadotApiException($resultData->GetContactHeader->Error);
562		}
563
564	1	return $resultData->GetContactContent->Contact;
565		}
566		}
567

level23 / dynadot-api

Pull Request — master (#3)

DynadotApi::getDomainList() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like