feat: Processes multiple reservations

Updates reservation processing to handle multiple reservations within a single request.

This change enables the API to accept and process an array of reservations, improving efficiency and reducing the need for multiple individual requests. It introduces a `ReservationRefSet` to encapsulate the array of `ReservationRef` objects and related tracking information. It also includes error handling for individual reservation failures within the set.

Author: Antaris

apps/GuestLineSDK.ConsoleSample/Program.cs

@@ -21,7 +21,7 @@
 	RateId: "1299224125",
 	AriAction: AriAction.Range,
 	Start: new(2026, 02, 15),
-	End: new(2026, 02, 15)
+	End: new(2026, 02, 16)
 ));
 
 var res = new ReservationRequest(
@@ -61,7 +61,7 @@
 var reservationResult = await api.Reservation.ProcessReservationAsync(
 	new GuestLineReservationRequest(
 		"12992",
-		[res]));
+		[res, res]));
 
 //string json = GetARIUpdate();
 

libs/GuestLineSDK/Api/ReservationOperations.cs

@@ -27,7 +27,7 @@ partial class GuestLineApiClient
 
 public partial interface IReservationOperations
 {
-	Task<GuestLineResponse<ReservationRef>> ProcessReservationAsync(
+	Task<GuestLineResponse<ReservationRefSet>> ProcessReservationAsync(
 		GuestLineReservationRequest request,
 		CancellationToken cancellationToken = default);
 }
@@ -36,7 +36,7 @@ public class ReservationOperations(ApiClient client) : IReservationOperations
 {
 	readonly ApiClient _client = client;
 
-	public async Task<GuestLineResponse<ReservationRef>> ProcessReservationAsync(GuestLineReservationRequest request, CancellationToken cancellationToken = default)
+	public async Task<GuestLineResponse<ReservationRefSet>> ProcessReservationAsync(GuestLineReservationRequest request, CancellationToken cancellationToken = default)
 	{
 
 		Ensure.IsNotNull(request, nameof(request));
@@ -52,8 +52,63 @@ public async Task<GuestLineResponse<ReservationRef>> ProcessReservationAsync(Gue
 			PathString.Empty,
 			request);
 
-		return await _client.FetchAsync<GuestLineReservationRequest, ReservationRef>(req, cancellationToken)
+		var (res, data) = await _client.FetchRawAsync<GuestLineReservationRequest, ReservationRef[]>(req, cancellationToken)
 			.ConfigureAwait(false);
+
+		if (!res.IsSuccess)
+		{
+			return new GuestLineResponse<ReservationRefSet>(
+				res.RequestMethod,
+				res.RequestUri,
+				res.IsSuccess,
+				res.StatusCode,
+				error: res.Error);
+		}
+
+		string? trackingId = null;
+		List<ReservationRef> refs = new();
+		List<string> errors = new();
+		bool success = true;
+
+		if (data != null)
+		{
+			var tracker = data.FirstOrDefault(x => !string.IsNullOrEmpty(x.TrackingId));
+			trackingId = tracker?.TrackingId;
+
+			for (int i = 0; i < data.Length; i++)
+			{
+				var @ref = data[i];
+				if (@ref == tracker)
+				{
+					continue;
+				}
+
+				if (@ref.Error is { Length: >0 } || string.Equals("fail", @ref.Status, StringComparison.OrdinalIgnoreCase))
+				{
+					success = false;
+					if (@ref.Error is { Length: >0 })
+					{
+						errors.Add(@ref.Error);
+					}
+				}
+
+				@ref.TrackingId = tracker?.TrackingId;
+				refs.Add(@ref);
+			}
+		}
+
+		return new GuestLineResponse<ReservationRefSet>(
+			res.RequestMethod,
+			res.RequestUri,
+			success,
+			res.StatusCode,
+			data: new ReservationRefSet()
+			{
+				Reservations = refs.ToArray(),
+				TrackingId = trackingId
+			},
+			error: res.Error ?? new ErrorResponse() { Error = string.Join("\n", errors), Status = "Fail", TrackingId = trackingId }
+		);
 	}
 }
 
@@ -93,6 +148,12 @@ public class ReservationRef : Result<ReservationRef>
 	public string? BookingId { get; set; }
 }
 
+public class ReservationRefSet : Result<ReservationRefSet>
+{
+	[JsonPropertyName("reservations")]
+	public ReservationRef[]? Reservations { get; set; }
+}
+
 public record ReservationRequest(
 	[property: JsonPropertyName("reservation_datetime"), JsonConverter(typeof(DateTimeJsonConverter))] DateTime ReservationDateTime,
 	[property: JsonPropertyName("reservation_id")] string ReservationId,

libs/GuestLineSDK/ApiClient.cs

@@ -269,6 +269,71 @@ protected internal async Task<GuestLineResponse<TResponse>> FetchAsync<TRequest,
 			}
 		}
 	}
