api.mustache

<?php

namespace {{apiPackage}};

use {{invokerPackage}}\Algolia;
use {{invokerPackage}}\ApiException;
use {{invokerPackage}}\Configuration\{{configClassname}};
use {{invokerPackage}}\ObjectSerializer;
use {{invokerPackage}}\RetryStrategy\ApiWrapper;
use {{invokerPackage}}\RetryStrategy\ApiWrapperInterface;
use {{invokerPackage}}\RetryStrategy\ClusterHosts;

/**
 * {{classname}} Class Doc Comment
 *
 * @category Class
 * @package  {{invokerPackage}}
 */
{{#operations}}class {{classname}}
{
    /**
     * @var ApiWrapperInterface
     */
    protected $api;

    /**
     * @var {{configClassname}}
     */
    protected $config;

    /**
     * @param {{configClassname}} $config
     * @param ApiWrapperInterface $apiWrapper
     */
    public function __construct(ApiWrapperInterface $apiWrapper, {{configClassname}} $config)
    {
        $this->config = $config;
        $this->api = $apiWrapper;
    }

    {{#hasRegionalHost}}
    /**
     * Instantiate the client with basic credentials and region
     *
     * @param string $appId  Application ID
     * @param string $apiKey Algolia API Key
     * @param string $region Region
     */
    public static function create($appId = null, $apiKey = null, $region = null)
    {
        $allowedRegions = [{{#allowedRegions}}'{{.}}'{{^-last}},{{/-last}}{{/allowedRegions}}];
        $config = {{configClassname}}::create($appId, $apiKey, $region, $allowedRegions);

        return static::createWithConfig($config);
    }
    {{/hasRegionalHost}}

    {{^hasRegionalHost}}
    /**
     * Instantiate the client with basic credentials
     *
     * @param string $appId  Application ID
     * @param string $apiKey Algolia API Key
     */
    public static function create($appId = null, $apiKey = null)
    {
        return static::createWithConfig({{configClassname}}::create($appId, $apiKey));
    }
    {{/hasRegionalHost}}
    
    /**
     * Instantiate the client with configuration
     *
     * @param {{configClassname}} $config Configuration
     */
    public static function createWithConfig({{configClassname}} $config)
    {
        $config = clone $config;

        {{#useCache}}
        $cacheKey = sprintf('%s-clusterHosts-%s', __CLASS__, $config->getAppId());

        if ($hosts = $config->getHosts()) {
            // If a list of hosts was passed, we ignore the cache
            $clusterHosts = ClusterHosts::create($hosts);
        } elseif (false === ($clusterHosts = ClusterHosts::createFromCache($cacheKey))) {
            // We'll try to restore the ClusterHost from cache, if we cannot
            // we create a new instance and set the cache key
            $clusterHosts = ClusterHosts::createFromAppId($config->getAppId())
                ->setCacheKey($cacheKey);
        }
        {{/useCache}}

        {{^useCache}}
        if ($hosts = $config->getHosts()) {
            // If a list of hosts was passed, we ignore the cache
            $clusterHosts = ClusterHosts::create($hosts);
        } else {
            $url = str_replace('{region}', $config->getRegion(), '{{{host}}}');
            $clusterHosts = ClusterHosts::create($url);
        }
        {{/useCache}}

        $apiWrapper = new ApiWrapper(
            Algolia::getHttpClient(),
            $config,
            $clusterHosts
        );

        return new static($apiWrapper, $config);
    }

    /**
     * @return {{configClassname}}
     */
    public function getClientConfig()
    {
        return $this->config;
    }

{{#operation}}
    /**
{{#summary}}
     * {{.}}
{{/summary}}
     *
{{#description}}
     * {{.}}
     *
{{/description}}
{{#allParams}}
     * @param {{#isString}}string{{/isString}}{{#isInteger}}int{{/isInteger}}{{#isBoolean}}bool{{/isBoolean}}{{^isString}}{{^isInteger}}{{^isBoolean}}array{{/isBoolean}}{{/isInteger}}{{/isString}} ${{paramName}}{{#description}} {{.}}{{/description}}{{^description}} {{paramName}}{{/description}} {{#required}}(required){{/required}}{{^required}}(optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/required}}{{#isDeprecated}} (deprecated){{/isDeprecated}}
{{#isModel}}
    {{#vars}}
     * - ${{paramName}}{{> arrayParam}}
    {{/vars}}
     * @see {{{dataType}}}
{{/isModel}}
{{/allParams}}
     * @param array $requestOptions The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
     *
     * @return {{#returnType}}{{#responses}}{{#dataType}}{{#-first}}array<string, mixed>|{{{dataType}}}{{/-first}}{{/dataType}}{{/responses}}{{/returnType}}{{^returnType}}void{{/returnType}}
  {{#isDeprecated}}
     * @deprecated
  {{/isDeprecated}}
     */
    public function {{operationId}}({{^vendorExtensions.x-group-parameters}}{{#allParams}}${{paramName}}{{^required}} = null{{/required}}, {{/allParams}}{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}$associative_array{{/vendorExtensions.x-group-parameters}} $requestOptions = [])
    {
        {{#vendorExtensions.x-group-parameters}}
        // unbox the parameters from the associative array
        {{#allParams}}
        ${{paramName}} = array_key_exists('{{paramName}}', $associative_array) ? $associative_array['{{paramName}}'] : {{{defaultValue}}}{{^defaultValue}}null{{/defaultValue}};
        {{/allParams}}

        {{/vendorExtensions.x-group-parameters}}
        {{#allParams}}
        {{#required}}
        // verify the required parameter '{{paramName}}' is set
        if (${{paramName}} === null || (is_array(${{paramName}}) && count(${{paramName}}) === 0)) {
            throw new \InvalidArgumentException(
                'Missing the required parameter ${{paramName}} when calling {{operationId}}'
            );
        }
        {{/required}}
        {{#hasValidation}}
        {{#maxLength}}
        if ({{^required}}${{paramName}} !== null && {{/required}}strlen(${{paramName}}) > {{maxLength}}) {
            throw new \InvalidArgumentException('invalid length for "${{paramName}}" when calling {{classname}}.{{operationId}}, must be smaller than or equal to {{maxLength}}.');
        }
        {{/maxLength}}
        {{#minLength}}
        if ({{^required}}${{paramName}} !== null && {{/required}}strlen(${{paramName}}) < {{minLength}}) {
            throw new \InvalidArgumentException('invalid length for "${{paramName}}" when calling {{classname}}.{{operationId}}, must be bigger than or equal to {{minLength}}.');
        }
        {{/minLength}}
        {{#maximum}}
        if ({{^required}}${{paramName}} !== null && {{/required}}${{paramName}} >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{maximum}}) {
            throw new \InvalidArgumentException('invalid value for "${{paramName}}" when calling {{classname}}.{{operationId}}, must be smaller than {{^exclusiveMaximum}}or equal to {{/exclusiveMaximum}}{{maximum}}.');
        }
        {{/maximum}}
        {{#minimum}}
        if ({{^required}}${{paramName}} !== null && {{/required}}${{paramName}} <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{minimum}}) {
            throw new \InvalidArgumentException('invalid value for "${{paramName}}" when calling {{classname}}.{{operationId}}, must be bigger than {{^exclusiveMinimum}}or equal to {{/exclusiveMinimum}}{{minimum}}.');
        }
        {{/minimum}}
        {{#pattern}}
        if ({{^required}}${{paramName}} !== null && {{/required}}!preg_match("{{{pattern}}}", ${{paramName}})) {
            throw new \InvalidArgumentException("invalid value for \"{{paramName}}\" when calling {{classname}}.{{operationId}}, must conform to the pattern {{{pattern}}}.");
        }
        {{/pattern}}
        {{#maxItems}}
        if ({{^required}}${{paramName}} !== null && {{/required}}count(${{paramName}}) > {{maxItems}}) {
            throw new \InvalidArgumentException('invalid value for "${{paramName}}" when calling {{classname}}.{{operationId}}, number of items must be less than or equal to {{maxItems}}.');
        }
        {{/maxItems}}
        {{#minItems}}
        if ({{^required}}${{paramName}} !== null && {{/required}}count(${{paramName}}) < {{minItems}}) {
            throw new \InvalidArgumentException('invalid value for "${{paramName}}" when calling {{classname}}.{{operationId}}, number of items must be greater than or equal to {{minItems}}.');
        }
        {{/minItems}}

        {{/hasValidation}}
        {{/allParams}}

        $resourcePath = '{{{path}}}';
        $queryParameters = [];
        $headers = [];
        $httpBody = [];
        {{#vendorExtensions}}{{#queryParams}}

        {{#isExplode}}
        if (${{paramName}} !== null) {
        {{#style}}
            $queryParameters{{^x-is-custom-request}}['{{baseName}}']{{/x-is-custom-request}} = ${{paramName}};
        {{/style}}
        {{^style}}
            $queryParameters['{{baseName}}'] = ${{paramName}};
        {{/style}}
        }
        {{/isExplode}}
        {{^isExplode}}
        if (is_array(${{paramName}})) {
            ${{paramName}} = ObjectSerializer::serializeCollection(${{paramName}}, '{{style}}{{^style}}{{collectionFormat}}{{/style}}', true);
        }
        if (${{paramName}} !== null) {
            $queryParameters['{{baseName}}'] = ${{paramName}};
        }
        {{/isExplode}}
        {{/queryParams}}{{/vendorExtensions}}
        {{#vendorExtensions}}{{#pathParams}}
        // path params
        {{#collectionFormat}}
        if (is_array(${{paramName}})) {
            ${{paramName}} = ObjectSerializer::serializeCollection(${{paramName}}, '{{collectionFormat}}');
        }
        {{/collectionFormat}}
        if (${{paramName}} !== null) {
            $resourcePath = str_replace(
                {{=<% %>=}}'{<%baseName%>}'<%={{ }}=%>,
                {{#x-is-custom-request}}${{paramName}}{{/x-is-custom-request}}{{^x-is-custom-request}}ObjectSerializer::toPathValue(${{paramName}}){{/x-is-custom-request}},
                $resourcePath
            );
        }
        {{/pathParams}}{{/vendorExtensions}}

        {{#bodyParams}}
        if (isset(${{paramName}})) { 
            $httpBody = ${{paramName}};
        } 
        {{/bodyParams}}
        {{#headerParams}}
            $headers['{{baseName}}'] = ${{paramName}};
        {{/headerParams}}
        {{#servers.0}}
        $operationHosts = [{{#servers}}"{{{url}}}"{{^-last}}, {{/-last}}{{/servers}}];
        if ($this->hostIndex < 0 || $this->hostIndex >= sizeof($operationHosts)) {
            throw new \InvalidArgumentException("Invalid index {$this->hostIndex} when selecting the host. Must be less than ".sizeof($operationHosts));
        }
        $operationHost = $operationHosts[$this->hostIndex];

        {{/servers.0}}

        return $this->sendRequest('{{httpMethod}}', $resourcePath, $headers, $queryParameters, $httpBody, $requestOptions, {{#vendorExtensions.x-use-read-transporter}}true{{/vendorExtensions.x-use-read-transporter}});
    }

    {{/operation}}

    private function sendRequest($method, $resourcePath, $headers, $queryParameters, $httpBody, $requestOptions, $useReadTransporter = false)
    {
        if (!isset($requestOptions['headers'])) {
            $requestOptions['headers'] = [];
        }
        if (!isset($requestOptions['queryParameters'])) {
            $requestOptions['queryParameters'] = [];
        }

        $requestOptions['headers'] = array_merge($headers, $requestOptions['headers']);
        $requestOptions['queryParameters'] = array_merge($queryParameters, $requestOptions['queryParameters']);
        $query = \GuzzleHttp\Psr7\Query::build($requestOptions['queryParameters']);

        return $this->api->sendRequest(
            $method,
            $resourcePath . ($query ? "?{$query}" : ''),
            $httpBody,
            $requestOptions,
            $useReadTransporter
        );
    }
}
{{/operations}}