perform method

@override Future<CubeFile> perform()

Implementation

@override
Future<CubeFile> perform() async {
  Completer<CubeFile> completer = Completer();

  try {
    String uuid = const Uuid().v4();

    CubeFile toCreate = CubeFile();
    toCreate.isPublic = isPublic ?? false;
    toCreate.name = _name ?? basename(_file!.path);

    if (!isEmpty(mimeType)) {
      toCreate.contentType = mimeType;
    } else {
      toCreate.contentType = lookupMimeType(toCreate.name!);
    }

    _CreateBlobQuery(toCreate).perform().then((cubeBlob) {
      toCreate.id = cubeBlob.id;
      toCreate.uid = cubeBlob.uid;

      var length = _file != null ? _file!.lengthSync() : _bytes!.length;

      ByteStream stream = _file != null
          ? ByteStream(_file!.openRead())
          : ByteStream.fromBytes(_bytes!);

      CubeFileObjectAccess? fileObjectAccess = cubeBlob.fileObjectAccess;
      BaseRequest request;

      if (fileObjectAccess?.method == 'PUT') {
        Map<String, dynamic> params = cubeBlob.fileObjectAccess!.params!;

        Map<String, String> headers =
            Map.from(params['headers']).map((key, value) {
          return MapEntry(key, value.toString());
        });
        headers['Content-Length'] = length.toString();

        request = StreamedRequestProgressed(
          'PUT',
          Uri.parse(params['url']),
          onProgress: (int bytes, int total) {
            final int newProgress = ((bytes / total) * 100).toInt();
            if (newProgress != _progress) {
              if (onProgress != null) {
                onProgress!(newProgress);
              }
              _progress = newProgress;
            }
          },
        )
          ..headers.addAll(headers)
          ..contentLength = length;

        (request as StreamedRequestProgressed).sink.addStream(stream).then((_) async {
          await (request as StreamedRequest).sink.close();
        });
      } else {
        String amazonParams = cubeBlob.fileObjectAccess!.params!;
        Uri decodedUri = Uri.parse(amazonParams);
        Map<String, String> params = decodedUri.queryParameters.map(
            (key, value) => MapEntry(key, Uri.decodeQueryComponent(value)));

        MultipartFile multipartFile = MultipartFile('file', stream, length,
            filename: toCreate.name,
            contentType: MediaType.parse(cubeBlob.contentType!));

        request = MultipartRequestProgressed(
          "POST",
          Uri(
              scheme: decodedUri.scheme,
              host: decodedUri.host,
              path: decodedUri.path),
          onProgress: (int bytes, int total) {
            final int newProgress = ((bytes / total) * 100).toInt();
            if (newProgress != _progress) {
              if (onProgress != null) {
                onProgress!(newProgress);
              }
              _progress = newProgress;
            }
          },
        )
          ..fields.addAll(params)
          ..files.add(multipartFile);
      }

      _logUploadBlobRequest(request, uuid);

      request.send().then((response) {
        _logUploadBlobResponse(response, uuid).then((voidValue) {
          if (response.statusCode == 201) {
            toCreate.size = length;

            DeclareBlobCompletedQuery(cubeBlob.id!, length)
                .perform()
                .then((voidResult) {
              toCreate.completedAt = DateTime.now();
              completer.complete(toCreate);
            });
          }
        });
      });
    }).catchError((error) {
      handelError(error);
      completer.completeError(error);
    });
  } catch (e) {
    completer.completeError(e);
  }

  return completer.future;
}