postMultipart2 method

Future<PlexApiResponse> postMultipart2(
  1. String url, {
  2. Map<String, dynamic>? query,
  3. Map<String, String>? headers,
  4. required Map<String, String> formData,
  5. required Map<String, File> files,
  6. Duration? timeout,
  7. PlexCancelToken? cancelToken,
})

Implementation

Future<PlexApiResponse> postMultipart2(
  String url, {
  Map<String, dynamic>? query,
  Map<String, String>? headers,
  required Map<String, String> formData,
  required Map<String, File> files,
  Duration? timeout,
  PlexCancelToken? cancelToken,
}) async {
  if (await isNetworkAvailable() == false) return PlexNetworkNoConnectivity();

  if (query?.isNotEmpty == true) {
    url += "?${query!.entries.map((e) => "${Uri.encodeComponent(e.key)}=${Uri.encodeComponent(e.value.toString())}").join("&")}";
  }

  var currentHeaders = <String, String>{};
  if (addHeaders != null) currentHeaders.addAll(await addHeaders!());
  if (headers != null) currentHeaders.addAll(headers);
  PlexLogger.d('Networking', 'Headers: $currentHeaders');
  currentHeaders = await _runRequestInterceptors(url, currentHeaders);
  final requestTimeout = timeout ?? defaultTimeout;

  if (cancelToken?.isCancelled == true) return _runResponseInterceptors(PlexNetworkCancelled());

  try {
    var uri = Uri.parse(_isValidUrl(url) ? url : _apiUrl() + url);
    PlexLogger.d('Networking', 'Started: ${uri.toString()}');

    var request = http.MultipartRequest('POST', uri);
    request.headers.addAll(currentHeaders);
    request.fields.addAll(formData);
    for (var entry in files.entries) {
      var multipartFile = await http.MultipartFile.fromPath(entry.key, entry.value.path);
      request.files.add(multipartFile);
    }

    var streamedResponse = await request.send().timeout(requestTimeout);
    if (cancelToken?.isCancelled == true) return _runResponseInterceptors(PlexNetworkCancelled());

    var responseBody = await streamedResponse.stream.transform(utf8.decoder).join();

    PlexLogger.d('Networking', 'Completed: ${streamedResponse.statusCode}: ${responseBody.toString()}');

    PlexApiResponse lastResponse;
    if (streamedResponse.statusCode == 200) {
      lastResponse = PlexSuccess(responseBody);
    } else {
      lastResponse = PlexNetworkServerError(
        streamedResponse.statusCode,
        responseBody.isEmpty ? streamedResponse.reasonPhrase ?? "Unknown error" : responseBody,
      );
    }
    return _runResponseInterceptors(lastResponse);
  } catch (e, stack) {
    if (e is TimeoutException) {
      return _runResponseInterceptors(PlexNetworkTimeout());
    }
    if (e is SocketException) {
      return _runResponseInterceptors(PlexNetworkNoConnectivity());
    }
    PlexLogger.e('Networking', 'Request failed', error: e);
    return _runResponseInterceptors(await _runErrorInterceptors(e, stack));
  }
}