Numverify\PhoneNumber\ValidPhoneNumber

Complexity

Total Complexity

18

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	jsonSerialize()	0	13	1
A	getNumber()	0	3	1
A	verifyPhoneNumberData()	0	14	4
A	getCountryPrefix()	0	3	1
A	__debugInfo()	0	3	1
A	getLocation()	0	3	1
A	__toString()	0	3	1
A	getLineType()	0	3	1
A	isValid()	0	3	1
A	getCountryName()	0	3	1
A	getCarrier()	0	3	1
A	getInternationalFormat()	0	3	1
A	__construct()	0	14	1
A	getCountryCode()	0	3	1
A	getLocalFormat()	0	3	1

<?php

declare(strict_types=1);

/**
 * This file is part of the Numverify API Client for PHP.
 *
 * (c) 2024 Eric Sizemore <admin@secondversion.com>
 * (c) 2018-2021 Mark Rogoyski <mark@rogoyski.com>
 *
 * This source file is subject to the MIT license. For the full copyright,
 * license information, and credits/acknowledgements, please view the LICENSE
 * and README files that were distributed with this source code.
 */

namespace Numverify\PhoneNumber;

use Numverify\Exception\NumverifyApiResponseException;
use stdClass;

use function implode;

/**
 * ValidPhoneNumber.
 *
 * Role: Value object to represent a phone number that the Numverify returned as valid.
 *
 * @phpstan-import-type ValidPhoneNumberObject from Factory
 *
 * @phpstan-type ValidNumberArray = array{
 *     valid: bool,
 *     number: string,
 *     localFormat: string,
 *     internationalFormat: string,
 *     countryPrefix: string,
 *     countryCode: string,
 *     countryName: string,
 *     location: string,
 *     carrier: string,
 *     lineType: string
 * }
 *
 * @see \Numverify\Tests\PhoneNumber\ValidPhoneNumberTest
 */

class ValidPhoneNumber implements PhoneNumberInterface
{
    /**
     * @var string[]
     */
    private const FIELDS = [
        'valid', 'number', 'local_format', 'international_format', 'country_prefix',
        'country_code', 'country_name', 'location', 'carrier', 'line_type',
    ];

    private readonly string $carrier;

    private readonly string $countryCode;

    private readonly string $countryName;

    private readonly string $countryPrefix;

    private readonly string $internationalFormat;

    private readonly string $lineType;

    private readonly string $localFormat;

    private readonly string $location;

    private readonly string $number;

    private readonly bool $valid;

    /**
     * ValidPhoneNumber constructor.
     *
     * @param ValidPhoneNumberObject $validatedPhoneNumberData
     */
    public function __construct(stdClass $validatedPhoneNumberData)
    {
        $this->verifyPhoneNumberData($validatedPhoneNumberData);

        $this->valid               = (bool) $validatedPhoneNumberData->valid;
        $this->number              = (string) $validatedPhoneNumberData->number;
        $this->localFormat         = $validatedPhoneNumberData->local_format;
        $this->internationalFormat = $validatedPhoneNumberData->international_format;
        $this->countryPrefix       = $validatedPhoneNumberData->country_prefix;
        $this->countryCode         = $validatedPhoneNumberData->country_code;
        $this->countryName         = $validatedPhoneNumberData->country_name;
        $this->location            = $validatedPhoneNumberData->location;
        $this->carrier             = $validatedPhoneNumberData->carrier;
        $this->lineType            = $validatedPhoneNumberData->line_type;
    }

    /**
     * Debug info.
     *
     * @return ValidNumberArray
     */
    public function __debugInfo(): array
    {
        return $this->jsonSerialize();
    }

    /**
     * @inheritDoc
     */
    public function __toString(): string
    {
        return $this->number;
    }

    /**
     * Get carrier.
     */
    public function getCarrier(): string
    {
        return $this->carrier;
    }

    /**
     * Get country code.
     */
    public function getCountryCode(): string
    {
        return $this->countryCode;
    }

    /**
     * Get country name.
     */
    public function getCountryName(): string
    {
        return $this->countryName;
    }

    /**
     * Get country prefix.
     */
    public function getCountryPrefix(): string
    {
        return $this->countryPrefix;
    }

    /**
     * Get international format.
     */
    public function getInternationalFormat(): string
    {
        return $this->internationalFormat;
    }

    /**
     * Get line type.
     */
    public function getLineType(): string
    {
        return $this->lineType;
    }

    /**
     * Get local format.
     */
    public function getLocalFormat(): string
    {
        return $this->localFormat;
    }

    /**
     * Get location.
     */
    public function getLocation(): string
    {
        return $this->location;
    }

    /**
     * @inheritDoc
     */
    public function getNumber(): string
    {
        return $this->number;
    }

    /**
     * @inheritDoc
     */
    public function isValid(): bool
    {
        return true;
    }

    /**
     * @inheritDoc
     *
     * @return ValidNumberArray
     */
    public function jsonSerialize(): array
    {
        return [
            'valid'               => $this->valid,
            'number'              => $this->number,
            'localFormat'         => $this->localFormat,
            'internationalFormat' => $this->internationalFormat,
            'countryPrefix'       => $this->countryPrefix,
            'countryCode'         => $this->countryCode,
            'countryName'         => $this->countryName,
            'location'            => $this->location,
            'carrier'             => $this->carrier,
            'lineType'            => $this->lineType,
        ];
    }

    /**
     * Verify the phone number data contains the expected fields.
     *
     * @throws NumverifyApiResponseException
     */
    private function verifyPhoneNumberData(stdClass $phoneNumberData): void
    {
        $missingFields = [];

        foreach (self::FIELDS as $field) {
            if (!isset($phoneNumberData->$field)) {
                $missingFields[] = $field;
            }
        }

        if ($missingFields !== []) {
            throw new NumverifyApiResponseException(\sprintf(
                'API response does not contain one or more expected fields: %s',
                implode(', ', $missingFields)
            ));
        }
    }
}