Merge pull request #162 from mailjet/async-operations

Async operations

Author: sdiakovskyi-gd

src/main/java/com/mailjet/client/MailjetClient.java

@@ -18,6 +18,8 @@
 
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CompletableFuture;
 
 import com.mailjet.client.errors.MailjetClientCommunicationException;
 import com.mailjet.client.errors.MailjetUnauthorizedException;
@@ -80,48 +82,90 @@ public MailjetClient(ClientOptions clientOptions) {
      * performs GET request.
      * @param request request to be sent to Mailjet server
      * @return MailjetResponse with parameters of the response
-     * @throws com.mailjet.client.errors.MailjetException in case of unsuccess response status code
+     * @throws com.mailjet.client.errors.MailjetException in case of unsuccessfull response status code
      */
      public MailjetResponse get(MailjetRequest request) throws MailjetException {
-        try {
-
-            final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
-                    .get()
-                    .build();
-
-            try (final Response okHttpResponse = _client.newCall(okHttpRequest).execute()) {
-                return parseResponse(request, okHttpResponse);
-            }
 
+         try (final Response okHttpResponse = getGetCall(request).execute()) {
+             return parseResponse(request, okHttpResponse);
         } catch (IOException ex) {
             throw new MailjetClientCommunicationException("Connection Exception", ex);
         }
     }
 
+    /**
+     * async version of {@link #get(MailjetRequest)} method
+     * performs GET request.
+     * @param request request to be sent to Mailjet server
+     * @return CompletableFuture with MailjetResponse response, or exception thrown during the call/response parsing
+     * CompletableFuture contains com.mailjet.client.errors.MailjetException in case of unsuccessfull call
+     */
+    public CompletableFuture<MailjetResponse> getAsync(MailjetRequest request) {
+        final CompletableFuture<MailjetResponse> resultFuture = new CompletableFuture<>();
+
+        try {
+            getGetCall(request).enqueue(getAsyncCallback(request, resultFuture));
+        } catch (MailjetException e) {
+            resultFuture.completeExceptionally(e);
+        }
+
+        return resultFuture;
+    }
+
+    private Call getGetCall(MailjetRequest request) throws MailjetException {
+        final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
+                .get()
+                .build();
+
+        return _client.newCall(okHttpRequest);
+    }
 
     /**
      * performs POST request.
      * @param request request to be sent to Mailjet server
      * @return MailjetResponse with parameters of the response
-     * @throws com.mailjet.client.errors.MailjetException in case of unsuccess response status code
+     * @throws com.mailjet.client.errors.MailjetException in case of unsuccessfull response status code
      */
     public MailjetResponse post(MailjetRequest request) throws MailjetException {
 
+        try (final Response okHttpResponse = getPostCall(request).execute()) {
+            return parseResponse(request, okHttpResponse);
+        } catch (IOException ex) {
+            throw new MailjetClientCommunicationException("Connection Exception", ex);
+        }
+    }
+
+    /**
+     * async version of {@link #post(MailjetRequest)} method
+     * performs POST request.
+     * @param request request to be sent to Mailjet server
+     * @return CompletableFuture with MailjetResponse response, or exception thrown during the call/response parsing
+     * CompletableFuture contains com.mailjet.client.errors.MailjetException in case of unsuccessfull call
+     */
+    public CompletableFuture<MailjetResponse> postAsync(MailjetRequest request) {
+        final CompletableFuture<MailjetResponse> resultFuture = new CompletableFuture<>();
+
         try {
-            final RequestBody requestBody = RequestBody.create(
-                    MediaType.parse(request.getContentType()), request.getBody().getBytes("UTF8"));
+            getPostCall(request).enqueue(getAsyncCallback(request, resultFuture));
+        } catch (MailjetException e) {
+            resultFuture.completeExceptionally(e);
+        }
 
-            final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
-                    .post(requestBody)
-                    .build();
+        return resultFuture;
+    }
 
-            try (final Response okHttpResponse = _client.newCall(okHttpRequest).execute()) {
-                return parseResponse(request, okHttpResponse);
-            }
+    private Call getPostCall(MailjetRequest request) throws MailjetException {
 
-        } catch (IOException ex) {
-            throw new MailjetClientCommunicationException("Connection Exception", ex);
-        }
+        final byte[] bodyContent = request.getBody().getBytes(StandardCharsets.UTF_8);
+
+        final RequestBody requestBody = RequestBody.create(
+                MediaType.parse(request.getContentType()), bodyContent);
+
+        final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
+                .post(requestBody)
+                .build();
+
+        return _client.newCall(okHttpRequest);
     }
 
     /**
@@ -131,49 +175,112 @@ public MailjetResponse post(MailjetRequest request) throws MailjetException {
      * @throws com.mailjet.client.errors.MailjetException in case of unsuccess response status code
      */
     public MailjetResponse put(MailjetRequest request) throws MailjetException {
-        try {
-            final RequestBody requestBody = RequestBody.create(
-                     MediaType.parse(request.getContentType()), request.getBody().getBytes("UTF8"));
-
-            final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
-                    .put(requestBody)
-                    .build();
-
-            try (final Response okHttpResponse = _client.newCall(okHttpRequest).execute()) {
-                return parseResponse(request, okHttpResponse);
-            }
 
+        try (final Response okHttpResponse = getPutCall(request).execute()) {
+            return parseResponse(request, okHttpResponse);
         } catch (IOException ex) {
             throw new MailjetClientCommunicationException("Connection Exception", ex);
         }
     }
 
+    /**
+     * async version of {@link #put(MailjetRequest)} method
+     * performs PUT request.
+     * CompletableFuture contains com.mailjet.client.errors.MailjetException in case of unsuccessfull call
+     * @param request request to be sent to Mailjet server
+     * @return CompletableFuture with MailjetResponse response, or exception thrown during the call/response parsing
+     */
+    public CompletableFuture<MailjetResponse> putAsync(MailjetRequest request) {
+        final CompletableFuture<MailjetResponse> resultFuture = new CompletableFuture<>();
+
+        try {
+            getPutCall(request).enqueue(getAsyncCallback(request, resultFuture));
+        } catch (MailjetException e) {
+            resultFuture.completeExceptionally(e);
+        }
+
+        return resultFuture;
+    }
+
+    private Call getPutCall(MailjetRequest request) throws MailjetException {
+
+        final byte[] bodyContent = request.getBody().getBytes(StandardCharsets.UTF_8);
+
+        final RequestBody requestBody = RequestBody.create(
+                MediaType.parse(request.getContentType()), bodyContent);
+
+        final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
+                .put(requestBody)
+                .build();
+
+        return _client.newCall(okHttpRequest);
+    }
+
     /**
      * performs DELETE request.
      * @param request request to be sent to Mailjet server
      * @return MailjetResponse with parameters of the response
      * @throws com.mailjet.client.errors.MailjetException in case of unsuccess response status code
      */
     public MailjetResponse delete(MailjetRequest request) throws MailjetException {
+
+        try (final Response okHttpResponse = getDeleteCall(request).execute()) {
+            return parseResponse(request, okHttpResponse);
+        } catch (IOException ex) {
+            throw new MailjetClientCommunicationException("Connection Exception", ex);
+        }
+    }
+
+    /**
+     * async version of {@link #delete(MailjetRequest)} method
+     * performs DELETE request.
+     * CompletableFuture contains com.mailjet.client.errors.MailjetException in case of unsuccessfull call
+     * @param request request to be sent to Mailjet server
+     * @return CompletableFuture with MailjetResponse with response
+     */
+    public CompletableFuture<MailjetResponse> deleteAsync(MailjetRequest request) {
+
+        final CompletableFuture<MailjetResponse> resultFuture = new CompletableFuture<>();
+
         try {
+            getDeleteCall(request).enqueue(getAsyncCallback(request, resultFuture));
+        } catch (MailjetException e) {
+            resultFuture.completeExceptionally(e);
+        }
 
-            final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
-                    .delete()
-                    .build();
+        return resultFuture;
+    }
 
-            try (final Response okHttpResponse = _client.newCall(okHttpRequest).execute()) {
-                return parseResponse(request, okHttpResponse);
+    private Call getDeleteCall(MailjetRequest request) throws MailjetException {
+        final Request okHttpRequest = getPreconfiguredRequestBuilder(request)
+                .delete()
+                .build();
+
+        return _client.newCall(okHttpRequest);
+    }
+
+    private Callback getAsyncCallback(MailjetRequest request, CompletableFuture<MailjetResponse> completableFuture){
+        return new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                completableFuture.completeExceptionally(new MailjetClientCommunicationException("Connection Exception", e));
             }
 
-        } catch (IOException ex) {
-            throw new MailjetClientCommunicationException("Connection Exception", ex);
-        }
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                try {
+                    completableFuture.complete(parseResponse(request, response));
+                } catch (MailjetException e) {
+                    completableFuture.completeExceptionally(e);
+                }
+            }
+        };
     }
 
     private MailjetResponse parseResponse(MailjetRequest request, Response okHttpResponse) throws IOException, MailjetException {
 
         final int responseStatusCode = okHttpResponse.code();
-        final String responseBody = okHttpResponse.body().string();
+        final String responseBody = okHttpResponse.body() != null ? okHttpResponse.body().string() : null;
 
         MailjetResponseUtil.validateMailjetResponse(request, responseStatusCode, responseBody);
 
@@ -189,14 +296,19 @@ private static OkHttpClient createDefaultOkHttpClient(){
                 .build();
     }
 
-    private Request.Builder getPreconfiguredRequestBuilder(MailjetRequest request) throws MailjetUnauthorizedException, UnsupportedEncodingException {
+    private Request.Builder getPreconfiguredRequestBuilder(MailjetRequest request) throws MailjetException {
 
-        final String url = request.buildUrl(this._options.getBaseUrl());
+        final String url;
+        try {
+            url = request.buildUrl(this._options.getBaseUrl());
+        } catch (UnsupportedEncodingException e) {
+            throw new MailjetClientCommunicationException("Connection Exception", e);
+        }
 
         final Request.Builder builder = new Request
                 .Builder()
                 .addHeader("Accept", "application/json")
-                .addHeader("User-Agent", this.userAgent)
+                .addHeader("User-Agent", userAgent)
                 .url(url);
 
         switch (request.getAuthenticationType()){

src/main/java/com/mailjet/client/transactional/Attachment.java

@@ -3,8 +3,10 @@
 import lombok.Builder;
 import lombok.Data;
 
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Base64;
@@ -55,4 +57,32 @@ public static Attachment fromFile(String pathToFile) throws IOException {
                 .filename(path.getFileName().toString())
                 .build();
     }
+
+    /**
+     * Creates an attachment from the input stream
+     * @param inputStream input stream that will be read as byte array
+     * @param attachmentFileName the name that will be given to the attachment in the email
+     * @param contentType mime type of the attachment https://www.iana.org/assignments/media-types/media-types.xhtml
+     * @return constructed Attachment object
+     * @throws IOException if something wrong with reading from input stream
+     */
+    public static Attachment fromInputStream(InputStream inputStream, String attachmentFileName, String contentType) throws IOException {
+
+        // replace this with .readAllBytes when migrating to Java 9
+        final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        int nRead;
+        byte[] data = new byte[4000];
+
+        while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
+            buffer.write(data, 0, nRead);
+        }
+
+        final String base64Content = Base64.getEncoder().encodeToString(buffer.toByteArray());
+
+        return new AttachmentBuilder()
+                .base64Content(base64Content)
+                .contentType(contentType)
+                .filename(attachmentFileName)
+                .build();
+    }
 }

src/main/java/com/mailjet/client/transactional/SendEmailsRequest.java

@@ -10,10 +10,10 @@
 import com.mailjet.client.resource.Emailv31;
 import com.mailjet.client.transactional.response.SendEmailsResponse;
 import lombok.Builder;
-import lombok.Builder.Default;
 import lombok.Singular;
 
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 @Builder
 public class SendEmailsRequest {
@@ -55,14 +55,40 @@ public class SendEmailsRequest {
      */
     public SendEmailsResponse sendWith(MailjetClient mailjetClient) throws MailjetException {
 
-        MailjetRequest request = new MailjetRequest(Emailv31.resource);
-        request.setBody(gson.toJson(this));
+        final MailjetResponse response = mailjetClient.post(getMailjetRequest());
 
-        MailjetResponse response = mailjetClient.post(request);
+        return convertResponse(response);
+    }
 
-        String responseContent = response.getRawResponseContent();
+    /**
+     * Represents a method to send multiple transactional emails asynchronously
+     * Note: Mailjet send API v3.1 will be used
+     * Note: Max 50 emails per batch allowed
+     * @param mailjetClient the Mailjet client that will be used to send messages
+     * @return A response future with sent messages information, or error information
+     * The returned future will contain MailjetException in case of communication error in HTTP stack,
+     * like, TLS connection couldn't be established to the Mailjet server
+     * Or the Server returned 5xx error,
+     * Or the Server returned the generic error response
+     */
+    public CompletableFuture<SendEmailsResponse> sendAsyncWith(MailjetClient mailjetClient)  {
 
-        SendEmailsResponse typedResponse = gson.fromJson(responseContent, SendEmailsResponse.class);
+        final CompletableFuture<SendEmailsResponse> responseCompletableFuture = new CompletableFuture<>();
+
+        try {
+            CompletableFuture<MailjetResponse> future = mailjetClient.postAsync(getMailjetRequest());
+            responseCompletableFuture.complete(convertResponse(future.get()));
+        } catch (Exception e) {
+            responseCompletableFuture.completeExceptionally(e);
+        }
+
+        return responseCompletableFuture;
+    }
+
+    private SendEmailsResponse convertResponse(MailjetResponse response) throws MailjetClientRequestException {
+        final String responseContent = response.getRawResponseContent();
+
+        final SendEmailsResponse typedResponse = gson.fromJson(responseContent, SendEmailsResponse.class);
 
         // in some cases, Mailjet server returns generic error w/o parsing the real passed messages
         if (typedResponse.getMessages() == null && response.getStatus() != MailjetResponseUtil.CREATED_STATUS){
@@ -71,4 +97,10 @@ public SendEmailsResponse sendWith(MailjetClient mailjetClient) throws MailjetEx
 
         return typedResponse;
     }
+
+    private MailjetRequest getMailjetRequest() {
+        final MailjetRequest request = new MailjetRequest(Emailv31.resource);
+        request.setBody(gson.toJson(this));
+        return request;
+    }
 }