(bunq/sdk_csharp#63) add response id to failed request

BunqSdk.Tests/Http/ResponseIdOnBadRequestTest.cs

@@ -0,0 +1,31 @@
+using System;
+using Bunq.Sdk.Context;
+using Bunq.Sdk.Exception;
+using Bunq.Sdk.Model.Generated.Endpoint;
+using Xunit;
+
+namespace Bunq.Sdk.Tests.Http
+{
+    public class ResponseIdOnBadRequestTest : BunqSdkTestBase
+    {
+        /// <summary>
+        /// API context to use for the test API calls.
+        /// </summary>
+        private static readonly ApiContext API_CONTEXT = GetApiContext();
+
+        /// <summary>
+        /// Invalid user id to trigger BadRequestException
+        /// </summary>
+        private const int INVALID_USER_PERSON_ID = 0;
+
+        [Fact]
+        public void TestBadRequestWithResponseId()
+        {
+            var caughtException = Assert.Throws<BadRequestException>(
+                () => UserPerson.Get(API_CONTEXT, INVALID_USER_PERSON_ID)
+            );
+
+            Assert.NotNull(caughtException.ResponseId);
+        }
+    }
+}

BunqSdk/Exception/ApiException.cs

@@ -4,12 +4,16 @@ namespace Bunq.Sdk.Exception
     public class ApiException : System.Exception
     {
         public int ResponseCode { get; private set; }
+        public string ResponseId { get; private set; }
 
+        /// <inheritdoc />
         /// <param name="responseCode">The HTTP Response code of the failed request.</param>
         /// <param name="message">The error message related to this exception.</param>
-        public ApiException(int responseCode, string message) : base(message)
+        /// <param name="responseId"></param>
+        protected ApiException(int responseCode, string message, string responseId) : base(message)
         {
             ResponseCode = responseCode;
+            ResponseId = responseId;
         }
     }   
 }

BunqSdk/Exception/BadRequestException.cs

