feat: Add support for sending JSON-encoded API requests

Author: BriannaDelgado

deepl-java/src/main/java/com/deepl/api/DeepLClient.java

@@ -577,9 +577,15 @@ public MultilingualGlossaryInfo updateMultilingualGlossaryName(String glossaryId
     ArrayList<KeyValuePair<String, String>> bodyParams = new ArrayList<>();
     bodyParams.add(new KeyValuePair<>("name", name));
     String relativeUrl = String.format("/v3/glossaries/%s", glossaryId);
-    HttpResponse response = httpClientWrapper.sendPatchRequestWithBackoff(relativeUrl, bodyParams);
-    checkResponse(response, false, true);
-    return jsonParser.parseMultilingualGlossaryInfo(response.getBody());
+    try {
+      HttpResponse response =
+          httpClientWrapper.sendPatchRequestWithBackoff(relativeUrl, bodyParams);
+      checkResponse(response, false, true);
+      return jsonParser.parseMultilingualGlossaryInfo(response.getBody());
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new DeepLException("Request was interrupted", e);
+    }
   }
 
   /**

deepl-java/src/main/java/com/deepl/api/HttpClientWrapper.java

@@ -9,10 +9,12 @@
 import java.net.*;
 import java.time.*;
 import java.util.*;
+import org.apache.http.HttpHost;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpPatch;
 import org.apache.http.entity.ByteArrayEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.util.EntityUtils;
 import org.jetbrains.annotations.*;
@@ -83,15 +85,61 @@ public HttpResponse sendPutRequestWithBackoff(
     return sendRequestWithBackoff(PUT, relativeUrl, content).toStringResponse();
   }
 
+  public HttpResponse sendJsonRequestWithBackoff(String relativeUrl, String jsonBody)
+      throws InterruptedException, DeepLException {
+    HttpContent content = HttpContent.buildJsonContent(jsonBody);
+    return sendRequestWithBackoff(POST, relativeUrl, content).toStringResponse();
+  }
+
+  public HttpResponse sendJsonRequestWithBackoff(String method, String relativeUrl, String jsonBody)
+      throws InterruptedException, DeepLException {
+    HttpContent content = HttpContent.buildJsonContent(jsonBody);
+    return sendRequestWithBackoff(method, relativeUrl, content).toStringResponse();
+  }
+
+  public HttpResponse sendJsonPatchRequestWithBackoff(String relativeUrl, String jsonBody)
+      throws InterruptedException, DeepLException {
+    return sendPatchRequestWithBackoff(relativeUrl, HttpContent.buildJsonContent(jsonBody));
+  }
+
   public HttpResponse sendPatchRequestWithBackoff(
       String relativeUrl, @Nullable Iterable<KeyValuePair<String, String>> params)
-      throws DeepLException {
-    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
-      HttpContent content = HttpContent.buildFormURLEncodedContent(params);
+      throws InterruptedException, DeepLException {
+    HttpContent content = HttpContent.buildFormURLEncodedContent(params);
+    return sendPatchRequestWithBackoff(relativeUrl, content);
+  }
+
+  private HttpResponse sendPatchRequestWithBackoff(String relativeUrl, HttpContent content)
+      throws InterruptedException, DeepLException {
+    BackoffTimer backoffTimer = new BackoffTimer(this.minTimeout);
+    while (true) {
+      try {
+        HttpResponse response = sendPatchRequest(relativeUrl, content, backoffTimer);
+        if (backoffTimer.getNumRetries() >= this.maxRetries) {
+          return response;
+        } else if (response.getCode() != 429 && response.getCode() < 500) {
+          return response;
+        }
+      } catch (ConnectionException exception) {
+        if (!exception.getShouldRetry() || backoffTimer.getNumRetries() >= this.maxRetries) {
+          throw exception;
+        }
+      }
+      backoffTimer.sleepUntilRetry();
+    }
+  }
+
+  private HttpResponse sendPatchRequest(
+      String relativeUrl, HttpContent content, BackoffTimer backoffTimer) throws DeepLException {
+    HttpClientBuilder builder = HttpClients.custom();
+    if (proxy != null) {
+      InetSocketAddress addr = (InetSocketAddress) proxy.address();
+      builder.setProxy(new HttpHost(addr.getHostName(), addr.getPort()));
+    }
+    try (CloseableHttpClient httpClient = builder.build()) {
       HttpPatch request = new HttpPatch(serverUrl + relativeUrl);
 
       // Set timeouts
-      BackoffTimer backoffTimer = new BackoffTimer(this.minTimeout);
       RequestConfig requestConfig =
           RequestConfig.custom()
               .setConnectTimeout((int) backoffTimer.getTimeoutMillis())

deepl-java/src/main/java/com/deepl/api/http/HttpContent.java

@@ -52,6 +52,13 @@ private static String urlEncode(String value) throws DeepLException {
     }
   }
 
+  public static HttpContent buildJsonContent(String jsonBody) {
+    if (jsonBody == null) {
+      throw new IllegalArgumentException("jsonBody must not be null");
+    }
+    return new HttpContent("application/json", jsonBody.getBytes(StandardCharsets.UTF_8));
+  }
+
   public static HttpContent buildMultipartFormDataContent(
       Iterable<KeyValuePair<String, Object>> params) throws Exception {
     String boundary = UUID.randomUUID().toString();

deepl-java/src/test/java/com/deepl/api/MultilingualGlossaryTest.java

@@ -482,6 +482,27 @@ void testGlossaryUpdateName() throws Exception {
     }
   }
 
+  @Test
+  void testGlossaryUpdateNameWithSpecialCharsIsProperlyEncoded() throws Exception {
+    DeepLClient deepLClient = createDeepLClient();
+    try (MultilingualGlossaryCleanupUtility cleanup =
+        new MultilingualGlossaryCleanupUtility(deepLClient)) {
+      GlossaryEntries entries = new GlossaryEntries();
+      entries.put("key1", "value1");
+      List<MultilingualGlossaryDictionaryEntries> glossaryDicts =
+          Arrays.asList(new MultilingualGlossaryDictionaryEntries(sourceLang, targetLang, entries));
+      MultilingualGlossaryInfo glossary =
+          deepLClient.createMultilingualGlossary(cleanup.getGlossaryName(), glossaryDicts);
+
+      String nameWithSpecialChars = "Name with special chars: é &foo=bar \"quoted\"";
+      MultilingualGlossaryInfo updatedGlossary =
+          deepLClient.updateMultilingualGlossaryName(
+              glossary.getGlossaryId(), nameWithSpecialChars);
+
+      Assertions.assertEquals(nameWithSpecialChars, updatedGlossary.getName());
+    }
+  }
+
   @Test
   void testGlossaryTranslateTextSentence() throws Exception {
     DeepLClient deepLClient = createDeepLClient();