org.glassfish.jersey.media.multipart.file.FileDataBodyPart Java Examples

/**
 * Perform a file upload using multipart/form-data, returning
 * a ClientResponse instance with the data returned from the endpoint.
 *
 * @param name the name for the form field that contains the file name
 * @param fileToUpload a File instance pointing to the file to upload
 * @param mediaTypeString the content-type of the uploaded file, if null will be determined from fileToUpload
 * @param formData the Form containing the name/value pairs
 * @param url the fully formed path to the GitLab API endpoint
 * @return a ClientResponse instance with the data returned from the endpoint
 * @throws IOException if an error occurs while constructing the URL
 */
protected Response upload(String name, File fileToUpload, String mediaTypeString, Form formData, URL url) throws IOException {

    MediaType mediaType = (mediaTypeString != null ? MediaType.valueOf(mediaTypeString) : null);
    try (FormDataMultiPart multiPart = new FormDataMultiPart()) {

        if (formData != null) {
            MultivaluedMap<String, String> formParams = formData.asMap();
            formParams.forEach((key, values) -> {
                if (values != null) {
                    values.forEach(value -> multiPart.field(key, value));
                }
            });
        }

        FileDataBodyPart filePart = mediaType != null ?
            new FileDataBodyPart(name, fileToUpload, mediaType) :
            new FileDataBodyPart(name, fileToUpload);
        multiPart.bodyPart(filePart);
        final Entity<?> entity = Entity.entity(multiPart, Boundary.addBoundary(multiPart.getMediaType()));
        return (invocation(url, null).post(entity));
    }
}
 

@Override
public ApiResponse<FileUploadResult> uploadFile(String channelId, Path... filePaths)
    throws IOException {

  if (filePaths.length == 0) {
    throw new IllegalArgumentException("At least one filePath required.");
  }

  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  for (Path filePath : filePaths) {
    FileDataBodyPart body = new FileDataBodyPart("files", filePath.toFile());
    multiPart.bodyPart(body);
  }
  multiPart.field("channel_id", channelId);

  return doApiPostMultiPart(getFilesRoute(), multiPart, FileUploadResult.class);
}
 

public DataWeaveAPIResponse<Void> post(ExecPOSTBody body) {
    WebTarget target = this._client.target(getBaseUri());
    final javax.ws.rs.client.Invocation.Builder invocationBuilder = target.request(MediaType.APPLICATION_JSON_TYPE);
    FormDataMultiPart multiPart = new FormDataMultiPart();
    if (body.getFile()!= null) {
        multiPart.bodyPart(new FileDataBodyPart("file", body.getFile()));
    }
    if (body.getFrom()!= null) {
        multiPart.field("From", body.getFrom().toString());
    }
    Response response = invocationBuilder.post(Entity.entity(multiPart, multiPart.getMediaType()));
    if (response.getStatusInfo().getFamily()!= Family.SUCCESSFUL) {
        Response.StatusType statusInfo = response.getStatusInfo();
        throw new DataWeaveAPIException(statusInfo.getStatusCode(), statusInfo.getReasonPhrase(), response.getStringHeaders(), response);
    }
    DataWeaveAPIResponse<Void> apiResponse = new DataWeaveAPIResponse<Void>(null, response.getStringHeaders(), response);
    return apiResponse;
}
 

public void post(ExecPOSTBody body) {
    WebTarget target = this._client.target(getBaseUri());
    final javax.ws.rs.client.Invocation.Builder invocationBuilder = target.request(MediaType.APPLICATION_JSON_TYPE);
    FormDataMultiPart multiPart = new FormDataMultiPart();
    if (body.getFile()!= null) {
        multiPart.bodyPart(new FileDataBodyPart("file", body.getFile()));
    }
    if (body.getFrom()!= null) {
        multiPart.field("From", body.getFrom().toString());
    }
    Response response = invocationBuilder.post(Entity.entity(multiPart, multiPart.getMediaType()));
    if (response.getStatusInfo().getFamily()!= Family.SUCCESSFUL) {
        Response.StatusType statusInfo = response.getStatusInfo();
        throw new DataWeaveAPIException(statusInfo.getStatusCode(), statusInfo.getReasonPhrase(), response.getStringHeaders(), response);
    }
}
 

