Cancellation tokens initial implementation (OrderService)

Author: R Hudylko

Source/FikaAmazonAPI/AmazonSpApiSDK/Runtime/LWAClient.cs

@@ -3,6 +3,7 @@
 using RestSharp;
 using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace FikaAmazonAPI.AmazonSpApiSDK.Runtime
@@ -31,7 +32,7 @@ public LWAClient(LWAAuthorizationCredentials lwaAuthorizationCredentials)
         /// </summary>
         /// <param name="lwaAccessTokenRequestMeta">LWA AccessTokenRequest metadata</param>
         /// <returns>LWA Access Token</returns>
-        public virtual async Task<TokenResponse> GetAccessTokenAsync()
+        public virtual async Task<TokenResponse> GetAccessTokenAsync(CancellationToken cancellationToken = default)
         {
             LWAAccessTokenRequestMeta lwaAccessTokenRequestMeta = LWAAccessTokenRequestMetaBuilder.Build(LWAAuthorizationCredentials);
             var accessTokenRequest = new RestRequest(LWAAuthorizationCredentials.Endpoint.AbsolutePath, RestSharp.Method.Post);
@@ -43,7 +44,7 @@ public virtual async Task<TokenResponse> GetAccessTokenAsync()
 
             try
             {
-                var response = await RestClient.ExecuteAsync(accessTokenRequest).ConfigureAwait(false);
+                var response = await RestClient.ExecuteAsync(accessTokenRequest, cancellationToken).ConfigureAwait(false);
 
                 if (!IsSuccessful(response))
                 {

Source/FikaAmazonAPI/Services/OrderService.cs

@@ -3,6 +3,7 @@
 using FikaAmazonAPI.Parameter.Order;
 using FikaAmazonAPI.Search;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace FikaAmazonAPI.Services
@@ -18,7 +19,7 @@ public OrderService(AmazonCredential amazonCredential) : base(amazonCredential)
 
         public OrderList GetOrders(ParameterOrderList searchOrderList) =>
             Task.Run(() => GetOrdersAsync(searchOrderList)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrderList> GetOrdersAsync(ParameterOrderList searchOrderList)
+        public async Task<OrderList> GetOrdersAsync(ParameterOrderList searchOrderList, CancellationToken cancellationToken = default)
         {
 
             var orderList = new OrderList();
@@ -46,8 +47,8 @@ public async Task<OrderList> GetOrdersAsync(ParameterOrderList searchOrderList)
 
             var queryParameters = searchOrderList.getParameters();
 
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.Orders, RestSharp.Method.Get, queryParameters, parameter: searchOrderList);
-            var response = await ExecuteRequestAsync<GetOrdersResponse>(Utils.RateLimitType.Order_GetOrders);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.Orders, RestSharp.Method.Get, queryParameters, parameter: searchOrderList, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrdersResponse>(Utils.RateLimitType.Order_GetOrders, cancellationToken);
             var nextToken = response.Payload.NextToken;
             orderList = response.Payload.Orders;
             int PageCount = 1;
@@ -59,10 +60,12 @@ public async Task<OrderList> GetOrdersAsync(ParameterOrderList searchOrderList)
             {
                 while (!string.IsNullOrEmpty(nextToken))
                 {
-                    var orderPayload = GetGetOrdersByNextToken(nextToken, searchOrderList);
+                    var orderPayload = await GetGetOrdersByNextTokenAsync(nextToken, searchOrderList, cancellationToken);
                     orderList.AddRange(orderPayload.Orders);
                     nextToken = orderPayload.NextToken;
 
+                    cancellationToken.ThrowIfCancellationRequested();
+
                     if (searchOrderList.MaxNumberOfPages.HasValue)
                     {
                         PageCount++;
@@ -77,22 +80,22 @@ public async Task<OrderList> GetOrdersAsync(ParameterOrderList searchOrderList)
 
         public OrdersList GetGetOrdersByNextToken(string nextToken, ParameterOrderList searchOrderList) =>
             Task.Run(() => GetGetOrdersByNextTokenAsync(nextToken, searchOrderList)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrdersList> GetGetOrdersByNextTokenAsync(string nextToken, ParameterOrderList searchOrderList)
+        public async Task<OrdersList> GetGetOrdersByNextTokenAsync(string nextToken, ParameterOrderList searchOrderList, CancellationToken cancellationToken = default)
         {
             List<KeyValuePair<string, string>> queryParameters = new List<KeyValuePair<string, string>>();
             queryParameters.Add(new KeyValuePair<string, string>("NextToken", nextToken));
             queryParameters.Add(new KeyValuePair<string, string>("MarketplaceIds", string.Join(",", searchOrderList.MarketplaceIds)));
 
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.Orders, RestSharp.Method.Get, queryParameters, parameter: searchOrderList);
-            var response = await ExecuteRequestAsync<GetOrdersResponse>(Utils.RateLimitType.Order_GetOrders);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.Orders, RestSharp.Method.Get, queryParameters, parameter: searchOrderList, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrdersResponse>(Utils.RateLimitType.Order_GetOrders, cancellationToken);
             return response.Payload;
         }
 
         #endregion
 
         public Order GetOrder(ParameterGetOrder parameter) =>
             Task.Run(() => GetOrderAsync(parameter)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<Order> GetOrderAsync(ParameterGetOrder parameter)
+        public async Task<Order> GetOrderAsync(ParameterGetOrder parameter, CancellationToken cancellationToken = default)
         {
             if (parameter.IsNeedRestrictedDataToken && parameter.RestrictedDataTokenRequest == null)
             {
@@ -109,15 +112,15 @@ public async Task<Order> GetOrderAsync(ParameterGetOrder parameter)
                 parameter.RestrictedDataTokenRequest = createRDT;
             }
 
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.Order(parameter.OrderId), RestSharp.Method.Get, parameter: parameter);
-            var response = await ExecuteRequestAsync<GetOrderResponse>(Utils.RateLimitType.Order_GetOrder);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.Order(parameter.OrderId), RestSharp.Method.Get, parameter: parameter, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderResponse>(Utils.RateLimitType.Order_GetOrder, cancellationToken);
             if (response != null && response.Payload != null)
                 return response.Payload;
             else return null;
         }
         public OrderItemList GetOrderItems(string orderId, IParameterBasedPII parameterBasedPII = null) =>
             Task.Run(() => GetOrderItemsAsync(orderId, parameterBasedPII)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrderItemList> GetOrderItemsAsync(string orderId, IParameterBasedPII ParameterBasedPII = null)
+        public async Task<OrderItemList> GetOrderItemsAsync(string orderId, IParameterBasedPII ParameterBasedPII = null, CancellationToken cancellationToken = default)
         {
             var orderItemList = new OrderItemList();
 
@@ -135,56 +138,58 @@ public async Task<OrderItemList> GetOrderItemsAsync(string orderId, IParameterBa
                 ParameterBasedPII.RestrictedDataTokenRequest = createRDT;
             }
 
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItems(orderId), RestSharp.Method.Get, parameter: ParameterBasedPII);
-            var response = await ExecuteRequestAsync<GetOrderItemsResponse>(Utils.RateLimitType.Order_GetOrderItems);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItems(orderId), RestSharp.Method.Get, parameter: ParameterBasedPII, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderItemsResponse>(Utils.RateLimitType.Order_GetOrderItems, cancellationToken);
             var nextToken = response.Payload.NextToken;
             orderItemList.AddRange(response.Payload.OrderItems);
             while (!string.IsNullOrEmpty(nextToken))
             {
-                var orderItemPayload = GetOrderItemsNextToken(orderId, nextToken);
+                var orderItemPayload = await GetOrderItemsNextTokenAsync(orderId, nextToken, cancellationToken);
                 orderItemList.AddRange(orderItemPayload.OrderItems);
                 nextToken = orderItemPayload.NextToken;
+
+                cancellationToken.ThrowIfCancellationRequested();
             }
             return orderItemList;
         }
 
         public OrderItemsList GetOrderItemsNextToken(string orderId, string nextToken) =>
             Task.Run(() => GetOrderItemsNextTokenAsync(orderId, nextToken)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrderItemsList> GetOrderItemsNextTokenAsync(string orderId, string nextToken)
+        public async Task<OrderItemsList> GetOrderItemsNextTokenAsync(string orderId, string nextToken, CancellationToken cancellationToken = default)
         {
             List<KeyValuePair<string, string>> queryParameters = new List<KeyValuePair<string, string>>();
             queryParameters.Add(new KeyValuePair<string, string>("NextToken", nextToken));
 
 
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItems(orderId), RestSharp.Method.Get, queryParameters);
-            var response = await ExecuteRequestAsync<GetOrderItemsResponse>(Utils.RateLimitType.Order_GetOrderItems);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItems(orderId), RestSharp.Method.Get, queryParameters, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderItemsResponse>(Utils.RateLimitType.Order_GetOrderItems, cancellationToken);
             return response.Payload;
         }
 
         public OrderBuyerInfo GetOrderBuyerInfo(string orderId, List<KeyValuePair<string, string>> queryParameters = null) =>
             Task.Run(() => GetOrderBuyerInfoAsync(orderId, queryParameters)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrderBuyerInfo> GetOrderBuyerInfoAsync(string orderId, List<KeyValuePair<string, string>> queryParameters = null)
+        public async Task<OrderBuyerInfo> GetOrderBuyerInfoAsync(string orderId, List<KeyValuePair<string, string>> queryParameters = null, CancellationToken cancellationToken = default)
         {
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderBuyerInfo(orderId), RestSharp.Method.Get, queryParameters);
-            var response = await ExecuteRequestAsync<GetOrderBuyerInfoResponse>(Utils.RateLimitType.Order_GetOrderBuyerInfo);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderBuyerInfo(orderId), RestSharp.Method.Get, queryParameters, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderBuyerInfoResponse>(Utils.RateLimitType.Order_GetOrderBuyerInfo, cancellationToken);
             return response.Payload;
         }
 
         public OrderItemsBuyerInfoList GetOrderItemsBuyerInfo(string orderId) =>
             Task.Run(() => GetOrderItemsBuyerInfoAsync(orderId)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<OrderItemsBuyerInfoList> GetOrderItemsBuyerInfoAsync(string orderId)
+        public async Task<OrderItemsBuyerInfoList> GetOrderItemsBuyerInfoAsync(string orderId, CancellationToken cancellationToken = default)
         {
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItemsBuyerInfo(orderId), RestSharp.Method.Get);
-            var response = await ExecuteRequestAsync<GetOrderItemsBuyerInfoResponse>(Utils.RateLimitType.Order_GetOrderItemsBuyerInfo);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderItemsBuyerInfo(orderId), RestSharp.Method.Get, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderItemsBuyerInfoResponse>(Utils.RateLimitType.Order_GetOrderItemsBuyerInfo, cancellationToken);
             return response.Payload;
         }
 
         public Address GetOrderAddress(string orderId) =>
             Task.Run(() => GetOrderAddressAsync(orderId)).ConfigureAwait(false).GetAwaiter().GetResult();
-        public async Task<Address> GetOrderAddressAsync(string orderId)
+        public async Task<Address> GetOrderAddressAsync(string orderId, CancellationToken cancellationToken = default)
         {
-            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderShipmentInfo(orderId), RestSharp.Method.Get);
-            var response = await ExecuteRequestAsync<GetOrderAddressResponse>(Utils.RateLimitType.Order_GetOrderAddress);
+            await CreateAuthorizedRequestAsync(OrdersApiUrls.OrderShipmentInfo(orderId), RestSharp.Method.Get, cancellationToken: cancellationToken);
+            var response = await ExecuteRequestAsync<GetOrderAddressResponse>(Utils.RateLimitType.Order_GetOrderAddress, cancellationToken);
             return response.Payload.ShippingAddress;
         }
     }