Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
dart2.api_client.mustache Maven / Gradle / Ivy
{{>header}}
{{>part_of}}
class ApiClient {
ApiClient({this.basePath = '{{{basePath}}}'}) {
{{#hasAuthMethods}}
// Setup authentications (key: authentication name, value: authentication).
{{#authMethods}}
{{#isBasic}}
{{#isBasicBasic}}
_authentications[r'{{{name}}}'] = HttpBasicAuth();
{{/isBasicBasic}}
{{#isBasicBearer}}
_authentications[r'{{{name}}}'] = HttpBearerAuth();
{{/isBasicBearer}}
{{/isBasic}}
{{#isApiKey}}
_authentications[r'{{{name}}}'] = ApiKeyAuth({{#isKeyInCookie}}'cookie'{{/isKeyInCookie}}{{^isKeyInCookie}}{{#isKeyInHeader}}'header'{{/isKeyInHeader}}{{^isKeyInHeader}}'query'{{/isKeyInHeader}}{{/isKeyInCookie}}, '{{{keyParamName}}}');
{{/isApiKey}}
{{#isOAuth}}
_authentications[r'{{{name}}}'] = OAuth();
{{/isOAuth}}
{{/authMethods}}
{{/hasAuthMethods}}
}
final String basePath;
var _client = Client();
/// Returns the current HTTP [Client] instance to use in this class.
///
/// The return value is guaranteed to never be null.
Client get client => _client;
/// Requests to use a new HTTP [Client] in this class.
///
/// If the [newClient] is null, an [ArgumentError] is thrown.
set client(Client newClient) {
if (newClient == null) {
throw ArgumentError('New client instance cannot be null.');
}
_client = newClient;
}
final _defaultHeaderMap = {};
final _authentications = {};
void addDefaultHeader(String key, String value) {
_defaultHeaderMap[key] = value;
}
Map get defaultHeaderMap => _defaultHeaderMap;
/// Returns an unmodifiable [Map] of the authentications, since none should be added
/// or deleted.
Map get authentications => Map.unmodifiable(_authentications);
T getAuthentication(String name) {
final authentication = _authentications[name];
return authentication is T ? authentication : null;
}
// We don't use a Map for queryParams.
// If collectionFormat is 'multi', a key might appear multiple times.
Future invokeAPI(
String path,
String method,
List queryParams,
Object body,
Map headerParams,
Map formParams,
String nullableContentType,
List authNames,
) async {
_updateParamsForAuth(authNames, queryParams, headerParams);
headerParams.addAll(_defaultHeaderMap);
final urlEncodedQueryParams = queryParams
.where((param) => param.value != null)
.map((param) => '$param');
final queryString = urlEncodedQueryParams.isNotEmpty
? '?${urlEncodedQueryParams.join('&')}'
: '';
final uri = Uri.parse('$basePath$path$queryString');
if (nullableContentType != null) {
headerParams['Content-Type'] = nullableContentType;
}
try {
// Special case for uploading a single file which isn't a 'multipart/form-data'.
if (
body is MultipartFile && (nullableContentType == null ||
!nullableContentType.toLowerCase().startsWith('multipart/form-data'))
) {
final request = StreamedRequest(method, uri);
request.headers.addAll(headerParams);
request.contentLength = body.length;
body.finalize().listen(
request.sink.add,
onDone: request.sink.close,
// ignore: avoid_types_on_closure_parameters
onError: (Object error, StackTrace trace) => request.sink.close(),
cancelOnError: true,
);
final response = await _client.send(request);
return Response.fromStream(response);
}
if (body is MultipartRequest) {
final request = MultipartRequest(method, uri);
request.fields.addAll(body.fields);
request.files.addAll(body.files);
request.headers.addAll(body.headers);
request.headers.addAll(headerParams);
final response = await _client.send(request);
return Response.fromStream(response);
}
final msgBody = nullableContentType == 'application/x-www-form-urlencoded'
? formParams
: await serializeAsync(body);
final nullableHeaderParams = headerParams.isEmpty ? null : headerParams;
switch(method) {
case 'POST': return await _client.post(uri, headers: nullableHeaderParams, body: msgBody,);
case 'PUT': return await _client.put(uri, headers: nullableHeaderParams, body: msgBody,);
case 'DELETE': return await _client.delete(uri, headers: nullableHeaderParams, body: msgBody,);
case 'PATCH': return await _client.patch(uri, headers: nullableHeaderParams, body: msgBody,);
case 'HEAD': return await _client.head(uri, headers: nullableHeaderParams,);
case 'GET': return await _client.get(uri, headers: nullableHeaderParams,);
}
} on SocketException catch (e, trace) {
throw ApiException.withInner(HttpStatus.badRequest, 'Socket operation failed: $method $path', e, trace,);
} on TlsException catch (e, trace) {
throw ApiException.withInner(HttpStatus.badRequest, 'TLS/SSL communication failed: $method $path', e, trace,);
} on IOException catch (e, trace) {
throw ApiException.withInner(HttpStatus.badRequest, 'I/O operation failed: $method $path', e, trace,);
} on ClientException catch (e, trace) {
throw ApiException.withInner(HttpStatus.badRequest, 'HTTP connection failed: $method $path', e, trace,);
} on Exception catch (e, trace) {
throw ApiException.withInner(HttpStatus.badRequest, 'Exception occurred: $method $path', e, trace,);
}
throw ApiException(HttpStatus.badRequest, 'Invalid HTTP operation: $method $path',);
}
{{#native_serialization}}
Future deserializeAsync(String json, String targetType, {bool growable}) async =>
// ignore: deprecated_member_use_from_same_package
deserialize(json, targetType, growable: growable);
@Deprecated('Scheduled for removal in OpenAPI Generator 6.x. Use deserializeAsync() instead.')
dynamic deserialize(String json, String targetType, {bool growable}) {
// Remove all spaces. Necessary for regular expressions as well.
targetType = targetType.replaceAll(' ', ''); // ignore: parameter_assignments
// If the expected target type is String, nothing to do...
return targetType == 'String'
? json
: _deserialize(jsonDecode(json), targetType, growable: growable == true);
}
{{/native_serialization}}
// ignore: deprecated_member_use_from_same_package
Future serializeAsync(Object value) async => serialize(value);
@Deprecated('Scheduled for removal in OpenAPI Generator 6.x. Use serializeAsync() instead.')
String serialize(Object value) => value == null ? '' : json.encode(value);
/// Update query and header parameters based on authentication settings.
/// @param authNames The authentications to apply
void _updateParamsForAuth(
List authNames,
List queryParams,
Map headerParams,
) {
for(final authName in authNames) {
final auth = _authentications[authName];
if (auth == null) {
throw ArgumentError('Authentication undefined: $authName');
}
auth.applyToParams(queryParams, headerParams);
}
}
{{#native_serialization}}
static dynamic _deserialize(dynamic value, String targetType, {bool growable}) {
try {
switch (targetType) {
case 'String':
return value is String ? value : value.toString();
case 'int':
return value is int ? value : int.parse('$value');
case 'double':
return value is double ? value : double.parse('$value');
case 'bool':
if (value is bool) {
return value;
}
final valueString = '$value'.toLowerCase();
return valueString == 'true' || valueString == '1';
{{#models}}
{{#model}}
case '{{{classname}}}':
{{#isEnum}}
{{#native_serialization}}return {{{classname}}}TypeTransformer().decode(value);{{/native_serialization}}
{{/isEnum}}
{{^isEnum}}
return {{{classname}}}.fromJson(value);
{{/isEnum}}
{{/model}}
{{/models}}
default:
Match match;
if (value is List && (match = _regList.firstMatch(targetType)) != null) {
targetType = match[1]; // ignore: parameter_assignments
return value
.map((dynamic v) => _deserialize(v, targetType, growable: growable))
.toList(growable: growable);
}
if (value is Set && (match = _regSet.firstMatch(targetType)) != null) {
targetType = match[1]; // ignore: parameter_assignments
return value
.map((dynamic v) => _deserialize(v, targetType, growable: growable))
.toSet();
}
if (value is Map && (match = _regMap.firstMatch(targetType)) != null) {
targetType = match[1]; // ignore: parameter_assignments
return Map.fromIterables(
value.keys.cast(),
value.values.map((dynamic v) => _deserialize(v, targetType, growable: growable)),
);
}
}
} on Exception catch (error, trace) {
throw ApiException.withInner(HttpStatus.internalServerError, 'Exception during deserialization.', error, trace,);
}
throw ApiException(HttpStatus.internalServerError, 'Could not find a suitable class for deserialization',);
}
{{/native_serialization}}
}
{{#native_serialization}}
/// Primarily intended for use in an isolate.
class DeserializationMessage {
const DeserializationMessage({
@required this.json,
@required this.targetType,
this.growable,
});
/// The JSON value to deserialize.
final String json;
/// Target type to deserialize to.
final String targetType;
/// Whether to make deserialized lists or maps growable.
final bool growable;
}
/// Primarily intended for use in an isolate.
Future deserializeAsync(DeserializationMessage message) async {
// Remove all spaces. Necessary for regular expressions as well.
final targetType = message.targetType.replaceAll(' ', '');
// If the expected target type is String, nothing to do...
return targetType == 'String'
? message.json
: ApiClient._deserialize(
jsonDecode(message.json),
targetType,
growable: message.growable == true,
);
}
{{/native_serialization}}
/// Primarily intended for use in an isolate.
Future serializeAsync(Object value) async => value == null ? '' : json.encode(value);