@Override
public CompletableFuture<String> triggerFunctionAsync(
        String tenant, String namespace, String function,
        String topic, String triggerValue, String triggerFile) {
    final FormDataMultiPart mp = new FormDataMultiPart();
    if (triggerFile != null) {
        mp.bodyPart(new FileDataBodyPart("dataStream",
                new File(triggerFile),
                MediaType.APPLICATION_OCTET_STREAM_TYPE));
    }
    if (triggerValue != null) {
        mp.bodyPart(new FormDataBodyPart("data", triggerValue, MediaType.TEXT_PLAIN_TYPE));
    }
    if (topic != null && !topic.isEmpty()) {
        mp.bodyPart(new FormDataBodyPart("topic", topic, MediaType.TEXT_PLAIN_TYPE));
    }
    WebTarget path = functions.path(tenant).path(namespace).path(function).path("trigger");

    final CompletableFuture<String> future = new CompletableFuture<>();
    try {
        request(path).async().post(Entity.entity(mp, MediaType.MULTIPART_FORM_DATA),
                new InvocationCallback<String>() {
                    @Override
                    public void completed(String response) {
                        future.complete(response);
                    }

                    @Override
                    public void failed(Throwable throwable) {
                        log.warn("[{}] Failed to perform http post request: {}",
                                path.getUri(), throwable.getMessage());
                        future.completeExceptionally(getApiException(throwable.getCause()));
                    }
                });
    } catch (PulsarAdminException cae) {
        future.completeExceptionally(cae);
    }
    return future;
}
 

public void sendFileToRemoteAndUnZip(final List<String> filesPath, final String saveToPath) {
    Response response = null;
    final MultiPart multiPart = new MultiPart(MediaType.MULTIPART_FORM_DATA_TYPE);

    filesPath.stream().forEach(path -> multiPart.bodyPart(new FileDataBodyPart("file",
            new File(separatorsToSystem(path)), MediaType.APPLICATION_OCTET_STREAM_TYPE)));

    try {
        response = client.target("http://" + ip + ":" + port + "/selenium")
                .path("content")
                .path("upload")
                .queryParam("saveTo", separatorsToSystem(saveToPath))
                .queryParam("unZip", true)
                .request(MediaType.APPLICATION_JSON_TYPE)
                .post(Entity.entity(multiPart, multiPart.getMediaType()));

        final int status = response.getStatus();

        if (status == Response.Status.OK.getStatusCode()) {
            CLIENT_LOGGER.info("File(-s) " + filesPath + " has been saved to " + separatorsToSystem(saveToPath) + " on " + ip);
        } else {
            CLIENT_LOGGER.severe("Unable to save or unZip file(-s) " + filesPath + " to " + separatorsToSystem(saveToPath) + " on " + ip + "; status = " + status);
        }
    } catch (Exception e) {
        CLIENT_LOGGER.info("An error occurred while file(-s) uploading: " + e);
        response = null;
    } finally {
        if (response != null) {
            response.close();
        }
    }
}
 

/**
 * load ${cert} for ${jobId}job
 * @param jobId
 * @param cert
 * @return
 */
public Resp<UploadCertResponse> uploadCert(Long jobId, File cert) {
    MultiPart multiPart = new FormDataMultiPart().bodyPart(
        new FileDataBodyPart("file", cert, MediaType.MULTIPART_FORM_DATA_TYPE)
    );

    BceClientConfig config = BceClientConfig.newDefaultBceClientConfig()
                                            .withMessageBodyWriterClass(MultiPartWriter.class);

    return super.createAuthorizedRequest(config)
                .path(certURL + "/upload/" + jobId)
                .postWithResponse(new Entity(multiPart, MediaType.MULTIPART_FORM_DATA))
                .getEntity(new GenericType<Resp<UploadCertResponse>>() { });
}
 

@Test
public void createFileSecretFileSizeExceeded() throws Exception {
  String pipelineId = "PIPELINE_VAULT_pipelineId";
  String secretName = "stage_id_config1";
  String secretValue = "secret";

  long maxBytesAllowedInFile = SecretResource.MAX_FILE_SIZE_KB_LIMIT_DEFAULT * 1024L;

  Path tempFile = Files.createTempFile("secret.txt", ".crt");

  try {
    try (FileWriter f = new FileWriter(tempFile.toFile().getAbsolutePath())) {
      int numberOfBytesWritten = 0;
      while (numberOfBytesWritten <= maxBytesAllowedInFile + 1) {
        f.write(secretValue);
        numberOfBytesWritten += secretValue.getBytes().length;
      }
    }

    FileDataBodyPart fileDataBodyPart = new FileDataBodyPart("uploadedFile", tempFile.toFile());
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    final FormDataMultiPart multipart = (FormDataMultiPart) formDataMultiPart
        .field("vault", pipelineId, MediaType.APPLICATION_JSON_TYPE)
        .field("name", secretName, MediaType.APPLICATION_JSON_TYPE)
        .bodyPart(fileDataBodyPart);

    Response response = target("/v1/secrets/file/ctx=SecretManage").register(MultiPartFeature.class).request()
        .post(Entity.entity(multipart, multipart.getMediaType()));

    Assert.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
    Assert.assertFalse(
        TestUtil.CredentialStoreTaskTestInjector.INSTANCE.getNames().contains(pipelineId + "/" + secretName)
    );
  } finally {
    Files.delete(tempFile);
  }
}
 

