CarrierServer.php

<?php

namespace Ivoz\Provider\Domain\Model\CarrierServer;

use Assert\Assertion;

/**
 * CarrierServer
 */
class CarrierServer extends CarrierServerAbstract implements CarrierServerInterface
{
    use CarrierServerTrait;

    /**
     * @codeCoverageIgnore
     * @return array<string, mixed>
     */
    public function getChangeSet(): array
    {
        return parent::getChangeSet();
    }

    /**
     * Get id
     * @codeCoverageIgnore
     * @return integer
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    protected function sanitizeValues(): void
    {
        $this->sanitizeBrandByCarrier();
        $this->sanitizeAuth();
    }

    protected function sanitizeBrandByCarrier(): void
    {
        $isNew = !$this->getId();
        $isNotNewAndCarrierHasChanged =
            !$isNew
            && $this->hasChanged('carrierId');

        if ($isNotNewAndCarrierHasChanged || !$this->getBrand()->getId()) {
            $brand = $this
                ->getCarrier()
                ->getBrand();

            $this->setBrand($brand);
        }
    }

    protected function sanitizeAuth(): void
    {
        if ($this->getAuthNeeded() === 'no') {
            $this->setAuthUser(null);
            $this->setAuthPassword(null);
        }
    }

    public function setOutboundProxy(?string $outboundProxy = null): static
    {
        if ($outboundProxy) {
            $outboundProxy = trim($outboundProxy);

            if ($outboundProxy === '') {
                return parent::setOutboundProxy(null);
            }

            if (str_contains($outboundProxy, ' ')) {
                throw new \DomainException('Outbound Proxy must not contain spaces.', 70001);
            }

            $parts = explode(':', $outboundProxy);

            if (count($parts) > 2) {
                throw new \DomainException('Outbound Proxy must be in format IP or IP:port, not more than one colon.', 70002);
            }

            $ip = $parts[0];

            if (!preg_match('/^(\d{1,3}\.){3}\d{1,3}$/', $ip)) {
                throw new \DomainException('IP format is invalid in Outbound Proxy.', 70003);
            }

            foreach (explode('.', $ip) as $octet) {
                $value = (int) $octet;
                if ($value < 0 || $value > 255) {
                    throw new \DomainException('Each segment of the IP must be between 0 and 255.', 70006);
                }
            }

            $this->setIp($ip);

            if (isset($parts[1])) {
                $port = $parts[1];

                if (!ctype_digit($port)) {
                    throw new \DomainException('Port must be a numeric value.', 70007);
                }

                $port = (int) $port;
                if ($port < 1 || $port > 65535) {
                    throw new \DomainException('Port must be between 1 and 65535.', 70004);
                }

                $this->setPort($port);
            } else {
                $this->setPort(5060);
            }
        }

        return parent::setOutboundProxy($outboundProxy);
    }

    /**
     * {@inheritDoc}
     */
    public function setIp(?string $ip = null): static
    {
        if (!is_null($ip)) {
            Assertion::ip($ip);
        }
        return parent::setIp($ip);
    }

    public function getName(): string
    {
        return
            sprintf(
                'b%dc%ds%d',
                (int) $this->getBrand()->getId(),
                (int) $this->getCarrier()->getId(),
                (int) $this->getId()
            );
    }

    protected function setAuthPassword(?string $authPassword = null): static
    {
        if ($authPassword) {
            $authPassword = trim($authPassword);
        }

        return parent::setAuthPassword($authPassword);
    }

    public function setSipProxy(?string $sipProxy = null): static
    {
        if ($sipProxy !== null) {
            $sipProxy = trim($sipProxy);

            if ($sipProxy === '') {
                throw new \InvalidArgumentException('SIP Proxy cannot be empty.');
            }

            if (str_contains($sipProxy, ' ')) {
                throw new \InvalidArgumentException('SIP Proxy must not contain spaces.');
            }

            $parts = explode(':', $sipProxy);

            if (count($parts) > 2) {
                throw new \DomainException('SIP Proxy can only contain one colon at most.');
            }

            $host = $parts[0];

            if (preg_match('/^(\d{1,3}\.){3}\d{1,3}$/', $host)) {
                foreach (explode('.', $host) as $octet) {
                    $value = (int) $octet;
                    if ($value < 0 || $value > 255) {
                        throw new \DomainException('Each segment of the IP must be between 0 and 255.');
                    }
                }
            } else {
                if (str_contains($host, ':') || str_contains($host, ' ')) {
                    throw new \DomainException('Invalid domain format for SIP Proxy.');
                }

                if (!str_contains($host, '.')) {
                    throw new \DomainException('Domain must contain at least one dot.');
                }

                if (str_ends_with($host, '.')) {
                    throw new \DomainException('Domain must not end with a dot.');
                }
            }

            if (isset($parts[1])) {
                $port = $parts[1];

                if (!ctype_digit($port)) {
                    throw new \DomainException('SIP Proxy port must be numeric.');
                }

                $port = (int) $port;
                if ($port < 1 || $port > 65535) {
                    throw new \DomainException('SIP Proxy port must be between 1 and 65535.');
                }

                $this->setPort($port);
            } else {
                $this->setPort(5060);
            }

            $this->setHostname($host);
        }

        return parent::setSipProxy($sipProxy);
    }
}