Fixes bugs in DiscordResponseParser (#113)

* fix: adds callAndParseMap to handle map responses
* fix: adds error handling for callAndParseMap and callAndParseList

Author: NightTripperID

api/src/main/java/com/javadiscord/jdi/core/api/AuditLogsRequest.java

@@ -15,7 +15,7 @@ public AuditLogsRequest(DiscordResponseParser responseParser, long guildId) {
     }
 
     public AsyncResponse<List<AuditLogEntry>> getAuditLogs(GetAuditLogsBuilder builder) {
-        return responseParser.callAndParseList(
-                AuditLogEntry.class, builder.guildId(guildId).build());
+        return responseParser.callAndParseMap(
+                "audit_log_entries", builder.guildId(guildId).build());
     }
 }

api/src/main/java/com/javadiscord/jdi/core/api/DiscordResponseParser.java

@@ -8,6 +8,7 @@
 import com.javadiscord.jdi.internal.api.DiscordResponseFuture;
 
 import java.util.List;
+import java.util.Map;
 
 public class DiscordResponseParser {
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
@@ -21,25 +22,60 @@ public <T> AsyncResponse<List<T>> callAndParseList(Class<T> clazz, DiscordReques
         AsyncResponse<List<T>> asyncResponse = new AsyncResponse<>();
         DiscordResponseFuture future = dispatcher.queue(request);
         future.onSuccess(
-                res -> {
-                    try {
-                        List<T> resultList = parseResponse(clazz, res.body());
-                        asyncResponse.setResult(resultList);
-                    } catch (Exception e) {
-                        asyncResponse.setException(e);
+                response -> {
+                    if (isSuccessfulResponse(response)) {
+                        try {
+                            List<T> resultList = parseResponseFromList(clazz, response.body());
+                            asyncResponse.setResult(resultList);
+                        } catch (Exception e) {
+                            asyncResponse.setException(e);
+                        }
+                    } else {
+                        asyncResponse.setException(errorResponseException(response));
                     }
                 });
         future.onError(asyncResponse::setException);
         return asyncResponse;
     }
 
-    private <T> List<T> parseResponse(Class<T> elementType, String response)
+    public <T> AsyncResponse<List<T>> callAndParseMap(String key, DiscordRequest request) {
+        AsyncResponse<List<T>> asyncResponse = new AsyncResponse<>();
+        DiscordResponseFuture future = dispatcher.queue(request);
+        future.onSuccess(
+                response -> {
+                    if (isSuccessfulResponse(response)) {
+                        try {
+                            List<T> resultList = parseResponseFromMap(key, response.body());
+                            asyncResponse.setResult(resultList);
+                        } catch (Exception e) {
+                            asyncResponse.setException(e);
+                        }
+                    } else {
+                        asyncResponse.setException(errorResponseException(response));
+                    }
+                });
+        future.onError(asyncResponse::setException);
+        return asyncResponse;
+    }
+
+    private <T> List<T> parseResponseFromList(Class<T> elementType, String response)
             throws JsonProcessingException {
         return OBJECT_MAPPER.readValue(
                 response,
                 OBJECT_MAPPER.getTypeFactory().constructCollectionType(List.class, elementType));
     }
 
+    private <T> List<T> parseResponseFromMap(String key, String response)
+            throws JsonProcessingException {
+        Map<String, List<T>> res =
+                OBJECT_MAPPER.readValue(
+                        response,
+                        OBJECT_MAPPER
+                                .getTypeFactory()
+                                .constructMapType(Map.class, String.class, List.class));
+        return res.get(key);
+    }
+
     public <T> AsyncResponse<T> callAndParse(Class<T> clazz, DiscordRequest request) {
         AsyncResponse<T> asyncResponse = new AsyncResponse<>();
         DiscordResponseFuture future = dispatcher.queue(request);
@@ -50,20 +86,24 @@ public <T> AsyncResponse<T> callAndParse(Class<T> clazz, DiscordRequest request)
 
     private <T> void success(
             Class<T> type, DiscordResponse response, AsyncResponse<T> asyncResponse) {
-        if (response.status() >= 200 && response.status() < 300) {
+        if (isSuccessfulResponse(response)) {
             try {
                 T result = OBJECT_MAPPER.readValue(response.body(), type);
                 asyncResponse.setResult(result);
             } catch (JsonProcessingException e) {
                 asyncResponse.setException(e);
             }
         } else {
-            asyncResponse.setException(
-                    new Exception(
-                            "Received HTTP status code "
-                                    + response.status()
-                                    + " "
-                                    + response.body()));
+            asyncResponse.setException(errorResponseException(response));
         }
     }
+
+    private boolean isSuccessfulResponse(DiscordResponse response) {
+        return response.status() >= 200 && response.status() < 300;
+    }
+
+    private Throwable errorResponseException(DiscordResponse response) {
+        return new Exception(
+                "Received HTTP status code " + response.status() + " " + response.body());
+    }
 }