private MultiPart getMultiPart(ResourceTestElement resourceToTest, Object entity) {
    MultiPart multiPart = new MultiPart();
    BodyPart filePart = new FileDataBodyPart(resourceToTest.fileNameHeader, resourceToTest.fileToUpload);
    BodyPart entityPart = new FormDataBodyPart(resourceToTest.entityNameHeader, entity, MediaType.APPLICATION_JSON_TYPE);
    multiPart.bodyPart(filePart).bodyPart(entityPart);
    return multiPart;
}
 

protected MultiPart getMultiPart(ResourceTestElement resourceToTest, Object entity) {
    MultiPart multiPart = new MultiPart();
    BodyPart filePart = new FileDataBodyPart(resourceToTest.getFileNameHeader(), resourceToTest.getFileToUpload());
    BodyPart entityPart = new FormDataBodyPart(resourceToTest.getEntityNameHeader(), entity, MediaType.APPLICATION_JSON_TYPE);
    multiPart.bodyPart(filePart).bodyPart(entityPart);
    return multiPart;
}
 

@Override
public BundleVersion create(final String bucketId, final BundleType bundleType, final File bundleFile, final String sha256)
        throws IOException, NiFiRegistryException {

    if (StringUtils.isBlank(bucketId)) {
        throw new IllegalArgumentException("Bucket id cannot be null or blank");
    }

    if (bundleType == null) {
        throw new IllegalArgumentException("Bundle type cannot be null");
    }

    if (bundleFile == null) {
        throw new IllegalArgumentException("Bundle file cannot be null");
    }

    return executeAction("Error creating extension bundle version", () -> {
        final WebTarget target = bucketExtensionBundlesTarget
                .path("{bundleType}")
                .resolveTemplate("bucketId", bucketId)
                .resolveTemplate("bundleType", bundleType.toString());

        final FileDataBodyPart fileBodyPart = new FileDataBodyPart("file", bundleFile, MediaType.APPLICATION_OCTET_STREAM_TYPE);

        final FormDataMultiPart multipart = new FormDataMultiPart();
        multipart.bodyPart(fileBodyPart);

        if (!StringUtils.isBlank(sha256)) {
            multipart.field("sha256", sha256);
        }

        return getRequestBuilder(target)
                .post(
                        Entity.entity(multipart, multipart.getMediaType()),
                        BundleVersion.class
                );
    });
}
 

@Override
public ApiResponse<PluginManifest> uploadPlugin(Path plugin, boolean force) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("plugin", plugin.toFile());
  multiPart.bodyPart(body);

  multiPart.field("force", force, MediaType.APPLICATION_JSON_TYPE);

  return doApiPostMultiPart(getPluginsRoute(), multiPart, PluginManifest.class);
}
 

@Override
public ApiResponse<Emoji> createEmoji(Emoji emoji, Path imageFile) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("image", imageFile.toFile());
  multiPart.bodyPart(body);

  multiPart.field("emoji", emoji, MediaType.APPLICATION_JSON_TYPE);

  return doApiPostMultiPart(getEmojisRoute(), multiPart, Emoji.class);
}
 

