ElevenLabs\Api\Definition\Parameters

Complexity

Total Complexity

28

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Test Coverage

Coverage

29.23%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	serialize()	0	3	1
A	hasPathSchema()	0	3	1
A	addParameter()	0	3	1
A	unserialize()	0	4	1
A	__construct()	0	4	2
A	getIterator()	0	4	2
A	getHeadersSchema()	0	3	1
A	getQueryParametersSchema()	0	3	1
A	hasBodySchema()	0	5	2
A	getQuery()	0	3	1
A	hasQueryParametersSchema()	0	3	1
A	getPathSchema()	0	3	1
A	getBodySchema()	0	3	1
A	findByLocation()	0	6	1
A	getPath()	0	3	1
A	getHeaders()	0	3	1
A	getSchema()	0	18	4
A	getBody()	0	8	2
A	getByName()	0	7	2
A	hasHeadersSchema()	0	3	1

<?php declare(strict_types=1);

namespace ElevenLabs\Api\Definition;

use stdClass;

class Parameters implements \Serializable, \IteratorAggregate
{
    /**
     * @var Parameter[]
     */
    private $parameters = [];

    public function __construct(array $parameters)
    {
        foreach ($parameters as $parameter) {
            $this->addParameter($parameter);
        }
    }

    // IteratorAggregate
    public function getIterator(): iterable
    {
        foreach ($this->parameters as $name => $parameter) {
            yield $name => $parameter;
        }
    }

    public function hasBodySchema(): bool
    {
        $body = $this->getBody();

        return ($body !== null && $body->hasSchema());
    }

    /**
     * JSON Schema for the body.
     */
    public function getBodySchema(): ?stdClass
    {
        return $this->getBody()->getSchema();
    }

    public function hasPathSchema(): bool
    {
        return $this->getPathSchema() !== null;
    }

    /**
     * JSON Schema for the path parameters.
     */
    public function getPathSchema(): ?stdClass
    {
        return $this->getSchema($this->getPath());
    }

    public function hasQueryParametersSchema(): bool
    {
        return $this->getQueryParametersSchema() !== null;
    }

    /**
     * JSON Schema for the query parameters.
     */
    public function getQueryParametersSchema(): ?stdClass
    {
        return $this->getSchema($this->getQuery());
    }

    public function hasHeadersSchema(): bool
    {
        return $this->getHeadersSchema() !== null;
    }

    /**
     * JSON Schema for the headers.
     */
    public function getHeadersSchema(): ?stdClass
    {
        return $this->getSchema($this->getHeaders());
    }

    /**
     * @return Parameter[]
     */
    public function getPath(): array
    {
        return $this->findByLocation('path');
    }

    /**
     * @return Parameter[]
     */
    public function getQuery(): array
    {
        return $this->findByLocation('query');
    }

    /**
     * @return Parameter[]
     */
    public function getHeaders(): array
    {
        return $this->findByLocation('header');
    }

    public function getBody(): ?Parameter
    {
        $match = $this->findByLocation('body');
        if (empty($match)) {
            return null;
        }

        return current($match);
    }

    /**
     * Get one request parameter by name
     *
     * @param string $name
     * @return Parameter|null
     */
    public function getByName($name)
    {
        if (! isset($this->parameters[$name])) {
            return null;
        }

        return $this->parameters[$name];
    }

    /**
     * @param Parameter[] $parameters
     */
    private function getSchema(array $parameters): ?stdClass
    {
        if (empty($parameters)) {
            return null;
        }

        $schema = new \stdClass();
        $schema->type = 'object';
        $schema->required = [];
        $schema->properties = new \stdClass();
        foreach ($parameters as $name => $parameter) {
            if ($parameter->isRequired()) {
                $schema->required[] = $parameter->getName();
            }
            $schema->properties->{$name} = $parameter->getSchema();
        }

        return $schema;
    }

    // Serializable
    public function serialize()
    {
        return serialize(['parameters' => $this->parameters]);
    }

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

    /**
     * @return Parameter[]
     */
    private function findByLocation($location): array
    {
        return array_filter(
            $this->parameters,
            function (Parameter $parameter) use ($location) {
                return $parameter->getLocation() === $location;
            }
        );
    }

    private function addParameter(Parameter $parameter)
    {
        $this->parameters[$parameter->getName()] = $parameter;
    }
}