public virtual async Task <IHttpActionResult> UpdateCart(UpdateCartRequest updateCartRequest)
{
if (updateCartRequest == null)
{
return(BadRequest("updateCartRequest is required"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getCartParam = new GetCartParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
CartName = CartConfiguration.ShoppingCartName,
BaseUrl = RequestUtils.GetBaseUrl(Request).ToString(),
};
var updateCheckoutCartParam = new UpdateCheckoutCartParam
{
GetCartParam = getCartParam,
CurrentStep = updateCartRequest.CurrentStep.GetValueOrDefault(),
IsGuest = ComposerContext.IsGuest,
UpdateValues = updateCartRequest.UpdatedCart
};
var updateCartResultViewModel = await CheckoutService.UpdateCheckoutCartAsync(updateCheckoutCartParam);
return(Ok(updateCartResultViewModel));
}
public ManagerResponse <CartResult, Cart> UpdateCart(string shopName, Cart currentCart, CartBase cartUpdate)
{
var request = new UpdateCartRequest(currentCart, cartUpdate);
var serviceProviderResult = this.cartServiceProvider.UpdateCart(request);
return(new ManagerResponse <CartResult, Cart>(serviceProviderResult, serviceProviderResult.Cart));
}
public async Task <IActionResult> SyncCartAsync(CartItemModel[] items)
{
var userId = User.GetSubjectId();
var request = new UpdateCartRequest(userId, items);
return(await _mediator.Send(request));
}
public Cart AddCartItem(Cart cart, InventoryItemResponse item, UpdateCartRequest request)
{
var cartItem = cart.Items.FirstOrDefault(i => i.ItemId == item.Id);
var alreadyIn = false;
if (cartItem != null)
{
alreadyIn = true;
cartItem.Price = item.Price;
cartItem.Count = request.Count;
}
else
{
cartItem = new CartItem(
itemId: item.Id,
name: item.Name,
price: item.Price,
count: request.Count
);
}
if (cartItem.Count > item.Stock)
{
throw new StockIsNotEnoughException(item.Id, item.Stock, request.Count);
}
if (!alreadyIn)
{
cart.Items.Add(cartItem);
}
return(cart);
}
public virtual async Task <IHttpActionResult> UpdateCart(UpdateCartRequest updateCartRequest)
{
if (updateCartRequest == null)
{
return(BadRequest("updateCartRequest is required"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getCartUrlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
var checkoutStepInfos = CartUrlProvider.GetCheckoutStepPageInfos(getCartUrlParam);
var nextStepUrl = CartUrlProvider.GetCheckoutStepUrl(new GetCheckoutStepUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
StepNumber = updateCartRequest.CurrentStep.GetValueOrDefault() + 1
});
var getCartParam = new GetCartParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
CartName = CartConfiguration.ShoppingCartName,
BaseUrl = RequestUtils.GetBaseUrl(Request).ToString(),
};
var updateCheckoutCartParam = new UpdateCheckoutCartParam
{
GetCartParam = getCartParam,
CurrentStep = updateCartRequest.CurrentStep.GetValueOrDefault(),
IsGuest = ComposerContext.IsGuest,
UpdateValues = updateCartRequest.UpdatedCart
};
var homepageUrl = GetHomepageUrl();
var updateCartResultViewModel = await CheckoutService.UpdateCheckoutCartAsync(updateCheckoutCartParam);
SetHomepageUrl(updateCartResultViewModel.Cart, homepageUrl);
SetEditCartUrl(updateCartResultViewModel.Cart);
if (updateCartResultViewModel.Cart.OrderSummary != null)
{
updateCartResultViewModel.Cart.OrderSummary.CheckoutStepUrls = checkoutStepInfos.Values.Select(x => x.Url).ToList();
}
if (!updateCartResultViewModel.HasErrors)
{
updateCartResultViewModel.NextStepUrl = nextStepUrl;
}
return(Ok(updateCartResultViewModel));
}
public ManagerResponse <CartResult, CommerceCart> UpdateCart(CommerceCart cart, CommerceCart cartChanges)
{
Assert.ArgumentNotNull(cart, nameof(cart));
Assert.ArgumentNotNull(cartChanges, nameof(cartChanges));
var updateCartRequest = new UpdateCartRequest(cart, cartChanges);
var result = CartServiceProvider.UpdateCart(updateCartRequest);
result.WriteToSitecoreLog();
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
public async Task <bool> UpdateCartAsync(UpdateCartRequest updateCartRequest, CancellationToken cancellationToken)
{
var savedToken = await _localStorage.GetItemAsync <string>("authToken");
if (!string.IsNullOrWhiteSpace(savedToken))
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", savedToken);
}
var response = await _httpClient.PostAsync(HttpMethod.Post, "v1/Cart/UpdateCartQuantity", updateCartRequest.AsJson(), cancellationToken);
return(response.IsSuccessStatusCode);
}
private Cart EnsureCorrectCartUserId(Cart cart)
{
if (cart.UserId != this.UserId)
{
Cart changes = new Cart {
UserId = this.UserId
};
var updateCartRequest = new UpdateCartRequest(cart, changes);
var result = this._cartServiceProvider.UpdateCart(updateCartRequest);
if (result != null && result.Success)
{
return(result.Cart);
}
}
return(cart);
}
public async Task <IActionResult> Update(Guid id, [FromBody] UpdateCartRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
var response = await _cartItemService.Update(id, request);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Updates the cart.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="cart">The cart.</param>
/// <param name="cartChanges">The cart changes.</param>
/// <returns>The manager response with the updated cart.</returns>
public virtual ManagerResponse <CartResult, CommerceCart> UpdateCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] CommerceCart cart, [NotNull] CommerceCart cartChanges)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNull(cart, "cart");
Assert.ArgumentNotNull(cartChanges, "cartChanges");
var updateCartRequest = new UpdateCartRequest(cart, cartChanges);
var result = this.CartServiceProvider.UpdateCart(updateCartRequest);
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
public async Task <ActionResult <CartResponse> > UpdateMyCart([FromBody] UpdateCartRequest request)
{
var customerId = getUserMetaData().Id;
var cart = await cache.TryGet(customerId);
if (cart == null)
{
cart = new Cart(customerId);
}
if (request.Count <= 0)
{
throw new WWSException("Count must be positive", StatusCodes.Status400BadRequest);
}
try
{
var item = await inventoryApiClient.GetInventoryItem(request.ItemId).ConfigureAwait(false);
var updatedCart = cartService.AddCartItem(cart, item, request);
await cache.Invalidate(customerId);
await cache.Set(updatedCart);
return(Ok(CartResponse.Of(updatedCart)));
}
catch (StockIsNotEnoughException)
{
throw new WWSException("Not enough item in stock", StatusCodes.Status400BadRequest);
}
catch (Refit.ApiException ex)
{
if (ex.StatusCode == HttpStatusCode.NotFound)
{
throw new WWSException("Item not found", StatusCodes.Status404NotFound);
}
else
{
throw;
}
}
}
/// <summary>
/// Update the Cart with new information
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public virtual Task <ProcessedCart> UpdateCartAsync(UpdateCartParam param)
{
var request = new UpdateCartRequest
{
CultureName = param.CultureInfo != null ? param.CultureInfo.Name : null,
CustomerId = param.CustomerId,
ScopeId = param.Scope,
CartName = param.CartName,
BillingCurrency = param.BillingCurrency,
CartType = param.CartType,
Coupons = param.Coupons,
Customer = param.Customer,
OrderLocation = param.OrderLocation,
PropertyBag = param.PropertyBag,
Shipments = param.Shipments,
Status = param.Status,
Payments = param.Payments
};
var cacheKey = BuildCartCacheKey(param.Scope, param.CustomerId, param.CartName);
return(CacheProvider.ExecuteAndSetAsync(cacheKey, () => OvertureClient.SendAsync(request)));
}
public async Task <BaseDtoResponse <AddToCartDto> > Update(Guid id, UpdateCartRequest request)
{
try
{
CartItem existingItem = await _cartItemRepository.GetById(id);
if (existingItem == null)
{
return(new BaseDtoResponse <AddToCartDto>("Unable to update the item in the cart, try later!"));
}
existingItem.Quantity = request.Quantity;
await _cartItemRepository.Update(existingItem);
CartItem updatedItem = await _cartItemRepository.GetById(id);
AddToCartDto response = _mapper.Map <CartItem, AddToCartDto>(updatedItem);
return(new BaseDtoResponse <AddToCartDto>(response));
}
catch (Exception ex)
{
return(new BaseDtoResponse <AddToCartDto>(ex.Message));
}
}
public async Task <IActionResult> UpdateCart(int cartId, [FromBody] UpdateCartRequest request)
{
var result = await cartService.UpdateCarts(cartId, request);
return(StatusCode((int)result.Code, result.Value));
}
/// <summary>
/// Updates the cart.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="cart">The cart.</param>
/// <param name="cartChanges">The cart changes.</param>
/// <returns>The manager response with the updated cart.</returns>
public virtual ManagerResponse<CartResult, CommerceCart> UpdateCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] CommerceCart cart, [NotNull] CommerceCart cartChanges)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNull(cart, "cart");
Assert.ArgumentNotNull(cartChanges, "cartChanges");
var updateCartRequest = new UpdateCartRequest(cart, cartChanges);
var result = this.CartServiceProvider.UpdateCart(updateCartRequest);
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
return new ManagerResponse<CartResult, CommerceCart>(result, result.Cart as CommerceCart);
}
