public virtual async Task CancelEditOrderAsync(Overture.ServiceModel.Orders.Order order) { if (order == null) { throw new ArgumentNullException(nameof(order)); } try { await DeleteCartDraft(order).ConfigureAwait(false); } catch (ComposerException ex) { var ownedBySomeoneElseError = ex.Errors?.FirstOrDefault(e => e.ErrorCode == Constants.ErrorCodes.IsOwnedBySomeoneElse); if (ownedBySomeoneElseError != null) { await ChangeOwnership(order).ConfigureAwait(false); await DeleteCartDraft(order).ConfigureAwait(false); } else { throw; } } ClearEditMode(); }
public virtual async Task <bool> CanEdit(Overture.ServiceModel.Orders.Order order) { if (!ComposerContext.IsAuthenticated || !ValidateOrder(order)) { return(false); } var orderSettings = await OrderRepository.GetOrderSettings(ComposerContext.Scope).ConfigureAwait(false); var shipmentStatuses = order.Cart.GetAllShipmentStatuses(); if (!shipmentStatuses.Any() || orderSettings == null || string.IsNullOrWhiteSpace(orderSettings.EditableShipmentStates)) { return(false); } var isOrderEditable = shipmentStatuses .All(item => orderSettings .EditableShipmentStates .ToLower() .Split('|') .Contains(item.ToLower())); return(isOrderEditable); }
protected CreateOrderDetailViewModelParam CreateOrderDetailViewModelParam(Overture.ServiceModel.Orders.Order order) { return(new CreateOrderDetailViewModelParam { CultureInfo = new CultureInfo("en-US"), OrderStatuses = new Dictionary <string, string> { { "InProgress", "In Progress" }, { "Canceled", "Canceled" } }, CountryCode = GetRandom.String(32), BaseUrl = GetRandom.String(32), Order = order, ProductImageInfo = new ProductImageInfo { ImageUrls = new List <ProductMainImage>() }, ShipmentsNotes = new Dictionary <Guid, List <string> >(), OrderChanges = new List <OrderHistoryItem>(), ShipmentStatuses = new Dictionary <string, string> { { "InProgress", "In Progress" }, { "Canceled", "Canceled" } } }); }
public async Task WHEN_valid_request_SHOULD_succeed() { //Arrange var order = new Overture.ServiceModel.Orders.Order { OrderNumber = GetRandom.String(10) }; _container.GetMock <IOvertureClient>() .Setup(r => r.SendAsync(It.IsAny <GetOrderByNumberRequest>())) .ReturnsAsync(order); var orderRepository = _container.CreateInstance <OrderRepository>(); //Act var param = new GetCustomerOrderParam { CustomerId = Guid.NewGuid(), OrderNumber = GetRandom.String(10), Scope = GetRandom.String(32), }; var result = await orderRepository.GetOrderAsync(param).ConfigureAwait(false); //Assert result.Should().NotBeNull(); result.OrderNumber.Should().BeEquivalentTo(order.OrderNumber); }
public void SetUp() { //Arrange _container = new AutoMocker(); _container.Use(ViewModelMapperFactory.Create()); _container.Use(CartViewModelFactoryMock.Create()); var cartRepoMock = _container.GetMock <ICartRepository>(); cartRepoMock.Setup(repo => repo.CompleteCheckoutAsync(It.IsNotNull <CompleteCheckoutParam>())) .Returns((CompleteCheckoutParam p) => { var order = new Overture.ServiceModel.Orders.Order { Cart = new ProcessedCart() { Customer = new CustomerSummary() { Email = GetRandom.Email() }, Shipments = new System.Collections.Generic.List <Shipment>() { new Shipment { Id = GetRandom.Guid(), LineItems = new System.Collections.Generic.List <LineItem>() { new LineItem { Id = GetRandom.Guid(), Sku = GetRandom.String(10), CatalogId = GetRandom.String(10), PlacedPrice = GetRandom.Decimal(), PlacedQuantity = GetRandom.Int(), Status = GetRandom.String(5), Total = GetRandom.Decimal(), KvaValues = new Overture.ServiceModel.PropertyBag(), KvaDisplayValues = new Overture.ServiceModel.PropertyBag(), ProductSummary = new CartProductSummary { Brand = null, DisplayName = GetRandom.String(10), PrimaryParentCategoryId = GetRandom.String(10) } } }, FulfillmentMethod = new FulfillmentMethod { FulfillmentMethodType = FulfillmentMethodType.PickUp } } } }, OrderNumber = GetRandom.String(12) }; return(Task.FromResult(order)); }); }
public virtual async Task <CancellationStatus> GetCancellationStatus(Overture.ServiceModel.Orders.Order order) { if (!ComposerContext.IsAuthenticated || !ValidateOrder(order)) { return(new CancellationStatus()); } var orderFulfillmentState = await OrderRepository.GetOrderFulfillmentStateAsync(new GetOrderFulfillmentStateParam { OrderId = order.Id, ScopeId = order.ScopeId }).ConfigureAwait(false); if (orderFulfillmentState == null || OrderHistoryConfiguration.CompletedOrderStatuses.Contains(orderFulfillmentState.Status)) { return(new CancellationStatus()); } switch (orderFulfillmentState.IsCancelable) { case true when !orderFulfillmentState.IsProcessing && orderFulfillmentState.ShipmentFulfillmentStates.All(item => item.AllowedStatusChanges?.Contains(Constants.OrderStatus.Canceled) ?? false): return(new CancellationStatus() { CanCancel = true, CancellationPending = false }); case false when orderFulfillmentState.IsProcessing && HasCancellationMessage(orderFulfillmentState): return(new CancellationStatus() { CanCancel = false, CancellationPending = true }); default: return(new CancellationStatus()); } }
private Task <Overture.ServiceModel.Orders.Order> SaveEditedOrder(Overture.ServiceModel.Orders.Order order) { return(OrderRepository.SubmitCartOrderDraftAsync(new SubmitCartOrderDraftParam { CustomerId = Guid.Parse(order.CustomerId), Scope = order.ScopeId, OrderId = Guid.Parse(order.Id) })); }
public virtual async Task <ProcessedCart> StartEditOrderModeAsync(Overture.ServiceModel.Orders.Order order) { if (order == null) { throw new ArgumentNullException(nameof(order)); } Guid orderId = Guid.Parse(order.Id); ProcessedCart draftCart = null; var createOrderDraftParam = new CreateCartOrderDraftParam { CultureInfo = ComposerContext.CultureInfo, OrderId = orderId, Scope = order.ScopeId, CustomerId = Guid.Parse(order.CustomerId) }; try { draftCart = await OrderRepository.CreateCartOrderDraft(createOrderDraftParam).ConfigureAwait(false); } catch (ComposerException ex) { var ownedBySomeoneElseError = ex.Errors?.FirstOrDefault(e => e.ErrorCode == Constants.ErrorCodes.IsOwnedBySomeoneElse); var ownedByRequestedUserError = ex.Errors?.FirstOrDefault(e => e.ErrorCode == Constants.ErrorCodes.IsOwnedByRequestedUser); if (ownedBySomeoneElseError != null) { draftCart = await ChangeOwnership(order).ConfigureAwait(false); } else if (ownedByRequestedUserError != null) { draftCart = await CartRepository.GetCartAsync(new GetCartParam { Scope = order.ScopeId, CartName = order.Id.GetDraftCartName(), CartType = CartConfiguration.OrderDraftCartType, CustomerId = Guid.Parse(order.CustomerId), CultureInfo = ComposerContext.CultureInfo }).ConfigureAwait(false); } else { throw; } } if (draftCart == null) { throw new InvalidOperationException("Expected draft cart, but received null."); } //Set Edit Mode ComposerContext.EditingCartName = draftCart.Name; return(draftCart); }
private bool ValidateOrder(Overture.ServiceModel.Orders.Order order) { return(order?.Cart?.Shipments != null && !string.IsNullOrWhiteSpace(order.OrderStatus) && Guid.TryParse(order.CustomerId, out Guid orderCustomerId) && orderCustomerId != Guid.Empty && orderCustomerId == ComposerContext.CustomerId && !OrderHistoryConfiguration.CompletedOrderStatuses.Contains(order.OrderStatus)); }
private Task DeleteCartDraft(Overture.ServiceModel.Orders.Order order) { return(OrderRepository.DeleteCartOrderDraft(new DeleteCartOrderDraftParam { CustomerId = Guid.Parse(order.CustomerId), Scope = order.ScopeId, OrderId = Guid.Parse(order.Id) })); }
private Task <ProcessedCart> ChangeOwnership(Overture.ServiceModel.Orders.Order order) { return(OrderRepository.ChangeOwnership(new ChangeOrderDraftOwnershipParam() { CultureName = ComposerContext.CultureInfo.Name, RevertPendingChanges = true, OrderId = Guid.Parse(order.Id), Scope = order.ScopeId, CustomerId = Guid.Parse(order.CustomerId) })); }
protected virtual IEnumerable <Shipment> GetActiveShipments(Overture.ServiceModel.Orders.Order order) { if (order.OrderStatus.Equals(_orderStatusCanceled)) { return(order.Cart.Shipments); } else { return(order.Cart.GetActiveShipments()); } }
protected virtual List <CouponViewModel> MapCoupons(Overture.ServiceModel.Orders.Order order, CultureInfo cultureInfo) { if (order?.Cart == null) { return(new List <CouponViewModel>()); } var couponsViewModel = CartViewModelFactory.GetCouponsViewModel(order.Cart, cultureInfo, false); return(couponsViewModel != null ? couponsViewModel.ApplicableCoupons : new List <CouponViewModel>()); }
public async Task CancelOrder(Overture.ServiceModel.Orders.Order order) { if (order == null) { throw new ArgumentNullException(nameof(order)); } var isOrderCancelable = (await GetCancellationStatus(order).ConfigureAwait(false)).CanCancel; if (!isOrderCancelable) { throw new InvalidOperationException($"Order {order.Id} can't be cancelled"); } var shipmentsTasks = order.Cart.Shipments.Select(shipment => OrderRepository.ChangeShipmentStatusAsync(new ChangeShipmentStatusParam { OrderId = Guid.Parse(order.Id), ScopeId = order.ScopeId, ShipmentId = shipment.Id, Reason = Constants.DefaultOrderCancellationReason, RequestedStatus = Constants.OrderStatus.Canceled })); await Task.WhenAll(shipmentsTasks).ConfigureAwait(false); var propertyBagShipment = new Dictionary <string, object>(); propertyBagShipment.Add(Constants.RequestedOrderCancellationDatePropertyBagKey, DateTime.UtcNow); var shipmentFulfillmentMessagesTasks = order.Cart.Shipments .Select(shipment => OrderRepository.AddShipmentFulfillmentMessagesAsync(new AddShipmentFulfillmentMessagesParam { OrderId = Guid.Parse(order.Id), ScopeId = order.ScopeId, ShipmentId = shipment.Id, ExecutionMessages = new List <ExecutionMessage>() { new ExecutionMessage() { Severity = ExecutionMessageSeverity.Info, MessageId = order.Id, PropertyBag = new PropertyBag(propertyBagShipment) } } })); await Task.WhenAll(shipmentFulfillmentMessagesTasks).ConfigureAwait(false); }
protected virtual async Task <OrderDetailViewModel> BuildOrderDetailViewModelAsync( Overture.ServiceModel.Orders.Order order, GetOrderParam getOrderParam) { var shipmentsNotes = await GetShipmentsNotes(order.Cart.Shipments, getOrderParam.Scope).ConfigureAwait(false); var orderChanges = await OrderRepository.GetOrderChangesAsync(new GetOrderChangesParam { OrderNumber = getOrderParam.OrderNumber, Scope = getOrderParam.Scope }).ConfigureAwait(false); var orderStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam { CultureInfo = getOrderParam.CultureInfo, LookupType = LookupType.Order, LookupName = "OrderStatus", }).ConfigureAwait(false); var shipmentStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam { CultureInfo = getOrderParam.CultureInfo, LookupType = LookupType.Order, LookupName = "ShipmentStatus", }).ConfigureAwait(false); var productImageInfo = new ProductImageInfo { ImageUrls = await ImageService.GetImageUrlsAsync(order.Cart.GetLineItems()).ConfigureAwait(false) }; var viewModel = OrderDetailsViewModelFactory.CreateViewModel(new CreateOrderDetailViewModelParam { Order = order, OrderChanges = orderChanges, OrderStatuses = orderStatuses, ShipmentStatuses = shipmentStatuses, CultureInfo = getOrderParam.CultureInfo, CountryCode = getOrderParam.CountryCode, ProductImageInfo = productImageInfo, BaseUrl = getOrderParam.BaseUrl, ShipmentsNotes = shipmentsNotes }); return(viewModel); }
protected virtual async Task <OrderDetailViewModel> BuildOrderDetailViewModelAsync( Overture.ServiceModel.Orders.Order order, GetOrderParam getOrderParam) { Helper.LineItemsHelper.PrepareGiftLineItems(order.Cart); var shipmentsNotes = await GetShipmentsNotes(order.Cart.Shipments, getOrderParam.Scope).ConfigureAwait(false); var orderChanges = await OrderRepository.GetOrderChangesAsync(new GetOrderChangesParam { OrderNumber = getOrderParam.OrderNumber, Scope = getOrderParam.Scope }).ConfigureAwait(false); var orderCartDrafts = await GetOrderCartDrafts(getOrderParam.Scope, Guid.Parse(order.CustomerId), getOrderParam.CultureInfo).ConfigureAwait(false); var orderStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam { CultureInfo = getOrderParam.CultureInfo, LookupType = LookupType.Order, LookupName = "OrderStatus", }).ConfigureAwait(false); var shipmentStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam { CultureInfo = getOrderParam.CultureInfo, LookupType = LookupType.Order, LookupName = "ShipmentStatus", }).ConfigureAwait(false); var productImageInfo = new ProductImageInfo { ImageUrls = await ImageService.GetImageUrlsAsync(order.Cart.GetLineItems()).ConfigureAwait(false) }; var viewModel = OrderDetailsViewModelFactory.CreateViewModel(new CreateOrderDetailViewModelParam { Order = order, OrderChanges = orderChanges, OrderStatuses = orderStatuses, ShipmentStatuses = shipmentStatuses, CultureInfo = getOrderParam.CultureInfo, CountryCode = getOrderParam.CountryCode, ProductImageInfo = productImageInfo, BaseUrl = getOrderParam.BaseUrl, ShipmentsNotes = shipmentsNotes, OrderCartDrafts = orderCartDrafts }); viewModel.OrderInfos.IsOrderEditable = await EditingOrderProvider.CanEdit(order).ConfigureAwait(false); viewModel.OrderInfos.IsBeingEdited = EditingOrderProvider.IsBeingEdited(order); var orderCancellationStatus = await EditingOrderProvider.GetCancellationStatus(order).ConfigureAwait(false); viewModel.OrderInfos.IsOrderCancelable = orderCancellationStatus.CanCancel; viewModel.OrderInfos.IsOrderPendingCancellation = orderCancellationStatus.CancellationPending; if (order.Cart.PropertyBag.TryGetValue("PickedItems", out var pickedItemsObject)) { var pickedItemsList = ComposerJsonSerializer.Deserialize <List <PickedItemViewModel> >(pickedItemsObject.ToString()); var shipment = viewModel.Shipments.First(); shipment.LineItems = await ProcessPickedLineItemsAsync(pickedItemsList, shipment.LineItems, getOrderParam.CultureInfo).ConfigureAwait(false); } ; return(viewModel); }
protected virtual List <CompleteCheckoutLineItemViewModel> MapCompleteCheckoutLineItems(Overture.ServiceModel.Orders.Order order, CultureInfo cultureInfo) { var lineItems = order.Cart.GetLineItems().Select(li => { var viewModel = ViewModelMapper.MapTo <CompleteCheckoutLineItemViewModel>(li, cultureInfo); var brandProperty = li.ProductSummary.Brand ?? string.Empty; var brand = string.IsNullOrWhiteSpace(brandProperty) ? string.Empty : LookupService.GetLookupDisplayNameAsync(new GetLookupDisplayNameParam { Delimiter = ", ", LookupName = "Brand", LookupType = LookupType.Product, Value = li.ProductSummary.Brand, CultureInfo = cultureInfo }).Result; viewModel.Name = li.ProductSummary.DisplayName; viewModel.BrandId = brandProperty; viewModel.Brand = brand; viewModel.CategoryId = li.ProductSummary.PrimaryParentCategoryId; viewModel.KeyVariantAttributesList = LineItemViewModelFactory.GetKeyVariantAttributes(new GetKeyVariantAttributesParam { KvaValues = li.KvaValues, KvaDisplayValues = li.KvaDisplayValues }).ToList(); return(viewModel); }); return(lineItems.ToList()); }
protected virtual CompleteCheckoutViewModel MapOrderToCompleteCheckoutViewModel(Overture.ServiceModel.Orders.Order order, CultureInfo cultureInfo) { if (order == null) { return(null); } var completeCheckoutViewModel = new CompleteCheckoutViewModel { OrderNumber = order.OrderNumber, CustomerEmail = order.Cart.Customer.Email, Affiliation = order.Cart.OrderLocation?.Name, Revenu = order.Cart.Total, Tax = order.Cart.TaxTotal, Shipping = order.Cart.FulfillmentCost, ShippingOptions = order.Cart.Shipments?.FirstOrDefault()?.FulfillmentMethod.FulfillmentMethodType.ToString().ToLowerInvariant(), BillingCurrency = order.Cart.BillingCurrency, Coupons = MapCoupons(order, cultureInfo), LineItems = MapCompleteCheckoutLineItems(order, cultureInfo) }; return(completeCheckoutViewModel); }
public virtual bool IsBeingEdited(Overture.ServiceModel.Orders.Order order) { return(order != null && IsEditMode() & ComposerContext.EditingCartName == order.Id.GetDraftCartName()); }
protected virtual async Task <CompleteCheckoutViewModel> MapOrderToCompleteCheckoutViewModel(Overture.ServiceModel.Orders.Order order, CompleteCheckoutParam param) { if (order == null) { return(null); } var orderStatuses = await LookupService.GetLookupDisplayNamesAsync(new GetLookupDisplayNamesParam { CultureInfo = param.CultureInfo, LookupType = LookupType.Order, LookupName = "OrderStatus", }).ConfigureAwait(false); var productImageInfo = new ProductImageInfo { ImageUrls = await ImageService.GetImageUrlsAsync(order.Cart.GetLineItems()).ConfigureAwait(false) }; var getVmOrderParam = new CreateOrderDetailViewModelParam { Order = order, CultureInfo = param.CultureInfo, OrderStatuses = orderStatuses, OrderDetailBaseUrl = OrderUrlProvider.GetOrderDetailsBaseUrl(param.CultureInfo), BaseUrl = param.BaseUrl, ProductImageInfo = productImageInfo, }; var orderViewModel = OrderDetailsViewModelFactory.CreateLightViewModel(getVmOrderParam); var completeCheckoutViewModel = new CompleteCheckoutViewModel { OrderNumber = order.OrderNumber, Order = orderViewModel, CustomerEmail = order.Cart.Customer.Email, CustomerFirstName = order.Cart.Customer.FirstName, CustomerLastName = order.Cart.Customer.LastName, Affiliation = order.Cart.OrderLocation?.Name, Revenu = order.Cart.Total, Tax = order.Cart.TaxTotal, Shipping = order.Cart.FulfillmentCost, ShippingOptions = order.Cart.Shipments?.FirstOrDefault()?.FulfillmentMethod.FulfillmentMethodType.ToString().ToLowerInvariant(), BillingCurrency = order.Cart.BillingCurrency, Coupons = MapCoupons(order, param.CultureInfo), LineItems = orderViewModel?.Shipments.FirstOrDefault()?.LineItems }; return(completeCheckoutViewModel); }
public virtual async Task <Overture.ServiceModel.Orders.Order> SaveEditedOrderAsync(Overture.ServiceModel.Orders.Order order) { if (order == null) { throw new ArgumentNullException(nameof(order)); } var isEditable = await CanEdit(order).ConfigureAwait(false); if (!isEditable) { await CancelEditOrderAsync(order).ConfigureAwait(false); throw new InvalidOperationException($"Cannot update edited order #${order.OrderNumber} as it can't be edited now."); } Overture.ServiceModel.Orders.Order updatedOrder; try { updatedOrder = await SaveEditedOrder(order).ConfigureAwait(false); } catch (ComposerException ex) { var ownedBySomeoneElseError = ex.Errors?.FirstOrDefault(e => e.ErrorCode == Constants.ErrorCodes.IsOwnedBySomeoneElse); if (ownedBySomeoneElseError != null) { await ChangeOwnership(order).ConfigureAwait(false); updatedOrder = await SaveEditedOrder(order).ConfigureAwait(false); } else { throw; } } ClearEditMode(); return(updatedOrder); }