api-body.mustache - mozsearch

++ {{>licenseInfo}}

++ #include "{{classFilename}}.h"

++ #include "{{prefixLowerCase}}serverconfiguration.h"

++

++ #include <QtCore/qanystringview.h>

++ #include <QtCore/qflags.h>

++ #include <QtCore/qjsonarray.h>

++ #include <QtCore/qjsondocument.h>

++ #include <QtNetwork/qhttpmultipart.h>

++ #include <QtNetwork/qnetworkaccessmanager.h>

++ #include <QtNetwork/qnetworkreply.h>

++ #include <QtNetwork/qnetworkrequestfactory.h>

++ #include <QtNetwork/qrestaccessmanager.h>

++

++ #include <string_view>

++

++ using namespace Qt::StringLiterals;

++ using namespace std::string_view_literals;

++

++ {{#cppCommonNamespaceDeclarations}}

++ using namespace {{this}};

++ {{/cppCommonNamespaceDeclarations}}

++

++ {{#cppNamespaceDeclarations}}

++ namespace {{this}} {

++ {{/cppNamespaceDeclarations}}

++

++ {{classname}}::{{classname}}(QObject *parent)

++     : {{prefix}}BaseApi(parent)

++ {

++     initializeServerConfigs();

++ }

++

++ {{classname}}::~{{classname}}()

++ {

++ }

++

++ void {{classname}}::initializeServerConfigs()

++ {

++     //Default server

++     QList<{{prefix}}ServerConfiguration> defaultConf = QList<{{prefix}}ServerConfiguration>();

++     //varying endpoint server

++ {{#vendorExtensions.x-cpp-global-server-list}}

++     defaultConf.append({{prefix}}ServerConfiguration(

++         u"{{{url}}}"_s,

++         u"{{{description}}}{{^description}}No description provided{{/description}}"_s,

++         {{#variables}}{{#-first}}QMap<QString, {{prefix}}ServerVariable>{ {{/-first}}

++         {u"{{{name}}}"_s, {{prefix}}ServerVariable(u"{{{description}}}{{^description}}No description provided{{/description}}"_s, u"{{{defaultValue}}}"_s,

++         QSet<QString>{ {{#enumValues}}{u"{{{.}}}"_s}{{#-last}} })},{{/-last}}{{^-last}}, {{/-last}}{{/enumValues}}{{^enumValues}}/* empty */ })},{{/enumValues}}{{#-last}} }));{{/-last}}

++         {{/variables}}{{^variables}}QMap<QString, {{prefix}}ServerVariable>()));{{/variables}}

++ {{/vendorExtensions.x-cpp-global-server-list}}

++ {{#operations}}

++ {{#operation}}

++     {

++ {{^servers}}

++         setServersForOperation(u"{{nickname}}"_s, defaultConf);

++ {{/servers}}

++ {{#servers}}

++ {{#-first}}

++         QList<{{prefix}}ServerConfiguration> serversForOperation;

++

++ {{/-first}}

++         serversForOperation.append({{prefix}}ServerConfiguration(

++             u"{{{url}}}"_s,

++             u"{{{description}}}{{^description}}No description provided{{/description}}"_s,

++             {{#variables}}{{#-first}}QMap<QString, {{prefix}}ServerVariable>{ {{/-first}}

++             {u"{{{name}}}"_s, {{prefix}}ServerVariable(u"{{{description}}}{{^description}}No description provided{{/description}}"_s, u"{{{defaultValue}}}"_s,

++             QSet<QString>{ {{#enumValues}}{u"{{{.}}}"_s}{{#-last}} })},{{/-last}}{{^-last}}, {{/-last}}{{/enumValues}}{{^enumValues}}/* empty */ })},{{/enumValues}}{{#-last}} }));{{/-last}}

++             {{/variables}}{{^variables}}QMap<QString, {{prefix}}ServerVariable>()));{{/variables}}

++ {{#-last}}

++

++         setServersForOperation(u"{{nickname}}"_s, serversForOperation);

++ {{/-last}}

++ {{/servers}}

++     }

++ {{/operation}}

++ {{/operations}}

++ }

++

++ {{#operations}}

++ {{#operation}}

++ /**

++ * \fn void {{classname}}::{{nickname}}({{#hasParams}}{{#allParams}}const {{#required}}{{{dataType}}} &{{/required}}{{^required}}{{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}> &{{/required}}{{paramName}}{{^required}} = {{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}>(){{/required}}{{^-last}}, {{/-last}}{{/allParams}}{{/hasParams}})

++ * {{#isDeprecated}}\deprecated {{/isDeprecated}}'{{nickname}}' operation sends the request to a server.

++ * The request parameters are defined by a specification file.

++ {{#hasParams}}{{#allParams}}{{#required}}

++ * @param[in] {{paramName}} {{{dataType}}} [required]{{/required}}{{^required}}

++ * @param[in] {{paramName}} {{{dataType}}} [optional]{{/required}}{{/allParams}}{{/hasParams}}

++ */

++

++ /**

++ * \fn template < Functor, > void {{classname}}::{{nickname}}({{#allParams}}const {{#required}}{{{dataType}}} &{{/required}}{{^required}}{{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}> &{{/required}}{{paramName}}{{^required}} = {{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}>(){{/required}}, {{/allParams}}const ContextTypeForFunctor< Functor > *_qt_context = nullptr, Functor &&_qt_callback = (){})

++ * {{#isDeprecated}}\deprecated {{/isDeprecated}}'{{nickname}}' operation sends the request to a server.

++ * The request parameters are defined by a specification file.

++ *

++ * \attention Use the operation with following parameters in the callback:

++ * \code {c++}

++ *    {{nickname}}({{#hasParams}}{{#allParams}}{{paramName}}, {{/allParams}}{{/hasParams}}this, [&](const QRestReply &reply{{#returnType}}, const {{{.}}} &summary{{/returnType}}) { if (reply.isSuccess()) ... });

++ * \endcode

++ {{#hasParams}}{{#allParams}}{{#required}}

++ * @param[in] {{paramName}} {{{dataType}}} [required]{{/required}}{{^required}}

++ * @param[in] {{paramName}} {{{dataType}}} [optional]{{/required}}{{/allParams}}{{/hasParams}}

++ * @param[in] _qt_context const ContextTypeForFunctor< Functor > * [optional]

++ * @param[in] _qt_callback Functor && [optional]

++ */

++

++ /**

++ * \fn void {{classname}}::{{nickname}}Callback(const QRestReply &reply)

++ * Processes a \a reply response from a server.

++ * The result of processed data is emitted by {{nickname}}Finished() or

++ * being returned as a callback parameter of {{nickname}}() request.

++ * @param[in] reply const QRestReply &

++ */

++

++ /**

++ * \fn void {{classname}}::{{nickname}}WithDataImpl({{#allParams}}const {{#required}}{{{dataType}}} &{{/required}}{{^required}}{{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}> &{{/required}}{{paramName}}, {{/allParams}}const QObject *_qt_context, QtPrivate::QSlotObjectBase *_qt_slot)

++ * Implements the {{nickname}}() operation request.

++ {{#hasParams}}{{#allParams}}{{#required}}

++ * @param[in] {{paramName}} {{{dataType}}} [required]{{/required}}{{^required}}

++ * @param[in] {{paramName}} {{{dataType}}} [optional]{{/required}}{{/allParams}}{{/hasParams}}

++ * @param[in] _qt_context const QObject * [optional]

++ * @param[in] _qt_slot QtPrivate::QSlotObjectBase * [optional]

++ */

++ void {{classname}}::{{nickname}}WithDataImpl({{#allParams}}const {{#required}}{{{dataType}}} &{{/required}}{{^required}}{{cppCommonNamespace}}::OptionalParameter<{{{dataType}}}> &{{/required}}{{paramName}}, {{/allParams}}const QObject *_qt_context, QtPrivate::QSlotObjectBase *_qt_slot)

++ {

++     QtPrivate::SlotObjUniquePtr slotPtr(_qt_slot);

++     setBaseServerUrl(u"{{nickname}}"_s);

++     QString fullPath = u"{{{path}}}"_s;

++ {{>set-auth-query}}

++ {{#pathParams}}

++     {

++         QString {{paramName}}PathParam = u"{%1}"_s.arg(u"{{baseName}}"_s);

++ {{#vendorExtensions.x-warningMessage}}

++         qWarning("{{{vendorExtensions.x-warningMessage}}}");

++ {{/vendorExtensions.x-warningMessage}}

++

++         SerializationFlags flags;

++         flags.setFlag(SerializationFlag::Object, {{^isAnyType}}{{isModel}} || {{isMap}}{{/isAnyType}}{{#isAnyType}}{{paramName}}.type() == QJsonValue::Object{{/isAnyType}});

++         flags.setFlag(SerializationFlag::NeedPercentEncoding, true);

++         flags.setFlag(SerializationFlag::Explode, {{isExplode}});

++

++         SerializationOptions opts;

++         opts.style = "{{style}}"sv.empty() ? "simple" : "{{style}}";

++         opts.prefix = getParamStylePrefix(opts.style);

++         opts.delimiter = getParamStyleDelimiter(opts.style, flags);

++         opts.assignOperator = getParamStyleAssignOperator(opts.style, flags);

++         opts.suffix = getParamStyleSuffix(opts.style, QUrl::toPercentEncoding(u"{{baseName}}"_s), flags);

++         opts.flags = flags;

++ {{^isAnyType}}

++         QString paramString = opts.prefix + opts.suffix;

++ {{/isAnyType}}

++ {{#isAnyType}}

++         QString paramString = opts.prefix + serializeJsonValue({{paramName}}, opts);

++ {{/isAnyType}}

++ {{#isModel}}

++         paramString = opts.prefix + serializeJsonValue({{paramName}}.asJsonValue(), opts);

++ {{/isModel}}

++ {{#isMap}}

++ {{#additionalProperties.isModel}}

++ {{^content}}

++         qWarning() << "Serialization of complex array or object properties in path or query "

++                       "parameters is undefined. The generated result will not conform to the "

++                       "OpenAPI standard.";

++ {{/content}}

++ {{/additionalProperties.isModel}}

++         paramString.append(serializeMapValue({{paramName}}, opts));

++ {{/isMap}}

++ {{#isPrimitiveType}}

++         paramString += QUrl::toPercentEncoding(::{{cppCommonNamespace}}::toStringValue({{paramName}}));

++ {{/isPrimitiveType}}

++ {{#isArray}}

++         paramString = opts.prefix + serializeArrayValue({{paramName}}, opts);

++ {{/isArray}}

++         // In case style=matrix and paramString is empty due to any reasons,

++         // we serialize it like undefined value and delete '='.

++         // Described here: https://spec.openapis.org/oas/v3.1.1.html#style-values

++         if ((paramString == opts.prefix + opts.suffix) && opts.style == "matrix")

++             paramString.chop(1);

++         fullPath.replace({{paramName}}PathParam, paramString);

++     }

++ {{/pathParams}}

++ {{#hasQueryParams}}

++     int queryParamCounter = 0;{{/hasQueryParams}}

++ {{#queryParams}}

++     {

++ {{^isArray}}

++         [[maybe_unused]] QString paramString;

++ {{/isArray}}

++ {{#vendorExtensions.x-warningMessage}}

++         qWarning("{{{vendorExtensions.x-warningMessage}}}");

++ {{/vendorExtensions.x-warningMessage}}

++

++         SerializationFlags flags;

++         flags.setFlag(SerializationFlag::Object, {{^isAnyType}}{{isModel}} || {{isMap}}{{/isAnyType}}{{#isAnyType}}{{paramName}}{{^required}}.value(){{/required}}.type() == QJsonValue::Object{{/isAnyType}});

++         flags.setFlag(SerializationFlag::NeedPercentEncoding, true);

++         flags.setFlag(SerializationFlag::Explode, {{isExplode}});

++

++         SerializationOptions opts;

++         opts.style = "{{style}}"sv.empty() ? "form" : "{{style}}";

++         opts.prefix = getParamStylePrefix(opts.style);

++         opts.delimiter = getParamStyleDelimiter(opts.style, flags);

++         opts.assignOperator = getParamStyleAssignOperator(opts.style, flags);

++         opts.suffix = getParamStyleSuffix(opts.style, QUrl::toPercentEncoding(u"{{baseName}}"_s), flags);

++         opts.flags = flags;

++ {{^isAnyType}}

++ {{^isArray}}

++ {{^isDeepObject}}

++         paramString = opts.suffix;

++ {{/isDeepObject}}

++ {{/isArray}}

++ {{/isAnyType}}

++         if ((fullPath.indexOf(u'?') != fullPath.size() - 1) && (queryParamCounter == 0))

++             fullPath.append(opts.prefix);

++         {{^required}}if ({{paramName}}.hasValue()) {{/required}}{

++             if (queryParamCounter > 0)

++                 fullPath.append(u'&');

++ {{#isAnyType}}

++             const QJsonValue::Type paramType = {{paramName}}{{^required}}.value(){{/required}}.type();

++             if (paramType != QJsonValue::Object) {

++                 if (opts.style == "deepObject") {

++                     qWarning("Be aware that 'deepObject' style is only valid for parameters of "

++                              "type 'object'. The generated result will not conform to the OpenAPI "

++                              "standard.");

++                 } else if (paramType != QJsonValue::Array

++                            && (opts.style == "pipeDelimited"

++                                || opts.style == "spaceDelimited")) {

++                     qWarning("Be aware that '%s' style is invalid for primitive parameters. "

++                              "The generated result will not conform to the OpenAPI standard.",

++                              opts.style.c_str());

++                 }

++             }

++             paramString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++             fullPath.append(paramString);

++ {{/isAnyType}}

++ {{#isModel}}

++             paramString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}.asJsonValue(), opts);

++             // style=form && explode=true && non-object => '{{baseName}}' isn't used in serialization

++             // style=form && explode=true && empty object => need to be '{{baseName}}='

++             // see https://spec.openapis.org/oas/v3.1.1.html#style-values

++             if (paramString.isEmpty() && opts.style == "form")

++                 paramString = u"{{baseName}}="_s;

++             fullPath.append(paramString);

++ {{/isModel}}

++ {{#isMap}}

++ {{#additionalProperties.isModel}}

++ {{^content}}

++             qWarning() << "Serialization of complex array or object properties in path or query "

++                           "parameters is undefined. The generated result will not conform to the"

++                           " OpenAPI standard.";

++ {{/content}}

++ {{/additionalProperties.isModel}}

++             if (opts.style == "deepObject") {

++                 qsizetype index = 0;

++                 if ({{paramName}}{{^required}}.value(){{/required}}.isEmpty())

++                     qWarning() << "Map is empty!";

++                 for (const auto &[key, value] : {{paramName}}{{^required}}.value(){{/required}}.asKeyValueRange()) {

++                     if (index > 0)

++                         paramString.append(opts.delimiter);

++                     paramString.append(opts.suffix + QUrl::toPercentEncoding(u"[%1]"_s.arg(key)) + opts.assignOperator + QUrl::toPercentEncoding(::{{cppCommonNamespace}}::toStringValue(value)));

++                     index++;

++                 }

++             } else {

++                 paramString.append(serializeMapValue({{paramName}}{{^required}}.value(){{/required}}, opts));

++             }

++             fullPath.append(paramString);

++ {{/isMap}}

++ {{#isPrimitiveType}}

++             fullPath.append(opts.suffix + QUrl::toPercentEncoding(::{{cppCommonNamespace}}::toStringValue({{paramName}}{{^required}}.value(){{/required}})));

++ {{/isPrimitiveType}}

++ {{#isArray}}

++             fullPath.append(serializeArrayValue({{paramName}}{{^required}}.value(){{/required}}, opts));

++ {{/isArray}}

++             queryParamCounter++;

++         }{{^required}}{{#isNullable}} else if ({{paramName}}.isNull()) {

++             if (queryParamCounter > 0)

++                 fullPath.append(u'&');

++             // style=form && explode=true && non-object => '{{baseName}}' isn't used in serialization

++             // style=form && explode=true && empty object => need to be '{{baseName}}='

++             // see https://spec.openapis.org/oas/v3.1.1.html#style-values

++             if (opts.style == "form")

++                 fullPath.append(u"{{baseName}}="_s);

++             else

++                 fullPath.append(opts.suffix);

++             queryParamCounter++;

++         }{{/isNullable}}{{/required}}

++     }

++ {{/queryParams}}

++     {{prefix}}HttpRequestInput input(fullPath, "{{httpMethod}}"_L1);

++ {{#hasFormParams}}

++ {{#consumes}}

++ {{#-first}}

++     input.headers().replaceOrAppend(QHttpHeaders::WellKnownHeader::ContentType, "{{{mediaType}}}"_L1);

++ {{/-first}}

++ {{/consumes}}

++     input.setIsFormData(true);

++ {{#isMultipart}}

++     input.setVariableLayout({{prefix}}HttpRequestInput::VariableLayout::Multipart);

++ {{/isMultipart}}

++ {{^isMultipart}}

++     input.setVariableLayout(input.httpMethod() == "GET"_L1 || input.httpMethod() == "HEAD"_L1

++                        ? {{prefix}}HttpRequestInput::VariableLayout::Address

++                        : {{prefix}}HttpRequestInput::VariableLayout::UrlEncoded);

++ {{/isMultipart}}

++ {{/hasFormParams}}

++ {{#formParams}}

++     {{^required}}if ({{paramName}}.hasValue()) {{/required}}{

++         QString contentType;

++ {{#consumes}}

++ {{#contentType}}

++         contentType = u"{{contentType}}"_s;

++ {{/contentType}}

++ {{/consumes}}

++ {{#isFile}}

++         input.addFile(u"{{baseName}}"_s, {{paramName}}{{^required}}.value(){{/required}}.filename(), contentType);

++ {{/isFile}}

++ {{^isFile}}

++ {{#isContainer}}

++         // if contentType is explicitly specified as json,

++         // or if it is not specified and the elements of the

++         // array are non-primitive, also serialize as a json-object

++ {{#isArray}}

++         using VT = std::decay_t<decltype({{paramName}}{{^required}}.value(){{/required}})>::value_type;

++         if (contentType == "application/json"_L1

++             || (contentType.isEmpty() && !isPrimitiveMediaType<VT>)) {

++             input.addFieldHeaders(u"{{baseName}}"_s, "application/json"_L1);

++             input.addVariable(u"{{baseName}}"_s, ::{{cppCommonNamespace}}::convertJsonValueToString(::{{cppCommonNamespace}}::toJsonValue({{paramName}}{{^required}}.value(){{/required}})));

++         } else {

++             // if none of the above - serialize according to the content type of items

++             for (const auto &item : {{paramName}}{{^required}}.value(){{/required}}) {

++                 input.addVariable(u"{{baseName}}"_s, ::{{cppCommonNamespace}}::serializeMediaTypeContentField(contentType, item));

++             }

++             input.addFieldHeaders(u"{{baseName}}"_s, "text/plain"_L1);

++         }

++ {{/isArray}}

++ {{#isMap}}

++         using MapType = std::decay_t<decltype({{paramName}}{{^required}}.value(){{/required}})>;

++         using VT = typename MapType::mapped_type;

++         if (contentType == "application/json"_L1

++             || (contentType.isEmpty() && !isPrimitiveMediaType<VT>)) {

++             input.addFieldHeaders(u"{{baseName}}"_s, "application/json"_L1);

++             input.addVariable(u"{{baseName}}"_s, ::{{cppCommonNamespace}}::convertJsonValueToString(::{{cppCommonNamespace}}::toJsonValue({{paramName}}{{^required}}.value(){{/required}})));

++         } else {

++             // if none of the above - serialize according to the content type of items

++             for (const auto &[key, value] : {{paramName}}{{^required}}.value(){{/required}}.asKeyValueRange()) {

++                 input.addVariable(key, ::{{cppCommonNamespace}}::serializeMediaTypeContentField(contentType, value));

++             }

++             input.addFieldHeaders(u"{{baseName}}"_s, "text/plain"_L1);

++         }

++ {{/isMap}}

++ {{/isContainer}}

++ {{^isContainer}}

++         using VT = std::decay_t<decltype({{paramName}}{{^required}}.value(){{/required}})>;

++         input.addFieldHeaders(u"{{baseName}}"_s, addContentField<VT>(contentType));

++         input.addVariable(u"{{baseName}}"_s, ::{{cppCommonNamespace}}::serializeMediaTypeContentField(contentType, {{paramName}}{{^required}}.value(){{/required}}));

++ {{/isContainer}}

++ {{/isFile}}

++     }

++ {{/formParams}}

++ {{#bodyParams}}

++ {{#consumes}}

++ {{#-first}}

++     input.headers().replaceOrAppend(QHttpHeaders::WellKnownHeader::ContentType, "{{{mediaType}}}"_L1);

++ {{/-first}}

++ {{/consumes}}

++     {{^required}}if ({{paramName}}.hasValue()) {{/required}}{

++ {{#isContainer}}

++ {{#isArray}}

++         QJsonDocument doc(::{{cppCommonNamespace}}::toJsonValue({{paramName}}{{^required}}.value(){{/required}}).toArray());

++ {{/isArray}}

++ {{#isMap}}

++         QJsonDocument doc(::{{cppCommonNamespace}}::toJsonValue({{paramName}}{{^required}}.value(){{/required}}).toObject());

++ {{/isMap}}

++         QByteArray bytes = doc.toJson(QJsonDocument::Compact);

++         input.setRequestBody(bytes);

++ {{/isContainer}}

++ {{^isContainer}}

++ {{#isString}}

++         const QByteArray output = {{paramName}}{{^required}}.value(){{/required}}.toUtf8();

++ {{/isString}}

++ {{#isByteArray}}

++         const QByteArray output({{paramName}}{{^required}}.value(){{/required}});

++ {{/isByteArray}}

++ {{#isNumeric}}

++         const QByteArray output = QByteArray::number({{paramName}}{{^required}}.value(){{/required}});

++ {{/isNumeric}}

++ {{#isBoolean}}

++         const QByteArray output = ::{{cppCommonNamespace}}::toStringValue({{paramName}}{{^required}}.value(){{/required}}).toUtf8();

++ {{/isBoolean}}

++ {{#isModel}}

++         const QByteArray output = {{paramName}}{{^required}}.value(){{/required}}.asJson().toUtf8();

++ {{/isModel}}

++ {{#isFile}}

++         const QByteArray output = {{paramName}}{{^required}}.value(){{/required}}.loadFromLocalFile();

++ {{/isFile}}

++ {{#isFreeFormObject}}

++         const QByteArray output = {{paramName}}{{^required}}.value(){{/required}}.asJson().toUtf8();

++ {{/isFreeFormObject}}

++ {{#isAnyType}}

++         const QByteArray output = {{paramName}}{{^required}}.value(){{/required}}.toJson(QJsonValue::JsonFormat::Compact);

++         if ({{paramName}}{{^required}}.value(){{/required}}.isUndefined())

++             qWarning() << "The QJsonValue is undefined.";

++ {{/isAnyType}}

++         input.setRequestBody(output);

++ {{/isContainer}}

++     }{{^required}}{{#isNullable}} else if ({{paramName}}.isNull()) {

++         input.setRequestBody("null");

++     }{{/isNullable}}{{/required}}

++ {{/bodyParams}}

++ {{#headerParams}}

++     {{^required}}if ({{paramName}}.hasValue()){{/required}}

++     {

++ {{#vendorExtensions.x-warningMessage}}

++         qWarning("{{{vendorExtensions.x-warningMessage}}}");

++ {{/vendorExtensions.x-warningMessage}}

++

++         SerializationFlags flags;

++         flags.setFlag(SerializationFlag::Object, {{^isAnyType}}{{isModel}} || {{isMap}}{{/isAnyType}}{{#isAnyType}}{{paramName}}{{^required}}.value(){{/required}}.type() == QJsonValue::Object{{/isAnyType}});

++         flags.setFlag(SerializationFlag::NeedPercentEncoding, false);

++         flags.setFlag(SerializationFlag::Explode, {{isExplode}});

++

++         SerializationOptions opts;

++         opts.style = "{{style}}"sv.empty() ? "simple" : "{{style}}";

++         opts.prefix = getParamStylePrefix(opts.style);

++         opts.delimiter = getParamStyleDelimiter(opts.style, flags);

++         opts.assignOperator = getParamStyleAssignOperator(opts.style, flags);

++         opts.suffix = getParamStyleSuffix(opts.style, u"{{baseName}}"_s, flags);

++         opts.flags = flags;

++

++ {{#isAnyType}}

++         const QString headerString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isAnyType}}

++ {{#isModel}}

++         const QString headerString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}.asJsonValue(), opts);

++ {{/isModel}}

++ {{#isMap}}

++         const QString headerString = serializeMapValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isMap}}

++ {{#isPrimitiveType}}

++         const QString headerString = toStringValue({{paramName}}{{^required}}.value(){{/required}});

++ {{/isPrimitiveType}}

++ {{#isArray}}

++         const QString headerString = serializeArrayValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isArray}}

++         if (!headerString.isEmpty())

++             input.headers().replaceOrAppend(u"{{baseName}}"_s, headerString);

++     }

++ {{/headerParams}}

++ {{#cookieParams}}

++     {{^required}}if ({{paramName}}.hasValue()){{/required}}

++     {

++ {{#vendorExtensions.x-warningMessage}}

++         qWarning("{{{vendorExtensions.x-warningMessage}}}");

++ {{/vendorExtensions.x-warningMessage}}

++

++         SerializationFlags flags;

++         flags.setFlag(SerializationFlag::Object, {{^isAnyType}}{{isModel}} || {{isMap}}{{/isAnyType}}{{#isAnyType}}{{paramName}}{{^required}}.value(){{/required}}.type() == QJsonValue::Object{{/isAnyType}});

++         flags.setFlag(SerializationFlag::NeedPercentEncoding, false);

++         flags.setFlag(SerializationFlag::Explode, {{isExplode}});

++

++         SerializationOptions opts;

++         opts.style = "{{style}}"sv.empty() ? "form" : "{{style}}";

++         opts.prefix = getParamStylePrefix(opts.style);

++         opts.delimiter = getParamStyleDelimiter(opts.style, flags);

++         opts.assignOperator = getParamStyleAssignOperator(opts.style, flags);

++         opts.suffix = getParamStyleSuffix(opts.style, u"{{baseName}}"_s, flags);

++         opts.flags = flags;

++

++         QString cookieString;

++ {{#isAnyType}}

++         cookieString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isAnyType}}

++ {{#isModel}}

++         cookieString = serializeJsonValue({{paramName}}{{^required}}.value(){{/required}}.asJsonValue(), opts);

++ {{/isModel}}

++ {{#isMap}}

++         cookieString = opts.suffix + serializeMapValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isMap}}

++ {{#isPrimitiveType}}

++         cookieString = opts.suffix + toStringValue({{paramName}}{{^required}}.value(){{/required}});

++ {{/isPrimitiveType}}

++ {{#isArray}}

++         cookieString = serializeArrayValue({{paramName}}{{^required}}.value(){{/required}}, opts);

++ {{/isArray}}

++         // See https://spec.openapis.org/oas/v3.1.1.html#style-values column "undefined"

++         if (cookieString.isEmpty())

++             cookieString = u"{{baseName}}="_s;

++         input.headers().append(QHttpHeaders::WellKnownHeader::Cookie, cookieString);

++     }

++ {{/cookieParams}}

++     QByteArray requestContent;

++     QNetworkRequest request

++         = {{prefix}}HttpRequestWorker::getNetworkRequest(input, requestContent,

++                                                          networkRequestFactory(),

++                                                          responseCompressionEnabled(),

++                                                          requestCompressionEnabled());

++ {{>set-auth-headers}}

++     QNetworkReply *reply = execute(input, request, requestContent);

++     if (reply != nullptr) {

++         reply->setParent(this);

++         setCallerInfo(reply, {{prefix}}CallerInfo{_qt_context, QtPrivate::SlotObjSharedPtr(std::move(slotPtr))});{{#addDownloadProgress}}

++         connect(reply, &QNetworkReply::downloadProgress, this, &{{classname}}::{{nickname}}Progress);{{/addDownloadProgress}}

++         connect(reply, &QNetworkReply::finished, this, [this, reply] {

++             {{nickname}}Callback(QRestReply(reply));

++         });

++         connect(reply, &QNetworkReply::errorOccurred, this, [this, reply] {

++             if (reply) {

++                 Q_EMIT {{nickname}}ErrorOccurred(reply->error(), reply->errorString());

++                 {{prefix}}CallerInfo callerInfo = takeCallerInfo(reply);

++                 if (callerInfo.slot) {

++                     {{#returnType}}{{{.}}} empty;

++                     {{/returnType}}QRestReply restRepl(reply);

++                     void *argv[] = { nullptr, &restRepl{{#returnType}}, &empty{{/returnType}} };

++                     QObject *context = callerInfo.contextObject ? const_cast<QObject*>(callerInfo.contextObject.get()) : nullptr;

++                     callerInfo.slot->call(context, argv);

++                 }

++             }

++         });

++     }

++ }

++

++ void {{classname}}::{{nickname}}Callback(const QRestReply &reply)

++ {

++     auto netReply = reply.networkReply();

++     if (netReply)

++         netReply->disconnect(this);

++     if (!reply.isSuccess())

++         return;

++

++ {{#returnType}}

++     {{prefix}}HttpResponseParseParameters responseData;

++ {{^returnTypeIsPrimitive}}

++ {{#isResponseFile}}

++     QMap<QString, {{prefix}}HttpFileElement> responseFiles;

++     responseData.m_files = &responseFiles;

++ {{/isResponseFile}}

++ {{/returnTypeIsPrimitive}}

++     responseData.m_fileConflictPolicy = fileConflictPolicy();

++     responseData.m_safetyThresholdSize = decompressedSafetyCheckThreshold();

++     {{^isResponseFile}}const QByteArray response = {{/isResponseFile}}{{prefix}}HttpRequestWorker::parseResponse(reply, workingDirectory(), responseData);

++ {{#isResponseFile}}

++     {{{returnType}}} output = {{prefix}}HttpRequestWorker::getHttpFileElement(responseFiles);

++ {{/isResponseFile}}

++ {{^isResponseFile}}

++ {{^returnTypeIsPrimitive}}

++ {{^returnContainer}}

++     {{{returnType}}} output(response);

++ {{/returnContainer}}

++ {{#returnContainer}}

++     {{{returnType}}} output;

++     const QJsonDocument doc = QJsonDocument::fromJson(response);

++     if (!doc.isNull() && doc.{{#isArray}}isArray(){{/isArray}}{{^isArray}}isObject(){{/isArray}}) {

++         const bool ok = ::{{cppCommonNamespace}}::fromJsonValue(output, doc.{{#isArray}}array(){{/isArray}}{{^isArray}}object(){{/isArray}});

++         if (!ok)

++             qWarning("%s: Failed to convert QJsonValue to {{{returnType}}}.", Q_FUNC_INFO);

++     } else {

++         qWarning("%s: Failed to parse the response as a JSON {{#isArray}}array{{/isArray}}{{^isArray}}object{{/isArray}}.", Q_FUNC_INFO);

++     }

++ {{/returnContainer}}

++ {{/returnTypeIsPrimitive}}

++ {{#returnTypeIsPrimitive}}

++     {{{returnType}}} output;

++ {{#returnContainer}}

++     const QJsonDocument doc = QJsonDocument::fromJson(response);

++     if (!doc.isNull() && doc.{{#isArray}}isArray(){{/isArray}}{{^isArray}}isObject(){{/isArray}}) {

++         const bool ok = ::{{cppCommonNamespace}}::fromJsonValue(output, doc.{{#isArray}}array(){{/isArray}}{{^isArray}}object(){{/isArray}});

++         if (!ok)

++             qWarning("%s: Failed to convert QJsonValue to {{{returnType}}}.", Q_FUNC_INFO);

++     } else {

++         qWarning("%s: Failed to parse the response as a JSON {{#isArray}}array{{/isArray}}{{^isArray}}object{{/isArray}}.", Q_FUNC_INFO);

++     }

++ {{/returnContainer}}

++ {{^returnContainer}}

++     const bool ok = ::{{cppCommonNamespace}}::fromByteArray(response, output);

++     if (!ok)

++         qWarning("%s: Failed to convert the response to {{returnType}}.", Q_FUNC_INFO);

++ {{/returnContainer}}

++ {{/returnTypeIsPrimitive}}

++ {{/isResponseFile}}

++ {{/returnType}}

++     // Check if callback is provided

++     {{prefix}}CallerInfo callerInfo = takeCallerInfo(netReply);

++     if (callerInfo.slot) {

++         void *argv[] = { nullptr, const_cast<QRestReply*>(&reply){{#returnType}}, &output{{/returnType}} };

++         QObject *context = callerInfo.contextObject

++                         ? const_cast<QObject*>(callerInfo.contextObject.get()) : nullptr;

++         callerInfo.slot->call(context, argv);

++     }

++     Q_EMIT {{nickname}}Finished({{#returnType}}output{{/returnType}});

++ }

++

++ {{/operation}}

++ {{/operations}}

++ {{#cppNamespaceDeclarations}}

++ } // namespace {{this}}

++ {{/cppNamespaceDeclarations}}

Revision control