617 lines
30 KiB
PHP
617 lines
30 KiB
PHP
<?php
|
|
/**
|
|
* ObjectSerializer
|
|
*
|
|
* PHP version 7.4
|
|
*
|
|
* @category Class
|
|
* @package OpenAPI\Client
|
|
* @author OpenAPI Generator team
|
|
* @link https://openapi-generator.tech
|
|
*/
|
|
|
|
/**
|
|
* Public Gateways API
|
|
*
|
|
* Scaleway Public Gateways are building blocks for your infrastructure on Scaleway's public cloud. They sit at the border of Private Networks and provide access to/from other networks or the Internet. As well as this, Public Gateways offer a host of managed features and services to facilitate the management of resources in your Private Network, including NAT to map private IP addresses in the Private Network to the public IP address of the Public Gateway. (switchcolumn) <Message type=\"tip\"> To create and manage your Private Networks, check out the [VPC API](https://www.scaleway.com/en/developers/api/vpc). </Message> (switchcolumn) ## Concepts Refer to our [dedicated concepts page](https://www.scaleway.com/en/docs/public-gateways/concepts/) to find definitions of all terminology related to Public Gateways, including NAT, SSH bastion and more. (switchcolumn) (switchcolumn) ## Quickstart 1. Configure your environment variables. <Message type=\"note\"> This is an optional step that seeks to simplify your usage of the Public Gateways API. </Message> ```bash export SCW_SECRET_KEY=\"<API secret key>\" export SCW_DEFAULT_ZONE=\"<Scaleway default Availability Zone>\" export SCW_PROJECT_ID=\"<Scaleway Project ID>\" ``` 2. **Choose a Public Gateway type**: Public Gateways come in different shapes and sizes, with different network capabilities and pricing. When you create your Public Gateway, you need to include the required Public Gateway type in the request. Use the following call to get a list of available Public Gateway offer types and their details: ```bash curl -X GET \\ -H \"X-Auth-Token: $SCW_SECRET_KEY\" \\ -H \"Content-Type: application/json\" \\ \"https://api.scaleway.com/vpc-gw/v2/zones/$SCW_DEFAULT_ZONE/gateway-types\" ``` 3. **Create a Public Gateway**: run the following command to create a Public Gateway. You can customize the details in the payload (name, description, tags, etc) to your needs: use the information below to adjust the payload as necessary. ```bash curl -X POST \\ -H \"X-Auth-Token: $SCW_SECRET_KEY\" \\ -H \"Content-Type: application/json\" \\ \"https://api.scaleway.com/vpc-gw/v2/zones/$SCW_DEFAULT_ZONE/gateways\" \\ -d '{ \"type\": \"VPC-GW-S\", \"name\": \"my-new-gateway\", \"tags\": [\"my-first-tag\", \"my-second-tag\"], \"project_id\": \"'\"$SCW_PROJECT_ID\"'\" }' ``` | Parameter | Description | Valid values | |-----------------|-----------------------------------------------------|-------------------------------| | type | The type of Public Gateway (commercial offer type) to create. Use the Gateway Types endpoint to get a list of offer types. | Any valid offer type string, e.g. `VPC-GW-S` | | name | A name of your choice for the Public Gateway | Any string containing only alphanumeric characters and dashes, e.g. `my-new-gateway`. | | tags | A list of tags to describe your Public Gateway. These can help you manage and filter your gateways. | A list of alphanumeric strings, e.g. `[\"my-first-tag`, `my-second-tag` | | project_id | The Scaleway Project ID to create the Public Gateway in. | A valid Scaleway Project ID, e.g. `f5fe13a0-b9c7-11ed-afa1-0242ac120002` | **Note**: Further parameters are available, but for the purposes of this quickstart we have included only the essentials. See the `Create a Public Gateway` endpoint documentation below for full details of all possible parameters. 4. **Get a list of your Public Gateways**: run the following command to get a list of all your Public Gateways. ```bash curl -X GET \\ -H \"X-Auth-Token: $SCW_SECRET_KEY\" \\ -H \"Content-Type: application/json\" \\ \"https://api.scaleway.com/vpc-gw/v2/zones/$SCW_DEFAULT_ZONE/gateways\" ``` 5. **Attach a Private Network to a Public Gateway**: run the following command to attach a Private Network to your Public Gateway, and make all the Gateway's services such as NAT available to the Private Network. You can customize the details in the payload to your needs: use the information below to adjust the payload as necessary. <Message type=\"tip\"> If you haven't created a Private Network yet, see the [Private Networks](https://www/scaleway.com/en/developers/api/vpc/) documentation to learn how to do so. Ensure you retain the ID of the Private Network. </Message> ```bash curl -X POST \\ -H \"X-Auth-Token: $SCW_SECRET_KEY\" \\ -H \"Content-Type: application/json\" \\ \"https://api.scaleway.com/vpc-gw/v2/zones/$SCW_DEFAULT_ZONE/gateway-networks\" \\ -d '{ \"gateway_id\": \"b1b2edda-9364-422d-93f2-ad04e6a054dc\", \"private_network_id\": \"548dbcc3-8b78-486f-a79a-c3f5a17642f9\", \"enable_masquerade\": true }' ``` This configuration will set up the Public Gateway as a NAT gateway, masquerading traffic sent to it to the outer internet to provide internet access to resources in the Private Network. | Parameter | Description | Valid values | |-----------------|-----------------------------------------------------|-------------------------------| | gateway_id | The Public Gateway ID of an existing Public Gateway | Any valid Public Gateway ID, e.g. `b1b2edda-9364-422d-93f2-ad04e6a054dc` | | private_network_id | The Private Network ID of an existing Private Network | Any valid Private Network ID in the same Availability Zone as the Public Gateway, e.g. `548dbcc3-8b78-486f-a79a-c3f5a17642f9` | | enable_masquerade | Defines whether the gateway should masquerade traffic for the attached Private Network (i.e. whether to enable dynamic NAT) | A boolean value, e.g. `true` | <Message type=\"note\"> Further parameters are available, but for the purposes of this quickstart we have included only the essentials. See the [Attach a gateway to a Private Network](#path-gateway-networks-attach-a-public-gateway-to-a-private-network) documentation below for full details of all possible parameters. </Message> 6. **Delete a Public Gateway**: run the following call to delete your Public Gateway. Ensure that you replace `<PUBLIC-GATEWAY-ID>` in the URL with the ID of the Public Gateway you want to delete. ```bash curl -X DELETE \\ -H \"X-Auth-Token: $SCW_SECRET_KEY\" \\ -H \"Content-Type: application/json\" \\ \"https://api.scaleway.com/vpc-gw/v2/zones/$SCW_DEFAULT_ZONE/gateways/<PUBLIC-GATEWAY-ID>\" ``` The expected successful response is empty. (switchcolumn) <Message type=\"requirement\"> - You have a [Scaleway account](https://console.scaleway.com/) - You have [created an API key](https://www.scaleway.com/en/docs/iam/how-to/create-api-keys/) and that the API key has sufficient [IAM permissions](https://www.scaleway.com/en/docs/iam/reference-content/permission-sets/) to perform the actions described on this page - You have [installed `curl`](https://curl.se/download.html) </Message> (switchcolumn) ## Technical limitations The following limitations apply to Public Gateways: - A maximum of eight (8) Private Networks can be plugged into a single Public Gateway - Note that the Public Gateway takes some time to start up, and actions on it are impossible unless it is in the `running` state. To check the current state of a Public Gateway, use the [Get a Public Gateway](#path-gateways-get-a-public-gateway) endpoint to get information for your gateway: the `status` field of the response will tell you if it is running or in another state. - For further information about Public Gateway limitations see our [dedicated documentation](https://www.scaleway.com/en/docs/public-gateways/troubleshooting/gw-limitations/). ## Technical information ### Availability Zones Public Gateways can be deployed in the following Availability Zones: | Name | API ID | |-----------|-----------------------| | Paris | `fr-par-1` `fr-par-2` | | Amsterdam | `nl-ams-1` `nl-ams-2` `nl-ams-3` | | Warsaw | `pl-waw-1` `pl-waw-2` `pl-waw-3` | The Scaleway Public Gateways API is a **zoned** API, meaning that each call must specify in its path parameters the Availability Zone for the resources concerned by the call. ## Going further For more help using Scaleway Public Gateways, check out the following resources: - Our [main documentation](https://www.scaleway.com/en/docs/public-gateways/) - The #public-gateway channel on our [Slack Community](https://www.scaleway.com/en/docs/tutorials/scaleway-slack-community/) - Our [support ticketing system](https://www.scaleway.com/en/docs/account/how-to/open-a-support-ticket/).
|
|
*
|
|
* The version of the OpenAPI document: v2
|
|
* Generated by: https://openapi-generator.tech
|
|
* Generator version: 7.11.0
|
|
*/
|
|
|
|
/**
|
|
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
|
|
* https://openapi-generator.tech
|
|
* Do not edit the class manually.
|
|
*/
|
|
|
|
namespace OpenAPI\Client;
|
|
|
|
use GuzzleHttp\Psr7\Utils;
|
|
use OpenAPI\Client\Model\ModelInterface;
|
|
|
|
/**
|
|
* ObjectSerializer Class Doc Comment
|
|
*
|
|
* @category Class
|
|
* @package OpenAPI\Client
|
|
* @author OpenAPI Generator team
|
|
* @link https://openapi-generator.tech
|
|
*/
|
|
class ObjectSerializer
|
|
{
|
|
/** @var string */
|
|
private static $dateTimeFormat = \DateTime::ATOM;
|
|
|
|
/**
|
|
* Change the date format
|
|
*
|
|
* @param string $format the new date format to use
|
|
*/
|
|
public static function setDateTimeFormat($format)
|
|
{
|
|
self::$dateTimeFormat = $format;
|
|
}
|
|
|
|
/**
|
|
* Serialize data
|
|
*
|
|
* @param mixed $data the data to serialize
|
|
* @param string|null $type the OpenAPIToolsType of the data
|
|
* @param string|null $format the format of the OpenAPITools type of the data
|
|
*
|
|
* @return scalar|object|array|null serialized form of $data
|
|
*/
|
|
public static function sanitizeForSerialization($data, $type = null, $format = null)
|
|
{
|
|
if (is_scalar($data) || null === $data) {
|
|
return $data;
|
|
}
|
|
|
|
if ($data instanceof \DateTime) {
|
|
return ($format === 'date') ? $data->format('Y-m-d') : $data->format(self::$dateTimeFormat);
|
|
}
|
|
|
|
if (is_array($data)) {
|
|
foreach ($data as $property => $value) {
|
|
$data[$property] = self::sanitizeForSerialization($value);
|
|
}
|
|
return $data;
|
|
}
|
|
|
|
if (is_object($data)) {
|
|
$values = [];
|
|
if ($data instanceof ModelInterface) {
|
|
$formats = $data::openAPIFormats();
|
|
foreach ($data::openAPITypes() as $property => $openAPIType) {
|
|
$getter = $data::getters()[$property];
|
|
$value = $data->$getter();
|
|
if ($value !== null && !in_array($openAPIType, ['\DateTime', '\SplFileObject', 'array', 'bool', 'boolean', 'byte', 'float', 'int', 'integer', 'mixed', 'number', 'object', 'string', 'void'], true)) {
|
|
$callable = [$openAPIType, 'getAllowableEnumValues'];
|
|
if (is_callable($callable)) {
|
|
/** array $callable */
|
|
$allowedEnumTypes = $callable();
|
|
if (!in_array($value, $allowedEnumTypes, true)) {
|
|
$imploded = implode("', '", $allowedEnumTypes);
|
|
throw new \InvalidArgumentException("Invalid value for enum '$openAPIType', must be one of: '$imploded'");
|
|
}
|
|
}
|
|
}
|
|
if (($data::isNullable($property) && $data->isNullableSetToNull($property)) || $value !== null) {
|
|
$values[$data::attributeMap()[$property]] = self::sanitizeForSerialization($value, $openAPIType, $formats[$property]);
|
|
}
|
|
}
|
|
} else {
|
|
foreach($data as $property => $value) {
|
|
$values[$property] = self::sanitizeForSerialization($value);
|
|
}
|
|
}
|
|
return (object)$values;
|
|
} else {
|
|
return (string)$data;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sanitize filename by removing path.
|
|
* e.g. ../../sun.gif becomes sun.gif
|
|
*
|
|
* @param string $filename filename to be sanitized
|
|
*
|
|
* @return string the sanitized filename
|
|
*/
|
|
public static function sanitizeFilename($filename)
|
|
{
|
|
if (preg_match("/.*[\/\\\\](.*)$/", $filename, $match)) {
|
|
return $match[1];
|
|
} else {
|
|
return $filename;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shorter timestamp microseconds to 6 digits length.
|
|
*
|
|
* @param string $timestamp Original timestamp
|
|
*
|
|
* @return string the shorten timestamp
|
|
*/
|
|
public static function sanitizeTimestamp($timestamp)
|
|
{
|
|
if (!is_string($timestamp)) return $timestamp;
|
|
|
|
return preg_replace('/(:\d{2}.\d{6})\d*/', '$1', $timestamp);
|
|
}
|
|
|
|
/**
|
|
* Take value and turn it into a string suitable for inclusion in
|
|
* the path, by url-encoding.
|
|
*
|
|
* @param string $value a string which will be part of the path
|
|
*
|
|
* @return string the serialized object
|
|
*/
|
|
public static function toPathValue($value)
|
|
{
|
|
return rawurlencode(self::toString($value));
|
|
}
|
|
|
|
/**
|
|
* Checks if a value is empty, based on its OpenAPI type.
|
|
*
|
|
* @param mixed $value
|
|
* @param string $openApiType
|
|
*
|
|
* @return bool true if $value is empty
|
|
*/
|
|
private static function isEmptyValue($value, string $openApiType): bool
|
|
{
|
|
# If empty() returns false, it is not empty regardless of its type.
|
|
if (!empty($value)) {
|
|
return false;
|
|
}
|
|
|
|
# Null is always empty, as we cannot send a real "null" value in a query parameter.
|
|
if ($value === null) {
|
|
return true;
|
|
}
|
|
|
|
switch ($openApiType) {
|
|
# For numeric values, false and '' are considered empty.
|
|
# This comparison is safe for floating point values, since the previous call to empty() will
|
|
# filter out values that don't match 0.
|
|
case 'int':
|
|
case 'integer':
|
|
return $value !== 0;
|
|
|
|
case 'number':
|
|
case 'float':
|
|
return $value !== 0 && $value !== 0.0;
|
|
|
|
# For boolean values, '' is considered empty
|
|
case 'bool':
|
|
case 'boolean':
|
|
return !in_array($value, [false, 0], true);
|
|
|
|
# For string values, '' is considered empty.
|
|
case 'string':
|
|
return $value === '';
|
|
|
|
# For all the other types, any value at this point can be considered empty.
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Take query parameter properties and turn it into an array suitable for
|
|
* native http_build_query or GuzzleHttp\Psr7\Query::build.
|
|
*
|
|
* @param mixed $value Parameter value
|
|
* @param string $paramName Parameter name
|
|
* @param string $openApiType OpenAPIType eg. array or object
|
|
* @param string $style Parameter serialization style
|
|
* @param bool $explode Parameter explode option
|
|
* @param bool $required Whether query param is required or not
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function toQueryValue(
|
|
$value,
|
|
string $paramName,
|
|
string $openApiType = 'string',
|
|
string $style = 'form',
|
|
bool $explode = true,
|
|
bool $required = true
|
|
): array {
|
|
|
|
# Check if we should omit this parameter from the query. This should only happen when:
|
|
# - Parameter is NOT required; AND
|
|
# - its value is set to a value that is equivalent to "empty", depending on its OpenAPI type. For
|
|
# example, 0 as "int" or "boolean" is NOT an empty value.
|
|
if (self::isEmptyValue($value, $openApiType)) {
|
|
if ($required) {
|
|
return ["{$paramName}" => ''];
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
# Handle DateTime objects in query
|
|
if($openApiType === "\\DateTime" && $value instanceof \DateTime) {
|
|
return ["{$paramName}" => $value->format(self::$dateTimeFormat)];
|
|
}
|
|
|
|
$query = [];
|
|
$value = (in_array($openApiType, ['object', 'array'], true)) ? (array)$value : $value;
|
|
|
|
// since \GuzzleHttp\Psr7\Query::build fails with nested arrays
|
|
// need to flatten array first
|
|
$flattenArray = function ($arr, $name, &$result = []) use (&$flattenArray, $style, $explode) {
|
|
if (!is_array($arr)) return $arr;
|
|
|
|
foreach ($arr as $k => $v) {
|
|
$prop = ($style === 'deepObject') ? $prop = "{$name}[{$k}]" : $k;
|
|
|
|
if (is_array($v)) {
|
|
$flattenArray($v, $prop, $result);
|
|
} else {
|
|
if ($style !== 'deepObject' && !$explode) {
|
|
// push key itself
|
|
$result[] = $prop;
|
|
}
|
|
$result[$prop] = $v;
|
|
}
|
|
}
|
|
return $result;
|
|
};
|
|
|
|
$value = $flattenArray($value, $paramName);
|
|
|
|
// https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
|
|
if ($openApiType === 'array' && $style === 'deepObject' && $explode) {
|
|
return $value;
|
|
}
|
|
|
|
if ($openApiType === 'object' && ($style === 'deepObject' || $explode)) {
|
|
return $value;
|
|
}
|
|
|
|
if ('boolean' === $openApiType && is_bool($value)) {
|
|
$value = self::convertBoolToQueryStringFormat($value);
|
|
}
|
|
|
|
// handle style in serializeCollection
|
|
$query[$paramName] = ($explode) ? $value : self::serializeCollection((array)$value, $style);
|
|
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Convert boolean value to format for query string.
|
|
*
|
|
* @param bool $value Boolean value
|
|
*
|
|
* @return int|string Boolean value in format
|
|
*/
|
|
public static function convertBoolToQueryStringFormat(bool $value)
|
|
{
|
|
if (Configuration::BOOLEAN_FORMAT_STRING == Configuration::getDefaultConfiguration()->getBooleanFormatForQueryString()) {
|
|
return $value ? 'true' : 'false';
|
|
}
|
|
|
|
return (int) $value;
|
|
}
|
|
|
|
/**
|
|
* Take value and turn it into a string suitable for inclusion in
|
|
* the header. If it's a string, pass through unchanged
|
|
* If it's a datetime object, format it in ISO8601
|
|
*
|
|
* @param string $value a string which will be part of the header
|
|
*
|
|
* @return string the header string
|
|
*/
|
|
public static function toHeaderValue($value)
|
|
{
|
|
$callable = [$value, 'toHeaderValue'];
|
|
if (is_callable($callable)) {
|
|
return $callable();
|
|
}
|
|
|
|
return self::toString($value);
|
|
}
|
|
|
|
/**
|
|
* Take value and turn it into a string suitable for inclusion in
|
|
* the http body (form parameter). If it's a string, pass through unchanged
|
|
* If it's a datetime object, format it in ISO8601
|
|
*
|
|
* @param string|\SplFileObject $value the value of the form parameter
|
|
*
|
|
* @return string the form string
|
|
*/
|
|
public static function toFormValue($value)
|
|
{
|
|
if ($value instanceof \SplFileObject) {
|
|
return $value->getRealPath();
|
|
} else {
|
|
return self::toString($value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Take value and turn it into a string suitable for inclusion in
|
|
* the parameter. If it's a string, pass through unchanged
|
|
* If it's a datetime object, format it in ISO8601
|
|
* If it's a boolean, convert it to "true" or "false".
|
|
*
|
|
* @param float|int|bool|\DateTime $value the value of the parameter
|
|
*
|
|
* @return string the header string
|
|
*/
|
|
public static function toString($value)
|
|
{
|
|
if ($value instanceof \DateTime) { // datetime in ISO8601 format
|
|
return $value->format(self::$dateTimeFormat);
|
|
} elseif (is_bool($value)) {
|
|
return $value ? 'true' : 'false';
|
|
} else {
|
|
return (string) $value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Serialize an array to a string.
|
|
*
|
|
* @param array $collection collection to serialize to a string
|
|
* @param string $style the format use for serialization (csv,
|
|
* ssv, tsv, pipes, multi)
|
|
* @param bool $allowCollectionFormatMulti allow collection format to be a multidimensional array
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function serializeCollection(array $collection, $style, $allowCollectionFormatMulti = false)
|
|
{
|
|
if ($allowCollectionFormatMulti && ('multi' === $style)) {
|
|
// http_build_query() almost does the job for us. We just
|
|
// need to fix the result of multidimensional arrays.
|
|
return preg_replace('/%5B[0-9]+%5D=/', '=', http_build_query($collection, '', '&'));
|
|
}
|
|
switch ($style) {
|
|
case 'pipeDelimited':
|
|
case 'pipes':
|
|
return implode('|', $collection);
|
|
|
|
case 'tsv':
|
|
return implode("\t", $collection);
|
|
|
|
case 'spaceDelimited':
|
|
case 'ssv':
|
|
return implode(' ', $collection);
|
|
|
|
case 'simple':
|
|
case 'csv':
|
|
// Deliberate fall through. CSV is default format.
|
|
default:
|
|
return implode(',', $collection);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deserialize a JSON string into an object
|
|
*
|
|
* @param mixed $data object or primitive to be deserialized
|
|
* @param string $class class name is passed as a string
|
|
* @param string[]|null $httpHeaders HTTP headers
|
|
*
|
|
* @return object|array|null a single or an array of $class instances
|
|
*/
|
|
public static function deserialize($data, $class, $httpHeaders = null)
|
|
{
|
|
if (null === $data) {
|
|
return null;
|
|
}
|
|
|
|
if (strcasecmp(substr($class, -2), '[]') === 0) {
|
|
$data = is_string($data) ? json_decode($data) : $data;
|
|
|
|
if (!is_array($data)) {
|
|
throw new \InvalidArgumentException("Invalid array '$class'");
|
|
}
|
|
|
|
$subClass = substr($class, 0, -2);
|
|
$values = [];
|
|
foreach ($data as $key => $value) {
|
|
$values[] = self::deserialize($value, $subClass, null);
|
|
}
|
|
return $values;
|
|
}
|
|
|
|
if (preg_match('/^(array<|map\[)/', $class)) { // for associative array e.g. array<string,int>
|
|
$data = is_string($data) ? json_decode($data) : $data;
|
|
settype($data, 'array');
|
|
$inner = substr($class, 4, -1);
|
|
$deserialized = [];
|
|
if (strrpos($inner, ",") !== false) {
|
|
$subClass_array = explode(',', $inner, 2);
|
|
$subClass = $subClass_array[1];
|
|
foreach ($data as $key => $value) {
|
|
$deserialized[$key] = self::deserialize($value, $subClass, null);
|
|
}
|
|
}
|
|
return $deserialized;
|
|
}
|
|
|
|
if ($class === 'object') {
|
|
settype($data, 'array');
|
|
return $data;
|
|
} elseif ($class === 'mixed') {
|
|
settype($data, gettype($data));
|
|
return $data;
|
|
}
|
|
|
|
if ($class === '\DateTime') {
|
|
// Some APIs return an invalid, empty string as a
|
|
// date-time property. DateTime::__construct() will return
|
|
// the current time for empty input which is probably not
|
|
// what is meant. The invalid empty string is probably to
|
|
// be interpreted as a missing field/value. Let's handle
|
|
// this graceful.
|
|
if (!empty($data)) {
|
|
try {
|
|
return new \DateTime($data);
|
|
} catch (\Exception $exception) {
|
|
// Some APIs return a date-time with too high nanosecond
|
|
// precision for php's DateTime to handle.
|
|
// With provided regexp 6 digits of microseconds saved
|
|
return new \DateTime(self::sanitizeTimestamp($data));
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if ($class === '\SplFileObject') {
|
|
$data = Utils::streamFor($data);
|
|
|
|
/** @var \Psr\Http\Message\StreamInterface $data */
|
|
|
|
// determine file name
|
|
if (
|
|
is_array($httpHeaders)
|
|
&& array_key_exists('Content-Disposition', $httpHeaders)
|
|
&& preg_match('/inline; filename=[\'"]?([^\'"\s]+)[\'"]?$/i', $httpHeaders['Content-Disposition'], $match)
|
|
) {
|
|
$filename = Configuration::getDefaultConfiguration()->getTempFolderPath() . DIRECTORY_SEPARATOR . self::sanitizeFilename($match[1]);
|
|
} else {
|
|
$filename = tempnam(Configuration::getDefaultConfiguration()->getTempFolderPath(), '');
|
|
}
|
|
|
|
$file = fopen($filename, 'w');
|
|
while ($chunk = $data->read(200)) {
|
|
fwrite($file, $chunk);
|
|
}
|
|
fclose($file);
|
|
|
|
return new \SplFileObject($filename, 'r');
|
|
}
|
|
|
|
/** @psalm-suppress ParadoxicalCondition */
|
|
if (in_array($class, ['\DateTime', '\SplFileObject', 'array', 'bool', 'boolean', 'byte', 'float', 'int', 'integer', 'mixed', 'number', 'object', 'string', 'void'], true)) {
|
|
settype($data, $class);
|
|
return $data;
|
|
}
|
|
|
|
|
|
if (method_exists($class, 'getAllowableEnumValues')) {
|
|
if (!in_array($data, $class::getAllowableEnumValues(), true)) {
|
|
$imploded = implode("', '", $class::getAllowableEnumValues());
|
|
throw new \InvalidArgumentException("Invalid value for enum '$class', must be one of: '$imploded'");
|
|
}
|
|
return $data;
|
|
} else {
|
|
$data = is_string($data) ? json_decode($data) : $data;
|
|
|
|
if (is_array($data)) {
|
|
$data = (object)$data;
|
|
}
|
|
|
|
// If a discriminator is defined and points to a valid subclass, use it.
|
|
$discriminator = $class::DISCRIMINATOR;
|
|
if (!empty($discriminator) && isset($data->{$discriminator}) && is_string($data->{$discriminator})) {
|
|
$subclass = '\OpenAPI\Client\Model\\' . $data->{$discriminator};
|
|
if (is_subclass_of($subclass, $class)) {
|
|
$class = $subclass;
|
|
}
|
|
}
|
|
|
|
/** @var ModelInterface $instance */
|
|
$instance = new $class();
|
|
foreach ($instance::openAPITypes() as $property => $type) {
|
|
$propertySetter = $instance::setters()[$property];
|
|
|
|
if (!isset($propertySetter)) {
|
|
continue;
|
|
}
|
|
|
|
if (!isset($data->{$instance::attributeMap()[$property]})) {
|
|
if ($instance::isNullable($property)) {
|
|
$instance->$propertySetter(null);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (isset($data->{$instance::attributeMap()[$property]})) {
|
|
$propertyValue = $data->{$instance::attributeMap()[$property]};
|
|
$instance->$propertySetter(self::deserialize($propertyValue, $type, null));
|
|
}
|
|
}
|
|
return $instance;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build a query string from an array of key value pairs.
|
|
*
|
|
* This function can use the return value of `parse()` to build a query
|
|
* string. This function does not modify the provided keys when an array is
|
|
* encountered (like `http_build_query()` would).
|
|
*
|
|
* The function is copied from https://github.com/guzzle/psr7/blob/a243f80a1ca7fe8ceed4deee17f12c1930efe662/src/Query.php#L59-L112
|
|
* with a modification which is described in https://github.com/guzzle/psr7/pull/603
|
|
*
|
|
* @param array $params Query string parameters.
|
|
* @param int|false $encoding Set to false to not encode, PHP_QUERY_RFC3986
|
|
* to encode using RFC3986, or PHP_QUERY_RFC1738
|
|
* to encode using RFC1738.
|
|
*/
|
|
public static function buildQuery(array $params, $encoding = PHP_QUERY_RFC3986): string
|
|
{
|
|
if (!$params) {
|
|
return '';
|
|
}
|
|
|
|
if ($encoding === false) {
|
|
$encoder = function (string $str): string {
|
|
return $str;
|
|
};
|
|
} elseif ($encoding === PHP_QUERY_RFC3986) {
|
|
$encoder = 'rawurlencode';
|
|
} elseif ($encoding === PHP_QUERY_RFC1738) {
|
|
$encoder = 'urlencode';
|
|
} else {
|
|
throw new \InvalidArgumentException('Invalid type');
|
|
}
|
|
|
|
$castBool = Configuration::BOOLEAN_FORMAT_INT == Configuration::getDefaultConfiguration()->getBooleanFormatForQueryString()
|
|
? function ($v) { return (int) $v; }
|
|
: function ($v) { return $v ? 'true' : 'false'; };
|
|
|
|
$qs = '';
|
|
foreach ($params as $k => $v) {
|
|
$k = $encoder((string) $k);
|
|
if (!is_array($v)) {
|
|
$qs .= $k;
|
|
$v = is_bool($v) ? $castBool($v) : $v;
|
|
if ($v !== null) {
|
|
$qs .= '='.$encoder((string) $v);
|
|
}
|
|
$qs .= '&';
|
|
} else {
|
|
foreach ($v as $vv) {
|
|
$qs .= $k;
|
|
$vv = is_bool($vv) ? $castBool($vv) : $vv;
|
|
if ($vv !== null) {
|
|
$qs .= '='.$encoder((string) $vv);
|
|
}
|
|
$qs .= '&';
|
|
}
|
|
}
|
|
}
|
|
|
|
return $qs ? (string) substr($qs, 0, -1) : '';
|
|
}
|
|
}
|