uploadFiles method

Future<Response> uploadFiles({
  1. String? url,
  2. IsolateModel? isolateModel,
  3. StreamTransformer<List<int>, String>? decoder,
  4. List<FileEntity>? multiKey,
  5. MultipleFileEntity? singleKey,
  6. List<BlobFileEntity>? multiKeyBlobFile,
  7. MultipleBlobFileEntity? singleKeyBlobFile,
  8. dynamic onProgress(
    1. int bytes,
    2. int totalBytes
    )?,
  9. dynamic cancelToken(
    1. Function c
    )?,
  10. OnTimeout? onTimeout,
  11. Duration? timeLimit,
})

Implementation

Future<Response> uploadFiles(
    {String? url,
    IsolateModel? isolateModel,
    StreamTransformer<List<int>, String>? decoder,
    List<FileEntity>? multiKey,
    MultipleFileEntity? singleKey,
    List<BlobFileEntity>? multiKeyBlobFile,
    MultipleBlobFileEntity? singleKeyBlobFile,
    Function(int bytes, int totalBytes)? onProgress,
    Function(Function c)? cancelToken,
    OnTimeout? onTimeout,
    Duration? timeLimit}) async {
  if (client == null) client = http.Client();
  if (timeLimit == null) timeLimit = config.uploadTimeout;

  var request = isolateModel!.request;
  var req = FileRequest(request.method.value, Uri.parse(url ?? config.url),
      (bytes, totalBytes) {
    _print('Upload progress : ' + (bytes / totalBytes).toString());
    if (onProgress != null) onProgress(bytes, totalBytes);
  });

  if (singleKeyBlobFile != null) {
    singleKeyBlobFile.blobEntries.forEach((blobEntry) {
      req.files.add(http.MultipartFile.fromBytes(
          singleKeyBlobFile.key, blobEntry.blobData,
          contentType: MediaType('application', 'octet-stream'),
          filename: blobEntry.blobName));
    });
  }

  if (multiKeyBlobFile != null) {
    multiKeyBlobFile.forEach((file) {
      req.files.add(http.MultipartFile.fromBytes(
          file.key, file.blobEntry.blobData,
          contentType: MediaType('application', 'octet-stream'),
          filename: file.blobEntry.blobName));
    });
  }

  if (multiKey != null) {
    multiKey.forEach((file) async {
      req.files.add(await http.MultipartFile.fromPath(file.key, file.path));
    });
  }

  if (singleKey != null) {
    singleKey.paths.forEach((path) async {
      req.files.add(await http.MultipartFile.fromPath(singleKey.key, path));
    });
  }

  Crypto crypto = Crypto(config.secretKey, config.publicKey);

  String requestMessage = _prepareRequestMessage(crypto, isolateModel);

  req.fields[isolateModel.requestParamName] = requestMessage;
  req.fields['os'] = _getOS();

  if (cancelToken != null) cancelToken(req.close);

  var res = await req.send().timeout(timeLimit, onTimeout: onTimeout);

  // if (res != null) {
  if (res.statusCode == 200) {
    var responseBody = await res.stream.bytesToString();
    var responseMessage = responseBody;
    _print('raw response : ' + responseMessage);

    responseMessage = _decrypt(crypto, isolateModel, responseMessage);

    try {
      var jsonResponse = convert.jsonDecode(responseMessage);
      _print('json decoded : ' + jsonResponse.toString());
      return Response(
        responseBody,
        res.statusCode,
        result: jsonResponse,
        state: ResponseState.SUCCESS,
      );
    } catch (e) {
      _print('json decoded exception : ' + e.toString());
      return Response(
        responseBody,
        res.statusCode,
        result: null,
        state: ResponseState.UNEXPECTED,
      );
    }
//        res.stream
//            .transform(decoder ?? convert.utf8.decoder)
//            .listen((responseBody) {
//
//        });
  } else {
    // error
    _print(res.statusCode.toString() + ' ' + res.reasonPhrase!);
    return Response(res.reasonPhrase, res.statusCode,
        result: null, state: ResponseState.ERROR);
  }
  // } else {
  //   _print('http response is null!');
  //   return Response('http response is null!', -1,
  //       result: null, state: ResponseState.ERROR);
  // }

  // if (await isConnected()) else {
  //   return Response('Check your network connection!', -1,
  //       result: null, state: ResponseState.NETWORK_CONNECTION);
  // }
}