@Override
public ApiResponse<Boolean> uploadBrandImage(Path dataFile) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("image", dataFile.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getBrandImageRoute(), multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> uploadSamlPrivateCertificate(Path dataFile, String fileName) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("certificate", dataFile.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getSamlRoute() + "/certificate/private", multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> uploadSamlPublicCertificate(Path dataFile, String fileName) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("certificate", dataFile.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getSamlRoute() + "/certificate/public", multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> uploadSamlIdpCertificate(Path dataFile, String fileName) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("certificate", dataFile.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getSamlRoute() + "/certificate/idp", multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> uploadLicenseFile(Path licenseFile) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("license", licenseFile.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart("/license", multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> setTeamIcon(String teamId, Path iconFilePath) {
  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("image", iconFilePath.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getTeamIconRoute(teamId), multiPart).checkStatusOk();
}
 

@Override
public ApiResponse<Boolean> setProfileImage(String userId, Path imageFilePath) {
  MultiPart multiPart = new MultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);

  FileDataBodyPart body = new FileDataBodyPart("image", imageFilePath.toFile());
  multiPart.bodyPart(body);

  return doApiPostMultiPart(getUserProfileImageRoute(userId), multiPart).checkStatusOk();
}
 

private void addAttachment(String name, File file) {
    this.multiPart.bodyPart(new FileDataBodyPart(name, file, APPLICATION_OCTET_STREAM_TYPE));
}
 

@Test
public void createFileSecret() throws Exception {
  String pipelineId = "PIPELINE_VAULT_pipelineId";
  String secretName = "stage_id_config1";
  String secretValue = "secret";


  Path tempFile = Files.createTempFile("secret.txt", ".crt");

  try {
    try (FileWriter f = new FileWriter(tempFile.toFile().getAbsolutePath())) {
      f.write(secretValue);
    }

    FileDataBodyPart fileDataBodyPart = new FileDataBodyPart("uploadedFile", tempFile.toFile());
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    final FormDataMultiPart multipart = (FormDataMultiPart) formDataMultiPart
        .field("vault", pipelineId, MediaType.APPLICATION_JSON_TYPE)
        .field("name", secretName, MediaType.APPLICATION_JSON_TYPE)
        .bodyPart(fileDataBodyPart);

    Response response = target("/v1/secrets/file/ctx=SecretManage").register(MultiPartFeature.class).request().post(
        Entity.entity(multipart, multipart.getMediaType()));

    Assert.assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

    InputStream responseEntity = (InputStream) response.getEntity();

    OkRestResponse<RSecret> secretResponse = ObjectMapperFactory.get()
        .readValue(responseEntity, new TypeReference<OkRestResponse<RSecret>>() {});

    RSecret rSecret = secretResponse.getData();
    Assert.assertNotNull(rSecret);
    Assert.assertEquals(pipelineId, rSecret.getVault().getValue());
    Assert.assertEquals(secretName, rSecret.getName().getValue());

    Assert.assertTrue(TestUtil.CredentialStoreTaskTestInjector.INSTANCE.getNames().contains(pipelineId + "/" + secretName));
    CredentialValue value = TestUtil.CredentialStoreTaskTestInjector.INSTANCE.get("",
        pipelineId + "/" + secretName,
        ""
    );
    Assert.assertEquals(IOUtils.toString(new FileReader(tempFile.toFile())), value.get());
  } finally {
    Files.delete(tempFile);
  }
}
 

@Test
public void updateFileSecret() throws Exception {
  String pipelineId = "PIPELINE_VAULT_pipelineId";
  String secretName = "stage_id_config1";
  String secretValue = "secretValue";
  TestUtil.CredentialStoreTaskTestInjector.INSTANCE.store(
      CredentialStoresTask.DEFAULT_SDC_GROUP_AS_LIST, pipelineId + "/" + secretName,
      secretValue
  );
  String changedSecretValue = "changedSecretValue";

  String secretPath = pipelineId + "/" + secretName;

  Path tempFile = Files.createTempFile("secret.txt", ".crt");

  try {
    try (FileWriter f = new FileWriter(tempFile.toFile().getAbsolutePath())) {
      f.write(changedSecretValue);
    }

    FileDataBodyPart fileDataBodyPart = new FileDataBodyPart("uploadedFile", tempFile.toFile());
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    final FormDataMultiPart multipart = (FormDataMultiPart) formDataMultiPart
        .field("vault", pipelineId, MediaType.APPLICATION_JSON_TYPE)
        .field("name", secretName, MediaType.APPLICATION_JSON_TYPE)
        .bodyPart(fileDataBodyPart);


    Response response = target(
        Utils.format("/v1/secrets/{}/file/ctx=SecretManage", URLEncoder.encode(secretPath, StandardCharsets.UTF_8.name()))
    ).register(MultiPartFeature.class).request().post(Entity.entity(multipart, multipart.getMediaType()));

    Assert.assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

    InputStream responseEntity = (InputStream) response.getEntity();

    OkRestResponse<RSecret> secretResponse = ObjectMapperFactory.get()
        .readValue(responseEntity, new TypeReference<OkRestResponse<RSecret>>() {});

    RSecret rSecret = secretResponse.getData();
    Assert.assertNotNull(rSecret);
    Assert.assertEquals(pipelineId, rSecret.getVault().getValue());
    Assert.assertEquals(secretName, rSecret.getName().getValue());

    Assert.assertTrue(TestUtil.CredentialStoreTaskTestInjector.INSTANCE.getNames().contains(pipelineId + "/" + secretName));
    CredentialValue changedValue = TestUtil.CredentialStoreTaskTestInjector.INSTANCE.get("",
        pipelineId + "/" + secretName,
        ""
    );
    Assert.assertEquals(IOUtils.toString(new FileReader(tempFile.toFile())), changedValue.get());
    Assert.assertEquals(changedSecretValue, changedValue.get());
  } finally {
    Files.delete(tempFile);
  }
}
 

@Test
public void updateFileSecretFileSizeExceeded() throws Exception {
  String pipelineId = "PIPELINE_VAULT_pipelineId";
  String secretName = "stage_id_config1";
  String secretValue = "secretValue";
  TestUtil.CredentialStoreTaskTestInjector.INSTANCE.store(
      CredentialStoresTask.DEFAULT_SDC_GROUP_AS_LIST, pipelineId + "/" + secretName,
      secretValue
  );
  String changedSecretValue = "changedSecretValue";

  String secretPath = pipelineId + "/" + secretName;


  Path tempFile = Files.createTempFile("secret.txt", ".crt");
  long maxBytesAllowedInFile = SecretResource.MAX_FILE_SIZE_KB_LIMIT_DEFAULT * 1024L;
  try {
    try (FileWriter f = new FileWriter(tempFile.toFile().getAbsolutePath())) {
      int numberOfBytesWritten = 0;
      while (numberOfBytesWritten <= maxBytesAllowedInFile + 1) {
        f.write(changedSecretValue);
        numberOfBytesWritten += secretValue.getBytes().length;
      }
    }

    FileDataBodyPart fileDataBodyPart = new FileDataBodyPart("uploadedFile", tempFile.toFile());
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();

    final FormDataMultiPart multipart = (FormDataMultiPart) formDataMultiPart
        .field("vault", pipelineId, MediaType.APPLICATION_JSON_TYPE)
        .field("name", secretName, MediaType.APPLICATION_JSON_TYPE)
        .bodyPart(fileDataBodyPart);

    Response response = target(
        Utils.format("/v1/secrets/{}/file/ctx=SecretManage", URLEncoder.encode(secretPath, StandardCharsets.UTF_8.name()))
    ).register(MultiPartFeature.class).request().post(Entity.entity(multipart, multipart.getMediaType()));

    Assert.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());

    //Max sure the old value is not changed
    Assert.assertTrue(TestUtil.CredentialStoreTaskTestInjector.INSTANCE.getNames().contains(pipelineId + "/" + secretName));
    CredentialValue value = TestUtil.CredentialStoreTaskTestInjector.INSTANCE.get(
        "",
        pipelineId + "/" + secretName,
        ""
    );
    Assert.assertEquals(secretValue, value.get());
  } finally {
    Files.delete(tempFile);
  }
}
 

/**
 * Perform a file upload using multipart/form-data using the HTTP PUT method, returning
 * a ClientResponse instance with the data returned from the endpoint.
 *
 * @param name the name for the form field that contains the file name
 * @param fileToUpload a File instance pointing to the file to upload

 * @param url the fully formed path to the GitLab API endpoint
 * @return a ClientResponse instance with the data returned from the endpoint
 * @throws IOException if an error occurs while constructing the URL
 */
protected Response putUpload(String name, File fileToUpload, URL url) throws IOException {

    try (MultiPart multiPart = new FormDataMultiPart()) {
        multiPart.bodyPart(new FileDataBodyPart(name, fileToUpload, MediaType.APPLICATION_OCTET_STREAM_TYPE));
        final Entity<?> entity = Entity.entity(multiPart, Boundary.addBoundary(multiPart.getMediaType()));
        return (invocation(url, null).put(entity));
    }
}
 

public Response uploadFile(final String file_path) {

    final FileDataBodyPart filePart = new FileDataBodyPart("file", new File(file_path));

    final FormDataMultiPart multiPart = new FormDataMultiPart();

    multiPart.bodyPart(filePart);

    final Response resp = fileUploadService.uploadFile(multiPart);

    return resp;
  }
 

/**
 * Adds an attachment from a {@link File}.
 *
 * @param file a file to attach
 * @return this builder
 */
public MultipartBuilder attachment(File file) {
    return bodyPart(new FileDataBodyPart(ATTACHMENT_NAME, file));
}