ElevenLabs\Api\Definition\Parameters

Complexity

Total Complexity

26

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Test Coverage

Coverage

98.48%

Importance

Changes

0

18 Methods

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

<?php
namespace ElevenLabs\Api\Definition;

class Parameters implements \Serializable, \IteratorAggregate
{


    /**
     * @var Parameter[]
     */
    private $parameters;

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

    public function getIterator()
    {
        return new \ArrayIterator($this->parameters);
    }

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

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

    /**
     * JSON Schema for a the body
     *
     * @return \stdClass|null
     */
    public function getBodySchema()
    {
        return $this->getBody()->getSchema();
    }

    /**
     * @return bool
     */
    public function hasQueryParametersSchema()
    {
        return ($this->getSchema($this->getQuery()) !== null);
    }

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

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

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

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

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

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

    /**
     * @return Parameter|null
     */
    public function getBody()
    {
        $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
     *
     * @return \stdClass|null
     */
    private function getSchema(array $parameters)
    {
        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;
    }

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

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

    private function findByLocation($location)
    {
        return array_filter(
            $this->parameters,
            function (Parameter $parameter) use ($location) {
                return $parameter->getLocation() === $location;
            }
        );
    }

    private function addParameter(Parameter $parameter)
    {
        if (!in_array($parameter->getLocation(), Parameter::LOCATIONS, true)) {
            throw new \InvalidArgumentException(
                sprintf(
                    '%s is not a supported parameter location, supported: %s',
                    $parameter->getLocation(),
                    implode(', ', Parameter::LOCATIONS)
                )
            );
        }

        $this->parameters[$parameter->getName()] = $parameter;
    }
}