[dart][dart-dio] API class/template refactoring (#8825)

* [dart][dart-dio] Refactor API template

* first construct a `RequestOptions` instance with all parameters etc. inline
* then construct and serialize the body data
* then send the request and await the response
* then deserialize the response
* always use the `specifiedType` for built_value (de)serialization instead of a mix of ways (this does the same as finding the serializer directly)
* use indent of 2 spaces (as per Dart convention)
* prefix all local variables to prevent name clashes with parameters

* Add tests that (de)serialize collections and add API key header
This commit is contained in:
Peter Leibiger
2021-02-25 13:24:21 +01:00
committed by GitHub
parent 9fc33f6a73
commit fbe2bb7c97
16 changed files with 4477 additions and 4532 deletions

View File

@@ -11,144 +11,138 @@ import 'package:built_value/serializer.dart';
class {{classname}} {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const {{classname}}(this._dio, this._serializers);
{{#operation}}
/// {{{summary}}}
///
/// {{{notes}}}
Future<Response<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}>> {{nickname}}({{^hasRequiredParams}}{ {{/hasRequiredParams}}{{#requiredParams}}
{{{dataType}}} {{paramName}},{{#-last}} { {{/-last}}{{/requiredParams}}{{#optionalParams}}
{{{dataType}}} {{paramName}},{{/optionalParams}}
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '{{{path}}}'{{#pathParams}}.replaceAll('{' r'{{baseName}}' '}', {{{paramName}}}.toString()){{/pathParams}};
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{ {{#httpUserAgent}}
'User-Agent': '{{{.}}}',{{/httpUserAgent}}
if (headers != null) ...headers,
};
dynamic bodyData;
const {{classname}}(this._dio, this._serializers);
{{#operation}}
/// {{{summary}}}
///
/// {{{notes}}}
Future<Response<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}>> {{nickname}}({{^hasRequiredParams}}{ {{/hasRequiredParams}}{{#requiredParams}}
{{{dataType}}} {{paramName}},{{#-last}} { {{/-last}}{{/requiredParams}}{{#optionalParams}}
{{{dataType}}} {{paramName}},{{/optionalParams}}
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'{{{path}}}'{{#pathParams}}.replaceAll('{' r'{{{baseName}}}' '}', {{{paramName}}}.toString()){{/pathParams}},
method: '{{#lambda.uppercase}}{{httpMethod}}{{/lambda.uppercase}}',
{{#isResponseFile}}
responseType: ResponseType.bytes,
{{/isResponseFile}}
headers: <String, dynamic>{
{{#httpUserAgent}}
r'User-Agent': r'{{{.}}}',
{{/httpUserAgent}}
{{#headerParams}}
headerParams[r'{{baseName}}'] = {{paramName}};
r'{{baseName}}': {{paramName}},
{{/headerParams}}
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
{{#queryParams}}
queryParams[r'{{baseName}}'] = {{paramName}};
r'{{baseName}}': {{paramName}},
{{/queryParams}}
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[{{^hasAuthMethods}}],{{/hasAuthMethods}}{{#hasAuthMethods}}
{{#authMethods}}{
'type': '{{type}}',
'name': '{{name}}',{{#isApiKey}}
'keyName': '{{keyParamName}}',
'where': '{{#isKeyInQuery}}query{{/isKeyInQuery}}{{#isKeyInHeader}}header{{/isKeyInHeader}}',{{/isApiKey}}
},{{/authMethods}}
],{{/hasAuthMethods}}
...?extra,
},
validateStatus: validateStatus,
contentType: [{{^hasConsumes}}
'application/json',{{/hasConsumes}}{{#hasConsumes}}{{#consumes}}
'{{{mediaType}}}',{{/consumes}}{{/hasConsumes}}
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final contentTypes = <String>[{{^hasConsumes}}];{{/hasConsumes}}{{#hasConsumes}}{{#consumes}}
'{{{mediaType}}}',{{/consumes}}
];{{/hasConsumes}}
{{#hasFormParams}}
dynamic _bodyData;
{{#hasFormParams}}
final formData = <String, dynamic>{
{{#formParams}}
{{^required}}{{^nullable}}if ({{paramName}} != null) {{/nullable}}{{/required}}r'{{baseName}}': {{#isFile}}MultipartFile.fromBytes({{paramName}}, filename: r'{{baseName}}'){{/isFile}}{{^isFile}}parameterToString(_serializers, {{paramName}}){{/isFile}},
{{/formParams}}
};
{{#isMultipart}}
bodyData = FormData.fromMap(formData);
{{/isMultipart}}
{{^isMultipart}}
bodyData = formData;
{{/isMultipart}}
{{/hasFormParams}}
{{#bodyParam}}
_bodyData = {{#isMultipart}}FormData.fromMap({{/isMultipart}}<String, dynamic>{
{{#formParams}}
{{^required}}{{^nullable}}if ({{{paramName}}} != null) {{/nullable}}{{/required}}r'{{{baseName}}}': {{#isFile}}MultipartFile.fromBytes({{{paramName}}}, filename: r'{{{baseName}}}'){{/isFile}}{{^isFile}}parameterToString(_serializers, {{{paramName}}}){{/isFile}},
{{/formParams}}
}{{#isMultipart}}){{/isMultipart}};
{{/hasFormParams}}
{{#bodyParam}}
{{#isContainer}}
{{#isArray}}
const type = FullType(Built{{#uniqueItems}}Built{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}, [FullType({{baseType}})]);
bodyData = _serializers.serialize({{paramName}}, specifiedType: type);
{{/isArray}}
{{#isMap}}
const type = FullType(BuiltMap, [FullType(String), FullType({{baseType}})]);
bodyData = _serializers.serialize({{paramName}}, specifiedType: type);
{{/isMap}}
{{/isContainer}}
{{^isContainer}}
{{#isPrimitiveType}}
bodyData = {{paramName}};
{{/isPrimitiveType}}
{{^isPrimitiveType}}
final bodySerializer = _serializers.serializerForType({{{baseType}}}) as Serializer<{{{baseType}}}>;
bodyData = _serializers.serializeWith(bodySerializer, {{paramName}});
{{/isPrimitiveType}}
{{/isContainer}}
{{/bodyParam}}
{{#isPrimitiveType}}
_bodyData = {{paramName}};
{{/isPrimitiveType}}
{{^isPrimitiveType}}
{{#isContainer}}
const _type = FullType(Built{{#isMap}}Map{{/isMap}}{{#isArray}}{{#uniqueItems}}Set{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}{{/isArray}}, [{{#isMap}}FullType(String), {{/isMap}}FullType({{{baseType}}})]);
_bodyData = _serializers.serialize({{paramName}}, specifiedType: _type);
{{/isContainer}}
{{^isContainer}}
const _type = FullType({{{baseType}}});
_bodyData = _serializers.serialize({{paramName}}, specifiedType: _type);
{{/isContainer}}
{{/isPrimitiveType}}
{{/bodyParam}}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: '{{httpMethod}}'.toUpperCase(),
{{#isResponseFile}}
responseType: ResponseType.bytes,
{{/isResponseFile}}
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[{{^hasAuthMethods}}],{{/hasAuthMethods}}{{#hasAuthMethods}}
{{#authMethods}}{
'type': '{{type}}',
'name': '{{name}}',{{#isApiKey}}
'keyName': '{{keyParamName}}',
'where': '{{#isKeyInQuery}}query{{/isKeyInQuery}}{{#isKeyInHeader}}header{{/isKeyInHeader}}',{{/isApiKey}}
},{{/authMethods}}
],{{/hasAuthMethods}}
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
){{#returnType}}.then((response) {
{{#isResponseFile}}
final data = response.data;
{{/isResponseFile}}
{{^isResponseFile}}
{{#returnSimpleType}}
{{#returnTypeIsPrimitive}}
final data = response.data as {{{returnType}}};
{{/returnTypeIsPrimitive}}
{{^returnTypeIsPrimitive}}
final serializer = _serializers.serializerForType({{{returnType}}}) as Serializer<{{{returnType}}}>;
final data = _serializers.deserializeWith<{{{returnType}}}>(serializer, response.data);
{{/returnTypeIsPrimitive}}
{{/returnSimpleType}}
{{^returnSimpleType}}
const type = FullType(Built{{#isMap}}Map{{/isMap}}{{#isArray}}{{#uniqueItems}}Set{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}{{/isArray}}, [{{#isMap}}FullType(String), {{/isMap}}FullType({{{returnBaseType}}})]);
final data = _serializers.deserialize(response.data, specifiedType: type) as {{{returnType}}};
{{/returnSimpleType}}
{{/isResponseFile}}
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
{{#returnType}}
return Response<{{{returnType}}}>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
}){{/returnType}};
}
{{#isResponseFile}}
final {{{returnType}}} _responseData = _response.data;
{{/isResponseFile}}
{{^isResponseFile}}
{{#returnSimpleType}}
{{#returnTypeIsPrimitive}}
final {{{returnType}}} _responseData = _response.data as {{{returnType}}};
{{/returnTypeIsPrimitive}}
{{^returnTypeIsPrimitive}}
const _responseType = FullType({{{returnType}}});
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as {{{returnType}}};
{{/returnTypeIsPrimitive}}
{{/returnSimpleType}}
{{^returnSimpleType}}
const _responseType = FullType(Built{{#isArray}}{{#uniqueItems}}Set{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}{{/isArray}}{{#isMap}}Map{{/isMap}}, [{{#isMap}}FullType(String), {{/isMap}}FullType({{{returnBaseType}}})]);
final {{{returnType}}} _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as {{{returnType}}};
{{/returnSimpleType}}
{{/isResponseFile}}
{{/operation}}
return Response<{{{returnType}}}>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);{{/returnType}}{{^returnType}}
return _response;{{/returnType}}
}
{{/operation}}
}
{{/operations}}

View File

@@ -17,504 +17,490 @@ import 'package:openapi/api_util.dart';
class PetApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const PetApi(this._dio, this._serializers);
const PetApi(this._dio, this._serializers);
/// Add a new pet to the store
///
///
Future<Response<void>> addPet(
Pet body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet';
/// Add a new pet to the store
///
///
Future<Response<void>> addPet(
Pet body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
'application/xml',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(Pet);
_bodyData = _serializers.serialize(body, specifiedType: _type);
final contentTypes = <String>[
'application/json',
'application/xml',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(Pet) as Serializer<Pet>;
bodyData = _serializers.serializeWith(bodySerializer, body);
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Deletes a pet
///
///
Future<Response<void>> deletePet(
int petId, {
String apiKey,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString()),
method: 'DELETE',
headers: <String, dynamic>{
r'api_key': apiKey,
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Deletes a pet
///
///
Future<Response<void>> deletePet(
int petId, {
String apiKey,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString());
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
headerParams[r'api_key'] = apiKey;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return _response;
}
final contentTypes = <String>[];
/// Finds Pets by status
///
/// Multiple status values can be provided with comma separated strings
Future<Response<BuiltList<Pet>>> findPetsByStatus(
BuiltList<String> status, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/findByStatus',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
r'status': status,
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
dynamic _bodyData;
/// Finds Pets by status
///
/// Multiple status values can be provided with comma separated strings
Future<Response<BuiltList<Pet>>> findPetsByStatus(
BuiltList<String> status, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/findByStatus';
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(BuiltList, [FullType(Pet)]);
final BuiltList<Pet> _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as BuiltList<Pet>;
queryParams[r'status'] = status;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return Response<BuiltList<Pet>>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final contentTypes = <String>[];
/// Finds Pets by tags
///
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
Future<Response<BuiltList<Pet>>> findPetsByTags(
BuiltList<String> tags, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/findByTags',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
r'tags': tags,
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
const type = FullType(BuiltList, [FullType(Pet)]);
final data = _serializers.deserialize(response.data, specifiedType: type) as BuiltList<Pet>;
dynamic _bodyData;
return Response<BuiltList<Pet>>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
/// Finds Pets by tags
///
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
Future<Response<BuiltList<Pet>>> findPetsByTags(
BuiltList<String> tags, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/findByTags';
const _responseType = FullType(BuiltList, [FullType(Pet)]);
final BuiltList<Pet> _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as BuiltList<Pet>;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
return Response<BuiltList<Pet>>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
queryParams[r'tags'] = tags;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
/// Find pet by ID
///
/// Returns a single pet
Future<Response<Pet>> getPetById(
int petId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final contentTypes = <String>[];
dynamic _bodyData;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
const type = FullType(BuiltList, [FullType(Pet)]);
final data = _serializers.deserialize(response.data, specifiedType: type) as BuiltList<Pet>;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return Response<BuiltList<Pet>>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
const _responseType = FullType(Pet);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Pet;
/// Find pet by ID
///
/// Returns a single pet
Future<Response<Pet>> getPetById(
int petId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString());
return Response<Pet>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Update an existing pet
///
///
Future<Response<void>> updatePet(
Pet body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet',
method: 'PUT',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
'application/xml',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
const _type = FullType(Pet);
_bodyData = _serializers.serialize(body, specifiedType: _type);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Pet) as Serializer<Pet>;
final data = _serializers.deserializeWith<Pet>(serializer, response.data);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return Response<Pet>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return _response;
}
/// Update an existing pet
///
///
Future<Response<void>> updatePet(
Pet body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet';
/// Updates a pet in the store with form data
///
///
Future<Response<void>> updatePetWithForm(
int petId, {
String name,
String status,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString()),
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/x-www-form-urlencoded',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
_bodyData = <String, dynamic>{
if (name != null) r'name': parameterToString(_serializers, name),
if (status != null) r'status': parameterToString(_serializers, status),
};
final contentTypes = <String>[
'application/json',
'application/xml',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(Pet) as Serializer<Pet>;
bodyData = _serializers.serializeWith(bodySerializer, body);
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'put'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// uploads an image
///
///
Future<Response<ApiResponse>> uploadFile(
int petId, {
String additionalMetadata,
Uint8List file,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/pet/{petId}/uploadImage'.replaceAll('{' r'petId' '}', petId.toString()),
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'multipart/form-data',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Updates a pet in the store with form data
///
///
Future<Response<void>> updatePetWithForm(
int petId, {
String name,
String status,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/{petId}'.replaceAll('{' r'petId' '}', petId.toString());
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
_bodyData = FormData.fromMap(<String, dynamic>{
if (additionalMetadata != null) r'additionalMetadata': parameterToString(_serializers, additionalMetadata),
if (file != null) r'file': MultipartFile.fromBytes(file, filename: r'file'),
});
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[
'application/x-www-form-urlencoded',
];
const _responseType = FullType(ApiResponse);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as ApiResponse;
final formData = <String, dynamic>{
if (name != null) r'name': parameterToString(_serializers, name),
if (status != null) r'status': parameterToString(_serializers, status),
};
bodyData = formData;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// uploads an image
///
///
Future<Response<ApiResponse>> uploadFile(
int petId, {
String additionalMetadata,
Uint8List file,
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/pet/{petId}/uploadImage'.replaceAll('{' r'petId' '}', petId.toString());
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[
'multipart/form-data',
];
final formData = <String, dynamic>{
if (additionalMetadata != null) r'additionalMetadata': parameterToString(_serializers, additionalMetadata),
if (file != null) r'file': MultipartFile.fromBytes(file, filename: r'file'),
};
bodyData = FormData.fromMap(formData);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'oauth2',
'name': 'petstore_auth',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(ApiResponse) as Serializer<ApiResponse>;
final data = _serializers.deserializeWith<ApiResponse>(serializer, response.data);
return Response<ApiResponse>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<ApiResponse>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -14,241 +14,240 @@ import 'package:built_collection/built_collection.dart';
class StoreApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const StoreApi(this._dio, this._serializers);
const StoreApi(this._dio, this._serializers);
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString());
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/inventory',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/inventory';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _responseType = FullType(BuiltMap, [FullType(String), FullType(int)]);
final BuiltMap<String, int> _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as BuiltMap<String, int>;
final contentTypes = <String>[];
return Response<BuiltMap<String, int>>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
const type = FullType(BuiltMap, [FullType(String), FullType(int)]);
final data = _serializers.deserialize(response.data, specifiedType: type) as BuiltMap<String, int>;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<BuiltMap<String, int>>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString());
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final contentTypes = <String>[];
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
dynamic _bodyData;
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
const _type = FullType(Order);
_bodyData = _serializers.serialize(body, specifiedType: _type);
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order';
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[];
final bodySerializer = _serializers.serializerForType(Order) as Serializer<Order>;
bodyData = _serializers.serializeWith(bodySerializer, body);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -14,412 +14,403 @@ import 'package:built_collection/built_collection.dart';
class UserApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const UserApi(this._dio, this._serializers);
const UserApi(this._dio, this._serializers);
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user';
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(User);
_bodyData = _serializers.serialize(body, specifiedType: _type);
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, body);
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithArray',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithArray';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(body, specifiedType: _type);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(body, specifiedType: type);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithList',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
dynamic _bodyData;
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithList';
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(body, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return _response;
}
final contentTypes = <String>[];
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(body, specifiedType: type);
dynamic _bodyData;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return _response;
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
const _responseType = FullType(User);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as User;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return Response<User>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/login',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
r'username': username,
r'password': password,
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(User) as Serializer<User>;
final data = _serializers.deserializeWith<User>(serializer, response.data);
final String _responseData = _response.data as String;
return Response<User>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<String>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/login';
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/logout',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams[r'username'] = username;
queryParams[r'password'] = password;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final data = response.data as String;
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'PUT',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<String>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/logout';
const _type = FullType(User);
_bodyData = _serializers.serialize(body, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[];
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User body, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[];
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, body);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'put'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
return _response;
}
}

View File

@@ -14,243 +14,240 @@ import 'package:built_collection/built_collection.dart';
class StoreApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const StoreApi(this._dio, this._serializers);
const StoreApi(this._dio, this._serializers);
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString());
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/inventory',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/inventory';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _responseType = FullType(BuiltMap, [FullType(String), FullType(int)]);
final BuiltMap<String, int> _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as BuiltMap<String, int>;
final contentTypes = <String>[];
return Response<BuiltMap<String, int>>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
const type = FullType(BuiltMap, [FullType(String), FullType(int)]);
final data = _serializers.deserialize(response.data, specifiedType: type) as BuiltMap<String, int>;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<BuiltMap<String, int>>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{orderId}'.replaceAll('{' r'orderId' '}', orderId.toString());
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final contentTypes = <String>[];
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order order, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
dynamic _bodyData;
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
const _type = FullType(Order);
_bodyData = _serializers.serialize(order, specifiedType: _type);
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order order, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order';
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[
'application/json',
];
final bodySerializer = _serializers.serializerForType(Order) as Serializer<Order>;
bodyData = _serializers.serializeWith(bodySerializer, order);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -14,462 +14,445 @@ import 'package:built_collection/built_collection.dart';
class UserApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const UserApi(this._dio, this._serializers);
const UserApi(this._dio, this._serializers);
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user';
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(User);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final contentTypes = <String>[
'application/json',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, user);
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithArray',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithArray';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(user, specifiedType: _type);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[
'application/json',
];
return _response;
}
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(user, specifiedType: type);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithList',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
dynamic _bodyData;
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithList';
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return _response;
}
final contentTypes = <String>[
'application/json',
];
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(user, specifiedType: type);
dynamic _bodyData;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return _response;
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
const _responseType = FullType(User);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as User;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return Response<User>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/login',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
r'username': username,
r'password': password,
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(User) as Serializer<User>;
final data = _serializers.deserializeWith<User>(serializer, response.data);
final String _responseData = _response.data as String;
return Response<User>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<String>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/login';
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/logout',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams[r'username'] = username;
queryParams[r'password'] = password;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final data = response.data as String;
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'PUT',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<String>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/logout';
const _type = FullType(User);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[];
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[
'application/json',
];
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, user);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'put'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
return _response;
}
}

View File

@@ -13,74 +13,72 @@ import 'package:openapi/model/model_client.dart';
class AnotherFakeApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const AnotherFakeApi(this._dio, this._serializers);
const AnotherFakeApi(this._dio, this._serializers);
/// To test special tags
///
/// To test special tags and operation ID starting with number
Future<Response<ModelClient>> call123testSpecialTags(
ModelClient modelClient, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/another-fake/dummy';
/// To test special tags
///
/// To test special tags and operation ID starting with number
Future<Response<ModelClient>> call123testSpecialTags(
ModelClient modelClient, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/another-fake/dummy',
method: 'PATCH',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(ModelClient);
_bodyData = _serializers.serialize(modelClient, specifiedType: _type);
final contentTypes = <String>[
'application/json',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(ModelClient) as Serializer<ModelClient>;
bodyData = _serializers.serializeWith(bodySerializer, modelClient);
const _responseType = FullType(ModelClient);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as ModelClient;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'patch'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(ModelClient) as Serializer<ModelClient>;
final data = _serializers.deserializeWith<ModelClient>(serializer, response.data);
return Response<ModelClient>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<ModelClient>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -13,68 +13,68 @@ import 'package:openapi/model/inline_response_default.dart';
class DefaultApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const DefaultApi(this._dio, this._serializers);
const DefaultApi(this._dio, this._serializers);
///
///
///
Future<Response<InlineResponseDefault>> fooGet({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/foo';
///
///
///
Future<Response<InlineResponseDefault>> fooGet({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/foo',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
const _responseType = FullType(InlineResponseDefault);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as InlineResponseDefault;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(InlineResponseDefault) as Serializer<InlineResponseDefault>;
final data = _serializers.deserializeWith<InlineResponseDefault>(serializer, response.data);
return Response<InlineResponseDefault>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<InlineResponseDefault>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -13,81 +13,79 @@ import 'package:openapi/model/model_client.dart';
class FakeClassnameTags123Api {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const FakeClassnameTags123Api(this._dio, this._serializers);
const FakeClassnameTags123Api(this._dio, this._serializers);
/// To test class name in snake case
///
/// To test class name in snake case
Future<Response<ModelClient>> testClassname(
ModelClient modelClient, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/fake_classname_test';
/// To test class name in snake case
///
/// To test class name in snake case
Future<Response<ModelClient>> testClassname(
ModelClient modelClient, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/fake_classname_test',
method: 'PATCH',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key_query',
'keyName': 'api_key_query',
'where': 'query',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(ModelClient);
_bodyData = _serializers.serialize(modelClient, specifiedType: _type);
final contentTypes = <String>[
'application/json',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(ModelClient) as Serializer<ModelClient>;
bodyData = _serializers.serializeWith(bodySerializer, modelClient);
const _responseType = FullType(ModelClient);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as ModelClient;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'patch'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key_query',
'keyName': 'api_key_query',
'where': 'query',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(ModelClient) as Serializer<ModelClient>;
final data = _serializers.deserializeWith<ModelClient>(serializer, response.data);
return Response<ModelClient>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<ModelClient>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -14,243 +14,240 @@ import 'package:built_collection/built_collection.dart';
class StoreApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const StoreApi(this._dio, this._serializers);
const StoreApi(this._dio, this._serializers);
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{order_id}'.replaceAll('{' r'order_id' '}', orderId.toString());
/// Delete purchase order by ID
///
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
Future<Response<void>> deleteOrder(
String orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{order_id}'.replaceAll('{' r'order_id' '}', orderId.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/inventory',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Returns pet inventories by status
///
/// Returns a map of status codes to quantities
Future<Response<BuiltMap<String, int>>> getInventory({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/inventory';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _responseType = FullType(BuiltMap, [FullType(String), FullType(int)]);
final BuiltMap<String, int> _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as BuiltMap<String, int>;
final contentTypes = <String>[];
return Response<BuiltMap<String, int>>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[
{
'type': 'apiKey',
'name': 'api_key',
'keyName': 'api_key',
'where': 'header',
},
],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
const type = FullType(BuiltMap, [FullType(String), FullType(int)]);
final data = _serializers.deserialize(response.data, specifiedType: type) as BuiltMap<String, int>;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order/{order_id}'.replaceAll('{' r'order_id' '}', orderId.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<BuiltMap<String, int>>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Find purchase order by ID
///
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
Future<Response<Order>> getOrderById(
int orderId, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order/{order_id}'.replaceAll('{' r'order_id' '}', orderId.toString());
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final contentTypes = <String>[];
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order order, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/store/order',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
dynamic _bodyData;
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
const _type = FullType(Order);
_bodyData = _serializers.serialize(order, specifiedType: _type);
/// Place an order for a pet
///
///
Future<Response<Order>> placeOrder(
Order order, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/store/order';
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _responseType = FullType(Order);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as Order;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[
'application/json',
];
final bodySerializer = _serializers.serializerForType(Order) as Serializer<Order>;
bodyData = _serializers.serializeWith(bodySerializer, order);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(Order) as Serializer<Order>;
final data = _serializers.deserializeWith<Order>(serializer, response.data);
return Response<Order>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<Order>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
}

View File

@@ -14,420 +14,403 @@ import 'package:built_collection/built_collection.dart';
class UserApi {
final Dio _dio;
final Dio _dio;
final Serializers _serializers;
final Serializers _serializers;
const UserApi(this._dio, this._serializers);
const UserApi(this._dio, this._serializers);
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user';
/// Create user
///
/// This can only be done by the logged in user.
Future<Response<void>> createUser(
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
const _type = FullType(User);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final contentTypes = <String>[
'application/json',
];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, user);
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithArray',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithArrayInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithArray';
dynamic _bodyData;
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(user, specifiedType: _type);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[
'application/json',
];
return _response;
}
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(user, specifiedType: type);
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/createWithList',
method: 'POST',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
dynamic _bodyData;
/// Creates list of users with given input array
///
///
Future<Response<void>> createUsersWithListInput(
BuiltList<User> user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/createWithList';
const _type = FullType(BuiltList, [FullType(User)]);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
return _response;
}
final contentTypes = <String>[
'application/json',
];
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'DELETE',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
const type = FullType(BuiltList, [FullType(User)]);
bodyData = _serializers.serialize(user, specifiedType: type);
dynamic _bodyData;
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'post'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
/// Delete user
///
/// This can only be done by the logged in user.
Future<Response<void>> deleteUser(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return _response;
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'delete'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
const _responseType = FullType(User);
final _responseData = _serializers.deserialize(
_response.data,
specifiedType: _responseType,
) as User;
/// Get user by user name
///
///
Future<Response<User>> getUserByName(
String username, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
return Response<User>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/login',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
r'username': username,
r'password': password,
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
dynamic _bodyData;
final contentTypes = <String>[];
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final serializer = _serializers.serializerForType(User) as Serializer<User>;
final data = _serializers.deserializeWith<User>(serializer, response.data);
final String _responseData = _response.data as String;
return Response<User>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
return Response<String>(
data: _responseData,
headers: _response.headers,
isRedirect: _response.isRedirect,
request: _response.request,
redirects: _response.redirects,
statusCode: _response.statusCode,
statusMessage: _response.statusMessage,
extra: _response.extra,
);
}
/// Logs user into the system
///
///
Future<Response<String>> loginUser(
String username,
String password, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/login';
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/logout',
method: 'GET',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
dynamic _bodyData;
queryParams[r'username'] = username;
queryParams[r'password'] = password;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
final contentTypes = <String>[];
return _response;
}
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
).then((response) {
final data = response.data as String;
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final _request = RequestOptions(
path: r'/user/{username}'.replaceAll('{' r'username' '}', username.toString()),
method: 'PUT',
headers: <String, dynamic>{
...?headers,
}..removeWhere((_, dynamic value) => value == null),
queryParameters: <String, dynamic>{
}..removeWhere((_, dynamic value) => value == null),
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
...?extra,
},
validateStatus: validateStatus,
contentType: [
'application/json',
].first,
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
return Response<String>(
data: data,
headers: response.headers,
isRedirect: response.isRedirect,
request: response.request,
redirects: response.redirects,
statusCode: response.statusCode,
statusMessage: response.statusMessage,
extra: response.extra,
);
});
}
dynamic _bodyData;
/// Logs out current logged in user session
///
///
Future<Response<void>> logoutUser({
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/logout';
const _type = FullType(User);
_bodyData = _serializers.serialize(user, specifiedType: _type);
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
final _response = await _dio.request<dynamic>(
_request.path,
data: _bodyData,
options: _request,
);
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[];
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'get'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
/// Updated user
///
/// This can only be done by the logged in user.
Future<Response<void>> updateUser(
String username,
User user, {
CancelToken cancelToken,
Map<String, dynamic> headers,
Map<String, dynamic> extra,
ValidateStatus validateStatus,
ProgressCallback onSendProgress,
ProgressCallback onReceiveProgress,
}) async {
final String _path = '/user/{username}'.replaceAll('{' r'username' '}', username.toString());
final queryParams = <String, dynamic>{};
final headerParams = <String, dynamic>{
if (headers != null) ...headers,
};
dynamic bodyData;
queryParams.removeWhere((key, dynamic value) => value == null);
headerParams.removeWhere((key, dynamic value) => value == null);
final contentTypes = <String>[
'application/json',
];
final bodySerializer = _serializers.serializerForType(User) as Serializer<User>;
bodyData = _serializers.serializeWith(bodySerializer, user);
return _dio.request<dynamic>(
_path,
queryParameters: queryParams,
data: bodyData,
options: Options(
method: 'put'.toUpperCase(),
headers: headerParams,
extra: <String, dynamic>{
'secure': <Map<String, String>>[],
if (extra != null) ...extra,
},
validateStatus: validateStatus,
contentType: contentTypes.isNotEmpty ? contentTypes[0] : 'application/json',
),
cancelToken: cancelToken,
onSendProgress: onSendProgress,
onReceiveProgress: onReceiveProgress,
);
}
return _response;
}
}

View File

@@ -9,8 +9,8 @@ import 'package:openapi/model/tag.dart';
import 'package:test/test.dart';
void main() {
const photo1 = "https://localhost/photo1.jpg";
const photo2 = "https://localhost/photo2.jpg";
const photo1 = 'https://localhost/photo1.jpg';
const photo2 = 'https://localhost/photo2.jpg';
Openapi client;
DioAdapter server;
@@ -30,25 +30,25 @@ void main() {
server.onGet(
'/pet/5',
handler: (response) => response.reply(200, {
"id": 5,
"name": "Paula",
"status": "sold",
"category": {
"id": 1,
"name": "dog",
'id': 5,
'name': 'Paula',
'status': 'sold',
'category': {
'id': 1,
'name': 'dog',
},
"photoUrls": [
"$photo1",
"$photo2",
'photoUrls': [
'$photo1',
'$photo2',
],
"tags": [
'tags': [
{
"id": 3,
"name": "smart",
'id': 3,
'name': 'smart',
},
{
"id": 4,
"name": "cute",
'id': 4,
'name': 'cute',
},
]
}),
@@ -59,10 +59,10 @@ void main() {
expect(response.statusCode, 200);
expect(response.data, isNotNull);
expect(response.data.id, 5);
expect(response.data.name, "Paula");
expect(response.data.name, 'Paula');
expect(response.data.status, PetStatusEnum.sold);
expect(response.data.category.id, 1);
expect(response.data.category.name, "dog");
expect(response.data.category.name, 'dog');
expect(response.data.photoUrls.length, 2);
expect(response.data.tags.length, 2);
});
@@ -71,9 +71,9 @@ void main() {
server.onGet(
'/pet/5',
handler: (response) => response.reply(200, {
"id": 5,
"name": "Paula",
"photoUrls": <String>[],
'id': 5,
'name': 'Paula',
'photoUrls': <String>[],
}),
);
@@ -82,7 +82,7 @@ void main() {
expect(response.statusCode, 200);
expect(response.data, isNotNull);
expect(response.data.id, 5);
expect(response.data.name, "Paula");
expect(response.data.name, 'Paula');
expect(response.data.status, isNull);
expect(response.data.category, isNull);
expect(response.data.photoUrls, isNotNull);
@@ -95,25 +95,25 @@ void main() {
server.onPost(
'/pet',
data: {
"id": 5,
"name": "Paula",
"status": "sold",
"category": {
"id": 1,
"name": "dog",
'id': 5,
'name': 'Paula',
'status': 'sold',
'category': {
'id': 1,
'name': 'dog',
},
"photoUrls": [
"$photo1",
"$photo2",
'photoUrls': [
'$photo1',
'$photo2',
],
"tags": [
'tags': [
{
"id": 3,
"name": "smart",
'id': 3,
'name': 'smart',
},
{
"id": 4,
"name": "cute",
'id': 4,
'name': 'cute',
},
]
},
@@ -126,19 +126,19 @@ void main() {
final response = await client.getPetApi().addPet(Pet((p) => p
..id = 5
..name = "Paula"
..name = 'Paula'
..status = PetStatusEnum.sold
..category = (CategoryBuilder()
..id = 1
..name = "dog")
..name = 'dog')
..photoUrls = SetBuilder<String>(<String>[photo1, photo2])
..tags = ListBuilder<Tag>(<Tag>[
Tag((t) => t
..id = 3
..name = "smart"),
..name = 'smart'),
Tag((t) => t
..id = 4
..name = "cute"),
..name = 'cute'),
])));
expect(response.statusCode, 200);
@@ -148,9 +148,9 @@ void main() {
server.onPost(
'/pet',
data: {
"id": 5,
"name": "Paula",
"photoUrls": <String>[],
'id': 5,
'name': 'Paula',
'photoUrls': <String>[],
},
headers: {
'content-type': 'application/json',
@@ -161,10 +161,58 @@ void main() {
final response = await client.getPetApi().addPet(Pet((p) => p
..id = 5
..name = "Paula"));
..name = 'Paula'));
expect(response.statusCode, 200);
});
});
group('getMultiplePets', () {
test('findByStatus', () async {
server.onRoute(
'/pet/findByStatus',
request: Request(
method: RequestMethods.GET,
queryParameters: <String, dynamic>{
'status': <String>[
'available',
'sold',
],
},
),
handler: (response) => response.reply(200, [
{
'id': 5,
'name': 'Paula',
'status': 'sold',
'photoUrls': <String>[],
},
{
'id': 1,
'name': 'Mickey',
'status': 'available',
'photoUrls': <String>[],
},
]),
);
final response = await client.getPetApi().findPetsByStatus(
ListBuilder<String>(<String>[
PetStatusEnum.available.name,
PetStatusEnum.sold.name,
]).build(),
);
expect(response.statusCode, 200);
expect(response.data, isNotNull);
expect(response.data.length, 2);
expect(response.data[0].id, 5);
expect(response.data[0].name, 'Paula');
expect(response.data[0].status, PetStatusEnum.sold);
expect(response.data[1].id, 1);
expect(response.data[1].name, 'Mickey');
expect(response.data[1].status, PetStatusEnum.available);
});
});
});
}

View File

@@ -0,0 +1,45 @@
import 'package:dio/dio.dart';
import 'package:http_mock_adapter/http_mock_adapter.dart';
import 'package:openapi/api.dart';
import 'package:openapi/api/store_api.dart';
import 'package:test/test.dart';
void main() {
Openapi client;
DioAdapter server;
setUp(() {
server = DioAdapter();
client = Openapi(dio: Dio()..httpClientAdapter = server);
});
tearDown(() {
server.close();
});
group(StoreApi, () {
group('getInventory', () {
test('with API key', () async {
client.setApiKey('api_key', 'SECRET_API_KEY');
server.onGet(
'/store/inventory',
headers: <String, dynamic>{
'api_key': 'SECRET_API_KEY',
},
handler: (response) => response.reply(200, {
'foo': 5,
'bar': 999,
'baz': 0,
}),
);
final response = await client.getStoreApi().getInventory();
expect(response.statusCode, 200);
expect(response.data, isNotNull);
expect(response.data.length, 3);
});
});
});
}