+
+	protected internal async Task<(GuestLineResponse, TResponse?)> FetchRawAsync<TRequest, TResponse>(
+		GuestLineRequest<TRequest> request,
+		CancellationToken cancellationToken = default)
+		where TRequest : notnull
+		where TResponse : class
+	{
+		Ensure.IsNotNull(request, nameof(request));
+		var (httpReq, capturedRequestContent) = CreateHttpRequest(request);
+		HttpResponseMessage? httpResp = null;
+
+		try
+		{
+			httpResp = await _http.SendAsync(httpReq, cancellationToken)
+				.ConfigureAwait(false);
+
+			var (transformedResponse, data, capturedResponseContent) = await TransformRawResponse<TResponse>(
+				httpReq.Method,
+				httpReq.RequestUri,
+				httpResp)
+					.ConfigureAwait(false); ;
+
+			if (_settings.CaptureRequestContent)
+			{
+				transformedResponse.RequestContent = capturedRequestContent;
+			}
+
+			if (_settings.CaptureResponseContent || !httpResp.IsSuccessStatusCode)
+			{
+				transformedResponse.ResponseContent = capturedResponseContent;
+			}
+
+			return (transformedResponse, data);
+		}
+		catch (Exception ex)
+		{
+			ex = ex.Demystify();
+
+			var response = new GuestLineResponse(
+				httpReq.Method,
+				httpReq.RequestUri,
+				false,
+				(HttpStatusCode)0,
+				error: new ErrorResponse
+				{
+					Error = ex.Message,
+					Exception = ex,
+					ErrorSource = ErrorSource.SDK
+				});
+
+			return (response, null);
+		}
+		finally
+		{
+			if (httpReq is not null)
+			{
+				httpReq.Dispose();
+			}
+
+			if (httpResp is not null)
+			{
+				httpResp.Dispose();
+			}
+		}
+	}
 	#endregion
 
 	#region Preprocessing
@@ -487,6 +552,116 @@ protected internal (HttpRequestMessage, string?) CreateHttpRequest<TRequest>(
 			), stringContent);
 		}
 	}
+
+	protected internal async Task<(GuestLineResponse, TResponse?, string?)> TransformRawResponse<TResponse>(
+		HttpMethod method,
+		Uri uri,
+		HttpResponseMessage response,
+		CancellationToken cancellationToken = default)
+		where TResponse : class
+	{
+		Stream? content = null;
+		string? stringContent = null;
+		if (response.Content is not null)
+		{
+			if (_settings.CaptureResponseContent || !response.IsSuccessStatusCode)
+			{
+				stringContent = await response.Content.ReadAsStringAsync()
+					.ConfigureAwait(false);
+			}
+			else
+			{
+				content = await response.Content.ReadAsStreamAsync()
+				.ConfigureAwait(false);
+			}
+		}
+
+		if (response.IsSuccessStatusCode)
+		{
+			TResponse? data = default;
+			if (content is not null || stringContent is { Length: > 0 })
+			{
+				try
+				{
+					data = stringContent is { Length: > 0 }
+						? JsonSerializer.Deserialize<TResponse>(stringContent, _deserializerOptions)
+						: await JsonSerializer.DeserializeAsync<TResponse>(content!, _deserializerOptions).ConfigureAwait(false);
+
+					return (new GuestLineResponse(
+						method,
+						uri,
+						response.IsSuccessStatusCode,
+						response.StatusCode), data, stringContent);
+				}
+				catch (Exception ex)
+				{
+					ex = ex.Demystify();
+
+					return new(
+						new GuestLineResponse(
+							method,
+							uri,
+							response.IsSuccessStatusCode,
+							response.StatusCode,
+							error: new ErrorResponse
+							{
+								Error = ex.Message,
+								Exception = ex,
+								ErrorSource = ErrorSource.SDK
+							}
+						), null, stringContent);
+				}
+			}
+
+			return (new GuestLineResponse(
+				method,
+				uri,
+				false,
+				response.StatusCode,
+				error: new ErrorResponse
+				{
+					Error = Resources.ApiClient_UnknownResponse
+				}
+			), null, stringContent);
+		}
+		else
+		{
+			ErrorResponse? error;
+			if (stringContent is { Length: > 0 })
+			{
+				var result = JsonSerializer.Deserialize<ErrorResponse>(stringContent, _deserializerOptions);
+
+				if (result?.Error is not { Length: > 0 })
+				{
+					error = new ErrorResponse
+					{
+						Error = Resources.ApiClient_UnknownResponse,
+						Status = result?.Status,
+						TrackingId = result?.TrackingId
+					};
+				}
+				else
+				{
+					error = result;
+				}
+			}
+			else
+			{
+				error = new ErrorResponse
+				{
+					Error = Resources.ApiClient_NoErrorMessage
+				};
+			}
+
+			return (new GuestLineResponse(
+				method,
+				uri,
+				false,
+				response.StatusCode,
+				error: error
+			), null, stringContent);
+		}
+	}
 	#endregion
 
 	protected internal Lazy<TOperations> Defer<TOperations>(Func<ApiClient, TOperations> factory)