ElevenLabs\Api\Definition\RequestDefinition

Complexity

Total Complexity

21

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Test Coverage

Coverage

60%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getPathSchema()	0	3	1
A	getMethod()	0	3	1
A	getResponseDefinition()	0	16	3
A	getBodySchema()	0	3	1
A	getContentTypes()	0	3	1
A	getOperationId()	0	3	1
A	hasQueryParametersSchema()	0	3	1
A	getHeadersSchema()	0	3	1
A	hasBodySchema()	0	3	1
A	hasHeadersSchema()	0	3	1
A	unserialize()	0	9	1
A	serialize()	0	9	1
A	__construct()	0	15	2
A	getRequestParameters()	0	3	1
A	addResponseDefinition()	0	3	1
A	getQueryParametersSchema()	0	3	1
A	hasPathSchema()	0	3	1
A	getPathTemplate()	0	3	1

<?php declare(strict_types=1);

namespace ElevenLabs\Api\Definition;

use stdClass;

class RequestDefinition implements \Serializable, MessageDefinition
{
    /** @var string */
    private $method;

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

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

    /** @var Parameters */
    private $parameters;

    /** @var string[] */
    private $contentTypes;

    /** @var ResponseDefinition[] */
    private $responses;

    /**
     * @param string[] $contentTypes
     * @param ResponseDefinition[] $responses
     */
    public function __construct(
        string $method,
        string $operationId,
        string $pathTemplate,
        Parameters $parameters,
        array $contentTypes,
        array $responses
    ) {
        $this->method = $method;
        $this->operationId = $operationId;
        $this->pathTemplate = $pathTemplate;
        $this->parameters = $parameters;
        $this->contentTypes = $contentTypes;
        foreach ($responses as $response) {
            $this->addResponseDefinition($response);
        }
    }

    public function getMethod(): string
    {
        return $this->method;
    }

    public function getOperationId(): string
    {
        return $this->operationId;
    }

    public function getPathTemplate(): string
    {
        return $this->pathTemplate;
    }

    public function getRequestParameters(): Parameters
    {
        return $this->parameters;
    }

    public function getContentTypes(): array
    {
        return $this->contentTypes;
    }

    public function getResponseDefinition(int $statusCode): ResponseDefinition
    {
        if (isset($this->responses[$statusCode])) {
            return $this->responses[$statusCode];
        }

        if (isset($this->responses['default'])) {
            return $this->responses['default'];
        }

        throw new \InvalidArgumentException(
            sprintf(
                'No response definition for %s %s is available for status code %s',
                $this->method,
                $this->pathTemplate,
                $statusCode
            )
        );
    }

    public function hasBodySchema(): bool
    {
        return $this->parameters->hasBodySchema();
    }

    public function getBodySchema(): ?stdClass
    {
        return $this->parameters->getBodySchema();
    }

    public function hasHeadersSchema(): bool
    {
        return $this->parameters->hasHeadersSchema();
    }

    public function getHeadersSchema(): ?stdClass
    {
        return $this->parameters->getHeadersSchema();
    }

    public function hasPathSchema(): bool
    {
        return $this->parameters->hasPathSchema();
    }

    public function getPathSchema(): ?stdClass
    {
        return $this->parameters->getPathSchema();
    }

    public function hasQueryParametersSchema(): bool
    {
        return $this->parameters->hasQueryParametersSchema();
    }

    public function getQueryParametersSchema(): ?stdClass
    {
        return $this->parameters->getQueryParametersSchema();
    }

    // Serializable
    public function serialize()
    {
        return serialize([
            'method' => $this->method,
            'operationId' => $this->operationId,
            'pathTemplate' => $this->pathTemplate,
            'parameters' => $this->parameters,
            'contentTypes' => $this->contentTypes,
            'responses' => $this->responses
        ]);
    }

    // Serializable
    public function unserialize($serialized)
    {
        $data = unserialize($serialized);
        $this->method = $data['method'];
        $this->operationId = $data['operationId'];
        $this->pathTemplate = $data['pathTemplate'];
        $this->parameters = $data['parameters'];
        $this->contentTypes = $data['contentTypes'];
        $this->responses = $data['responses'];
    }

    private function addResponseDefinition(ResponseDefinition $response)
    {
        $this->responses[$response->getStatusCode()] = $response;
    }
}