@@ -2,7 +2,8 @@
 {
     public class BadRequestException : ApiException
     {
-        public BadRequestException(int responseCode, string message) : base(responseCode, message)
+        public BadRequestException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/ExceptionFactory.cs

@@ -1,7 +1,11 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace Bunq.Sdk.Exception
 {
+    /// <summary>
+    /// This class makes sure that the correct exception is thrown for the given response code.
+    /// </summary>
     public class ExceptionFactory
     {
         /// <summary>
@@ -16,39 +20,49 @@ public class ExceptionFactory
         private const int HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR = 500;
 
         /// <summary>
-        /// Glue to concatenate the error messages.
+        /// String format constants.
         /// </summary>
-        private const string GLUE_ERROR_MESSAGES = "\n";
+        private const string FORMAT_ERROR_MESSAGE = "Response id to help bunq debug: {0}. \n Error message: {1}";
 
         /// <returns>The exception that belongs to this status code.</returns>
-        public static ApiException CreateExceptionForResponse(int responseCode, IList<string> messages)
+        public static ApiException CreateExceptionForResponse(
+            int responseCode,
+            IEnumerable<string> messages,
+            string responseId
+        )
         {
-            var errorMessage = ConcatenateMessages(messages);
+            var errorMessage = FormatExceptionMessage(messages, responseId);
 
             switch (responseCode)
             {
                 case HTTP_RESPONSE_CODE_BAD_REQUEST:
-                    return new BadRequestException(responseCode, errorMessage);
+                    return new BadRequestException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_UNAUTHORIZED:
-                    return new UnauthorizedException(responseCode, errorMessage);
+                    return new UnauthorizedException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_FORBIDDEN:
-                    return new ForbiddenException(responseCode, errorMessage);
+                    return new ForbiddenException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_NOT_FOUND:
-                    return new NotFoundException(responseCode, errorMessage);
+                    return new NotFoundException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED:
-                    return new MethodNotAllowedException(responseCode, errorMessage);
+                    return new MethodNotAllowedException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS:
-                    return new TooManyRequestsException(responseCode, errorMessage);
+                    return new TooManyRequestsException(responseCode, errorMessage, responseId);
                 case HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR:
-                    return new PleaseContactBunqException(responseCode, errorMessage);
+                    return new PleaseContactBunqException(responseCode, errorMessage, responseId);
                 default:
-                     return new UnknownApiErrorException(responseCode, errorMessage);
+                     return new UnknownApiErrorException(responseCode, errorMessage, responseId);
             }
         }
 
-        private static string ConcatenateMessages(IEnumerable<string> messages)
+        /// <summary>
+        /// Formats the exception message accordingly.
+        /// </summary>
+        private static string FormatExceptionMessage(IEnumerable<string> messages, string responseId)
         {
-            return string.Join(GLUE_ERROR_MESSAGES, messages);
+            return string.Format(FORMAT_ERROR_MESSAGE,
+                responseId,
+                string.Join(Environment.NewLine, messages)
+            );
         }
     }
 }

BunqSdk/Exception/ForbiddenException.cs

@@ -2,7 +2,8 @@
 {
     public class ForbiddenException : ApiException
     {
-        public ForbiddenException(int responseCode, string message) : base(responseCode, message)
+        public ForbiddenException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/MethodNotAllowedException.cs

@@ -2,7 +2,8 @@
 {
     public class MethodNotAllowedException : ApiException
     {
-        public MethodNotAllowedException(int responseCode, string message) : base(responseCode, message)
+        public MethodNotAllowedException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/NotFoundException.cs

@@ -2,7 +2,8 @@
 {
     public class NotFoundException : ApiException
     {
-        public NotFoundException(int responseCode, string message) : base(responseCode, message)
+        public NotFoundException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/PleaseContactBunqException.cs

@@ -2,7 +2,8 @@
 {
     public class PleaseContactBunqException : ApiException
     {
-        public PleaseContactBunqException(int responseCode, string message) : base(responseCode, message)
+        public PleaseContactBunqException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/TooManyRequestsException.cs

@@ -2,7 +2,8 @@
 {
     public class TooManyRequestsException : ApiException
     {
-        public TooManyRequestsException(int responseCode, string message) : base(responseCode, message)
+        public TooManyRequestsException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/UnauthorizedException.cs

@@ -2,7 +2,8 @@
 {
     public class UnauthorizedException : ApiException
     {
-        public UnauthorizedException(int responseCode, string message) : base(responseCode, message)
+        public UnauthorizedException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Exception/UnknownApiErrorException.cs

@@ -5,7 +5,8 @@
     /// </summary>
     public class UnknownApiErrorException : ApiException
     {
-        public UnknownApiErrorException(int responseCode, string message) : base(responseCode, message)
+        public UnknownApiErrorException(int responseCode, string message, string responseId)
+            : base(responseCode, message, responseId)
         {
         }
     }

BunqSdk/Http/ApiClient.cs

@@ -16,6 +16,12 @@ namespace Bunq.Sdk.Http
 {
     public class ApiClient
     {
+
+        /// <summary>
+        /// Error constatns.
+        /// </summary>
+        private static string ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER =
+            "The response header \"X-Bunq-Client-Response-Id\" or \"x-bunq-client-response-id\" could not be found.";
 
         /// <summary>
         /// Endpoints not requiring active session for the request to succeed.
@@ -43,6 +49,8 @@ public class ApiClient
         private const string HEADER_GEOLOCATION = "X-Bunq-Geolocation";
         private const string HEADER_SIGNATURE = "X-Bunq-Client-Signature";
         private const string HEADER_AUTHENTICATION = "X-Bunq-Client-Authentication";
+        private static string HEADER_RESPONSE_ID_LOWER_CASE = "x-bunq-client-response-id";
+        private static string HEADER_RESPONSE_ID_UPPER_CASE = "X-Bunq-Client-Response-Id";
 
         /// <summary>
         /// Field constants.
@@ -282,18 +290,50 @@ private static void AssertResponseSuccess(HttpResponseMessage responseMessage)
             var responseCode = (int) responseMessage.StatusCode;
             var responseBody = responseMessage.Content.ReadAsStringAsync().Result;
 
-            throw CreateApiExceptionRequestUnsuccessful(responseCode, responseBody);
+            throw CreateApiExceptionRequestUnsuccessful(
+                responseCode,
+                responseBody,
+                DetermineResponseIdByAllHeader(responseMessage.Headers)
+            );
+        }
+
+        private static string DetermineResponseIdByAllHeader(HttpHeaders allHeader)
+        {
+            if (allHeader.Contains(HEADER_RESPONSE_ID_UPPER_CASE))
+            {
+                return allHeader.GetValues(HEADER_RESPONSE_ID_UPPER_CASE).First();
+            }
+            else if (allHeader.Contains(HEADER_RESPONSE_ID_LOWER_CASE))
+            {
+                return allHeader.GetValues(HEADER_RESPONSE_ID_LOWER_CASE).First();
+            }
+            else
+            {
+                throw new BunqException(ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER);
+            }
         }
 
-        private static ApiException CreateApiExceptionRequestUnsuccessful(int responseCode, string responseBody)
+        private static ApiException CreateApiExceptionRequestUnsuccessful(
+            int responseCode,
+            string responseBody,
+            string responseId
+        )
         {
             try
             {
-                return ExceptionFactory.CreateExceptionForResponse(responseCode, FetchErrorDescriptions(responseBody));
+                return ExceptionFactory.CreateExceptionForResponse(
+                    responseCode,
+                    FetchErrorDescriptions(responseBody),
+                    responseId
+                );
             }
             catch (JsonException)
             {
-                return ExceptionFactory.CreateExceptionForResponse(responseCode, new List<string> {responseBody});
+                return ExceptionFactory.CreateExceptionForResponse(
+                    responseCode,
+                    new List<string> {responseBody},
+                    responseId
+                );
             }
         }