protected virtual async Task <Dictionary <Guid, TrackingInfoViewModel> > GetShipmentsTrackingInfoViewModels(
OrderQueryResult orderQueryResult,
GetCustomerOrdersParam param)
{
var shipmentsTrackingInfos = new Dictionary <Guid, TrackingInfoViewModel>();
var getOrderTasks = orderQueryResult.Results.Select(order => OrderRepository.GetOrderAsync(new GetCustomerOrderParam
{
OrderNumber = order.OrderNumber,
Scope = param.Scope
}));
var orders = await Task.WhenAll(getOrderTasks).ConfigureAwait(false);
foreach (var order in orders)
{
foreach (var shipment in order.Cart.Shipments)
{
var shippingTrackingProvider = ShippingTrackingProviderFactory.ResolveProvider(shipment.FulfillmentMethod.Name);
var trackingInfoVm = shippingTrackingProvider.GetTrackingInfoViewModel(shipment, param.CultureInfo);
shipmentsTrackingInfos.Add(shipment.Id, trackingInfoVm);
}
}
return(shipmentsTrackingInfos);
}
private GetCustomerOrdersParam BuildGetCustomerOrdersParam()
{
var param = new GetCustomerOrdersParam
{
Scope = GetRandom.String(32),
CustomerId = Guid.NewGuid(),
CultureInfo = new CultureInfo("en-US"),
OrderTense = OrderTense.CurrentOrders,
Page = 1
};
return(param);
}
public virtual FindOrdersRequest Create(GetCustomerOrdersParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
if (param.CultureInfo == null)
{
throw new ArgumentException("param.CultureInfo");
}
if (param.CustomerId == Guid.Empty)
{
throw new ArgumentException("param.CustomerId");
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException("param.Scope");
}
var request = new FindOrdersRequest
{
CustomerId = param.CustomerId,
CultureName = param.CultureInfo.Name,
ScopeId = param.Scope,
Query = new Query
{
StartingIndex = (param.Page - 1) * OrderHistoryConfiguration.MaxItemsPerPage,
MaximumItems = OrderHistoryConfiguration.MaxItemsPerPage,
Sortings = new List <QuerySorting>
{
new QuerySorting
{
Direction = SortDirection.Descending,
PropertyName = "Created"
}
}
},
};
request.Query.Filter = new FilterGroup
{
Filters = new List <Filter>
{
BuildOrderStatusFilter(param.OrderTense)
}
};
return(request);
}
protected virtual Dictionary <Guid, TrackingInfoViewModel> GetShipmentsTrackingInfoViewModels(
List <Overture.ServiceModel.Orders.Order> orders,
GetCustomerOrdersParam param)
{
var shipmentsTrackingInfos = new Dictionary <Guid, TrackingInfoViewModel>();
foreach (var order in orders)
{
foreach (var shipment in order.Cart.Shipments)
{
var shippingTrackingProvider = ShippingTrackingProviderFactory.ResolveProvider(shipment.FulfillmentMethod.Name);
var trackingInfoVm = shippingTrackingProvider.GetTrackingInfoViewModel(shipment, param.CultureInfo);
shipmentsTrackingInfos.Add(shipment.Id, trackingInfoVm);
}
}
return(shipmentsTrackingInfos);
}
public void WHEN_OrderTense_equal_PastOrders_SHOULD_return_right_request()
{
//Arrange
var factory = new FindOrdersRequestFactory();
//Act
var param = new GetCustomerOrdersParam
{
CustomerId = Guid.NewGuid(),
CultureInfo = new CultureInfo("en-US"),
Scope = GetRandom.String(32),
Page = 2,
OrderTense = OrderTense.PastOrders
};
var request = factory.Create(param);
//Assert
ValidateRequest(request, param, 10, false);
}
private void ValidateRequest(FindOrdersRequest request, GetCustomerOrdersParam param,
int expectedStartingIndex, bool expectedNot)
{
request.Should().NotBeNull();
request.CustomerId.ShouldBeEquivalentTo(param.CustomerId);
request.CultureName.ShouldBeEquivalentTo(param.CultureInfo.Name);
request.ScopeId.ShouldBeEquivalentTo(param.Scope);
request.Query.Should().NotBeNull();
var query = request.Query;
query.StartingIndex.ShouldBeEquivalentTo(expectedStartingIndex);
query.MaximumItems.ShouldBeEquivalentTo(OrderHistoryConfiguration.MaxItemsPerPage);
query.Filter.Should().NotBeNull();
query.Filter.Filters.Should().NotBeNull();
var filter = query.Filter.Filters.FirstOrDefault();
filter.Should().NotBeNull();
filter.Member.ShouldBeEquivalentTo("OrderStatus");
filter.Operator.ShouldBeEquivalentTo(Operator.In);
filter.Not.ShouldBeEquivalentTo(expectedNot);
}
/// <summary>
/// Gets the customer orders asynchronous.
/// </summary>
/// <param name="param">The get customer orders parameter.</param>
/// <returns></returns>
public virtual async Task <OrderQueryResult> GetCustomerOrdersAsync(GetCustomerOrdersParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.CustomerId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CustomerId)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
var request = FindOrdersRequestFactory.Create(param);
var result = await OvertureClient.SendAsync(request).ConfigureAwait(false);
return(result?.TotalCount > 0 ? result : null);
}
/// <summary>
/// Gets the OrderHistory ViewModel, containing a list of Orders.
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public virtual async Task <OrderHistoryViewModel> GetOrderHistoryViewModelAsync(GetCustomerOrdersParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
if (param.CultureInfo == null)
{
throw new ArgumentException("param.CultureInfo");
}
if (param.CustomerId == null)
{
throw new ArgumentException("param.CustomerId");
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException("param.Scope");
}
var orderDetailBaseUrl = OrderUrlProvider.GetOrderDetailsBaseUrl(param.CultureInfo);
var orderStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam
{
CultureInfo = param.CultureInfo,
LookupType = LookupType.Order,
LookupName = "OrderStatus",
}).ConfigureAwait(false);
var orderQueryResult = await OrderRepository.GetCustomerOrdersAsync(param).ConfigureAwait(false);
var shipmentsTrackingInfos = new Dictionary <Guid, TrackingInfoViewModel>();
if (orderQueryResult != null && orderQueryResult.Results != null && param.OrderTense == OrderTense.CurrentOrders)
{
shipmentsTrackingInfos = await GetShipmentsTrackingInfoViewModels(orderQueryResult, param).ConfigureAwait(false);
}
var getOrderHistoryViewModelParam = new GetOrderHistoryViewModelParam
{
CultureInfo = param.CultureInfo,
OrderResult = orderQueryResult,
OrderStatuses = orderStatuses,
Page = param.Page,
OrderDetailBaseUrl = orderDetailBaseUrl,
ShipmentsTrackingInfos = shipmentsTrackingInfos
};
var viewModel = OrderHistoryViewModelFactory.CreateViewModel(getOrderHistoryViewModelParam);
return(viewModel);
}
protected virtual async Task <List <Overture.ServiceModel.Orders.Order> > GetOrders(OrderQueryResult orderQueryResult,
GetCustomerOrdersParam param)
{
var getOrderTasks = orderQueryResult.Results.Select(order => OrderRepository.GetOrderAsync(new GetCustomerOrderParam
{
OrderNumber = order.OrderNumber,
Scope = param.Scope
}));
var orders = await Task.WhenAll(getOrderTasks).ConfigureAwait(false);
return(orders.ToList());
}
/// <summary>
/// Gets the OrderHistory ViewModel, containing a list of Orders.
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public virtual async Task <OrderHistoryViewModel> GetOrderHistoryViewModelAsync(GetCustomerOrdersParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.CustomerId == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CustomerId)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
var orderQueryResult = await OrderRepository.GetCustomerOrdersAsync(param).ConfigureAwait(false);
if (orderQueryResult == null)
{
return(null);
}
var orderDetailBaseUrl = OrderUrlProvider.GetOrderDetailsBaseUrl(param.CultureInfo);
var orderStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam
{
CultureInfo = param.CultureInfo,
LookupType = LookupType.Order,
LookupName = "OrderStatus",
}).ConfigureAwait(false);
var shipmentsTrackingInfos = new Dictionary <Guid, TrackingInfoViewModel>();
var ordersDetails = new List <Overture.ServiceModel.Orders.Order>();
var orderCartDrafts = new List <CartSummary>();
var orderEditingInfos = new Dictionary <Guid, bool>();
var orderCancellationInfos = new Dictionary <Guid, CancellationStatus>();
if (orderQueryResult.Results != null && param.OrderTense == OrderTense.CurrentOrders)
{
ordersDetails = await GetOrders(orderQueryResult, param).ConfigureAwait(false);
orderCartDrafts = await GetOrderCartDrafts(param.Scope, param.CustomerId, param.CultureInfo).ConfigureAwait(false);
orderEditingInfos = await GetOrderEditingInfos(ordersDetails).ConfigureAwait(false);
orderCancellationInfos = await GetCancellationStatus(ordersDetails).ConfigureAwait(false);
shipmentsTrackingInfos = GetShipmentsTrackingInfoViewModels(ordersDetails, param);
}
Guid.TryParse(EditingOrderProvider.GetCurrentEditingCartName(), out Guid currentlyEditingOrder);
var getOrderHistoryViewModelParam = new GetOrderHistoryViewModelParam
{
CultureInfo = param.CultureInfo,
OrderResult = orderQueryResult,
OrderCartDrafts = orderCartDrafts,
OrderStatuses = orderStatuses,
Page = param.Page,
OrderDetailBaseUrl = orderDetailBaseUrl,
ShipmentsTrackingInfos = shipmentsTrackingInfos,
OrderEditingInfos = orderEditingInfos,
Orders = ordersDetails,
OrderCancellationStatusInfos = orderCancellationInfos,
CurrentlyEditedOrderId = currentlyEditingOrder
};
var viewModel = OrderHistoryViewModelFactory.CreateViewModel(getOrderHistoryViewModelParam);
return(viewModel);
}
