// using on OrderDetail page
public ActionResult LoadOrder(int orderLink)
{
var success = false;
var purchaseOrder = _orderRepository.Load <IPurchaseOrder>(orderLink);
DateTime.TryParse(purchaseOrder.Properties[Constant.Quote.QuoteExpireDate].ToString(), out var quoteExpireDate);
if (DateTime.Compare(DateTime.Now, quoteExpireDate) > 0)
{
return(Json(new { success }));
}
if (CartWithValidationIssues.Cart != null && CartWithValidationIssues.Cart.OrderLink != null)
{
_orderRepository.Delete(CartWithValidationIssues.Cart.OrderLink);
}
_cart = new CartWithValidationIssues
{
Cart = _cartService.CreateNewCart(),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
var returnedCart = _cartService.PlaceOrderToCart(purchaseOrder, _cart.Cart);
returnedCart.Properties[Constant.Quote.ParentOrderGroupId] = purchaseOrder.OrderLink.OrderGroupId;
_orderRepository.Save(returnedCart);
var referenceSettings = _settingsService.GetSiteSettings <ReferencePageSettings>();
_cartService.ValidateCart(returnedCart);
return(Json(new { link = _urlResolver.GetUrl(referenceSettings?.CheckoutPage ?? ContentReference.StartPage) }));
}
public ActionResult RequestQuote(CartPage currentPage)
{
bool succesRequest;
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
succesRequest = _cartService.PlaceCartForQuote(_cart.Cart);
}
else
{
succesRequest = _cartService.PlaceCartForQuote(CartWithValidationIssues.Cart);
}
if (succesRequest)
{
_cartService.DeleteCart(_cart.Cart);
_cart = new CartWithValidationIssues
{
Cart = _cartService.CreateNewCart(),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
return(Redirect(currentPage.StaticLinkURL));
}
public ActionResult AddToCart(RequestParamsToCart param)
{
ModelState.Clear();
if (SharedCart.Cart == null)
{
_sharedCart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultSharedCartName, OrganizationId),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
param.Store = "delivery";
var result = _cartService.AddToCart(SharedCart.Cart, param);
if (result.EntriesAddedToCart)
{
_orderRepository.Save(SharedCart.Cart);
var productName = "";
var entryLink = _referenceConverter.GetContentLink(param.Code);
productName = _contentLoader.Get <EntryContentBase>(entryLink).DisplayName;
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
CountItems = (int)SharedCart.Cart.GetAllLineItems().Sum(x => x.Quantity),
Message = productName + " is added to the shared cart successfully."
}));
}
return(Json(new ChangeCartJsonResult {
StatusCode = -1, Message = result.GetComposedValidationMessage()
}));
}
public async Task <ActionResult> Subscription(RequestParamsToCart param)
{
var warningMessage = string.Empty;
ModelState.Clear();
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var result = _cartService.AddToCart(CartWithValidationIssues.Cart, param);
if (result.EntriesAddedToCart)
{
var item = CartWithValidationIssues.Cart.GetAllLineItems().FirstOrDefault(x => x.Code.Equals(param.Code));
var subscriptionPrice = PriceCalculationService.GetSubscriptionPrice(param.Code, CartWithValidationIssues.Cart.MarketId, CartWithValidationIssues.Cart.Currency);
if (subscriptionPrice != null)
{
item.Properties["SubscriptionPrice"] = subscriptionPrice.UnitPrice.Amount;
item.PlacedPrice = subscriptionPrice.UnitPrice.Amount;
}
_orderRepository.Save(CartWithValidationIssues.Cart);
await _recommendationService.TrackCart(HttpContext, CartWithValidationIssues.Cart);
return(MiniCartDetails());
}
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
public ActionResult RequestQuote()
{
bool succesRequest;
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
succesRequest = _cartService.PlaceCartForQuote(_cart.Cart);
}
else
{
succesRequest = _cartService.PlaceCartForQuote(CartWithValidationIssues.Cart);
}
if (succesRequest)
{
_cartService.DeleteCart(_cart.Cart);
_cart = new CartWithValidationIssues
{
Cart = _cartService.CreateNewCart(),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
return(Json(new { result = succesRequest }));
}
public JsonResult ClearQuotedCart()
{
_cartService.DeleteCart(CartWithValidationIssues.Cart);
_cart = new CartWithValidationIssues
{
Cart = _cartService.CreateNewCart(),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
return(Json("success", JsonRequestBehavior.AllowGet));
}
public ActionResult AddToSharedCart(RequestParamsToCart param)
{
ModelState.Clear();
var currentPage = _contentRouteHelper.Content as CartPage;
if (SharedCardWithValidationIssues.Cart == null)
{
_sharedcart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultSharedCartName, _customerService.GetCurrentContact().FoundationOrganization?.OrganizationId.ToString()),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var items = new Dictionary <int, string>();
foreach (var shipment in CartWithValidationIssues.Cart.Forms.SelectMany(x => x.Shipments))
{
foreach (var lineItem in shipment.LineItems)
{
if (!lineItem.Code.Equals(param.Code))
{
continue;
}
items.Add(shipment.ShipmentId, param.Code);
}
}
foreach (var key in items.Keys)
{
_cartService.ChangeCartItem(CartWithValidationIssues.Cart, key, items[key], 0, "", "");
}
_orderRepository.Save(CartWithValidationIssues.Cart);
if (SharedCardWithValidationIssues.Cart.GetAllLineItems().Any(item => item.Code.Equals(param.Code, StringComparison.OrdinalIgnoreCase)))
{
return(View("LargeCart", _cartViewModelFactory.CreateLargeCartViewModel(CartWithValidationIssues.Cart, currentPage)));
}
var result = _cartService.AddToCart(SharedCardWithValidationIssues.Cart,
new RequestParamsToCart {
Code = param.Code, Quantity = 1, Store = "delivery", SelectedStore = ""
});
if (!result.EntriesAddedToCart)
{
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
_orderRepository.Save(SharedCardWithValidationIssues.Cart);
var viewModel = _cartViewModelFactory.CreateLargeCartViewModel(CartWithValidationIssues.Cart, currentPage);
return(View("LargeCart", viewModel));
}
public ActionResult ClearCart(CartPage currentPage)
{
if (CartWithValidationIssues.Cart != null)
{
_orderRepository.Delete(CartWithValidationIssues.Cart.OrderLink);
_cart = null;
}
//var viewModel = _cartViewModelFactory.CreateLargeCartViewModel(CartWithValidationIssues.Cart, currentPage);
var redirect = currentPage.LinkURL;
return(Json(redirect));
}
public JsonResult AddVariantsToCart(List <string> variants)
{
var returnedMessages = new List <string>();
ModelState.Clear();
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
foreach (var product in variants)
{
var sku = product.Split(';')[0];
var quantity = Convert.ToInt32(product.Split(';')[1]);
var variationReference = _referenceConverter.GetContentLink(sku);
var responseMessage = _quickOrderService.ValidateProduct(variationReference, Convert.ToDecimal(quantity), sku);
if (responseMessage.IsNullOrEmpty())
{
var result = _cartService.AddToCart(CartWithValidationIssues.Cart,
new RequestParamsToCart {
Code = sku, Quantity = quantity, Store = "delivery", SelectedStore = ""
});
if (result.EntriesAddedToCart)
{
_cartService.ChangeCartItem(CartWithValidationIssues.Cart, 0, sku, quantity, "", "");
_orderRepository.Save(CartWithValidationIssues.Cart);
}
}
else
{
returnedMessages.Add(responseMessage);
}
}
Session[Constant.ErrorMessages] = returnedMessages;
return(Json(returnedMessages, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Reorder(string orderId)
{
if (!int.TryParse(orderId, out var orderIntId))
{
return(new HttpStatusCodeResult(500, "Error reordering order"));
}
var order = _orderRepository.Load <IPurchaseOrder>(orderIntId);
if (order == null)
{
return(new HttpStatusCodeResult(500, "Error reordering order"));
}
ModelState.Clear();
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var lineitems = order.Forms.First().GetAllLineItems();
foreach (var item in lineitems)
{
var result = _cartService.AddToCart(CartWithValidationIssues.Cart,
new RequestParamsToCart {
Code = item.Code, Quantity = item.Quantity, Store = "delivery", SelectedStore = ""
});
if (result.EntriesAddedToCart)
{
await _recommendationService.TrackCart(HttpContext, CartWithValidationIssues.Cart);
}
else
{
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
}
_orderRepository.Save(CartWithValidationIssues.Cart);
return(Redirect(Url.ContentUrl(_settingsService.GetSiteSettings <ReferencePageSettings>()?.CheckoutPage ?? ContentReference.StartPage)));
}
public async Task <ActionResult> AddAllToCart()
{
var allLineItem = WishList.Cart.GetAllLineItems();
var entriesAddedToCart = true;
var validationMessage = "";
if (Cart.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
foreach (var lineitem in allLineItem)
{
var result = _cartService.AddToCart(Cart.Cart,
new RequestParamsToCart {
Code = lineitem.Code, Quantity = lineitem.Quantity, Store = "delivery", SelectedStore = "", DynamicCodes = lineitem.Properties["VariantOptionCodes"]?.ToString().Split(',').ToList()
});
entriesAddedToCart &= result.EntriesAddedToCart;
validationMessage += result.GetComposedValidationMessage();
}
if (entriesAddedToCart)
{
_orderRepository.Save(Cart.Cart);
await _trackingService.TrackCart(HttpContext, Cart.Cart);
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
Message = "Add all LineItems from the wishlist to the cart.",
CountItems = (int)Cart.Cart.GetAllLineItems().Sum(x => x.Quantity),
}));
}
return(new HttpStatusCodeResult(500, validationMessage));
}
public JsonResult AddVariantsToOrderPad(List <string> variants)
{
var returnedMessages = new List <string>();
ModelState.Clear();
if (WishList.Cart == null)
{
_wishlist = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultWishListName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
foreach (var product in variants)
{
var sku = product.Split(';')[0];
var quantity = Convert.ToInt32(product.Split(';')[1]);
var variationReference = _referenceConverter.GetContentLink(sku);
var responseMessage = _quickOrderService.ValidateProduct(variationReference, Convert.ToDecimal(quantity), sku);
if (string.IsNullOrEmpty(responseMessage))
{
if (_cartService.AddToCart(WishList.Cart, sku, 1, "delivery", "").EntriesAddedToCart)
{
_orderRepository.Save(WishList.Cart);
}
}
else
{
returnedMessages.Add(responseMessage);
}
}
Session[Constant.ErrorMessages] = returnedMessages;
return(Json(returnedMessages, JsonRequestBehavior.AllowGet));
}
public async Task <JsonResult> AddToCart(RequestParamsToCart param) // only use Code
{
if (WishList.Cart == null)
{
_wishlist = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultWishListName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
// return 0 if the variant already exist in wishlist
// return 1 if added susscessfully
var result = new AddToCartResult();
var allLineItems = WishList.Cart.GetAllLineItems();
var contentLink = _referenceConverter.GetContentLink(param.Code);
var message = "";
var productName = "";
var entryLink = _referenceConverter.GetContentLink(param.Code);
productName = _contentLoader.Get <EntryContentBase>(entryLink).DisplayName;
if (_contentLoader.Get <EntryContentBase>(contentLink) is GenericBundle bundle) // Add bundle
{
var variantCodes = _contentLoader
.GetItems(bundle.GetEntries(_relationRepository), _languageResolver.GetPreferredCulture())
.OfType <VariationContent>()
.Where(v => v.IsAvailableInCurrentMarket(_currentMarket) && !_filterPublished.ShouldFilter(v))
.Select(x => x.Code);
var allLineItemCodes = allLineItems.Select(x => x.Code);
var allNewCodes = variantCodes.Where(x => !allLineItemCodes.Contains(x));
if (!allNewCodes.Any())
{
return(Json(new ChangeCartJsonResult {
StatusCode = 0, Message = productName + " already exist in the wishlist."
}));
}
else
{
foreach (var v in allNewCodes)
{
result = _cartService.AddToCart(WishList.Cart, new RequestParamsToCart {
Code = v, Quantity = 1, Store = "delivery", SelectedStore = ""
});
if (result.ValidationMessages.Count > 0)
{
message += string.Join("\n", result.ValidationMessages);
}
}
}
}
else // Add variant
{
if (allLineItems.Any(item => item.Code.Equals(param.Code, StringComparison.OrdinalIgnoreCase)))
{
return(Json(new ChangeCartJsonResult {
StatusCode = 0, Message = productName + " already exist in the wishlist."
}));
}
result = _cartService.AddToCart(WishList.Cart,
new RequestParamsToCart {
Code = param.Code, Quantity = 1, Store = "delivery", SelectedStore = ""
});
}
if (result.EntriesAddedToCart)
{
_orderRepository.Save(WishList.Cart);
await _trackingService.TrackWishlist(HttpContext);
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
CountItems = (int)WishList.Cart.GetAllLineItems().Sum(x => x.Quantity),
Message = productName + " is added to the wishlist successfully.\n" + message
}));
}
return(Json(new ChangeCartJsonResult {
StatusCode = -1, Message = result.GetComposedValidationMessage()
}));
}
public ActionResult MoveToWishlist(RequestParamsToCart param)
{
ModelState.Clear();
var productName = "";
var entryLink = _referenceConverter.GetContentLink(param.Code);
productName = _contentLoader.Get <EntryContentBase>(entryLink).DisplayName;
var currentPage = _contentRouteHelper.Content as CartPage;
if (WishListWithValidationIssues.Cart == null)
{
_wishlist = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultWishListName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var items = new Dictionary <int, string>();
foreach (var shipment in CartWithValidationIssues.Cart.Forms.SelectMany(x => x.Shipments))
{
foreach (var lineItem in shipment.LineItems)
{
if (!lineItem.Code.Equals(param.Code))
{
continue;
}
items.Add(shipment.ShipmentId, param.Code);
}
}
if (WishListWithValidationIssues.Cart.GetAllLineItems().Any(item => item.Code.Equals(param.Code, StringComparison.OrdinalIgnoreCase)))
{
return(Json(new ChangeCartJsonResult
{
StatusCode = 0,
Message = productName + " already existed in the wishlist.",
}));
}
foreach (var key in items.Keys)
{
_cartService.ChangeCartItem(CartWithValidationIssues.Cart, key, items[key], 0, "", "");
}
_orderRepository.Save(CartWithValidationIssues.Cart);
var result = _cartService.AddToCart(WishListWithValidationIssues.Cart, param.Code, 1, "delivery", "");
if (!result.EntriesAddedToCart)
{
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
_orderRepository.Save(WishListWithValidationIssues.Cart);
var viewModel = _cartViewModelFactory.CreateLargeCartViewModel(CartWithValidationIssues.Cart, currentPage);
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
Message = productName + " has moved to the wishlist.",
CountItems = (int)CartWithValidationIssues.Cart.GetAllLineItems().Sum(x => x.Quantity),
SubTotal = viewModel.Subtotal,
Total = viewModel.Total,
ShippingTotal = viewModel.ShippingTotal,
TaxTotal = viewModel.TaxTotal,
TotalDiscount = viewModel.TotalDiscount
}));
}
public async Task <ActionResult> BuyNow(RequestParamsToCart param)
{
var warningMessage = string.Empty;
ModelState.Clear();
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var result = _cartService.AddToCart(CartWithValidationIssues.Cart, param.Code, param.Quantity, param.Store, param.SelectedStore);
if (!result.EntriesAddedToCart)
{
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
var contact = PrincipalInfo.CurrentPrincipal.GetCustomerContact();
if (contact == null)
{
return(RedirectToCart("The contact is invalid"));
}
var creditCard = contact.ContactCreditCards.FirstOrDefault();
if (creditCard == null)
{
return(RedirectToCart("There is not any credit card"));
}
var shipment = CartWithValidationIssues.Cart.GetFirstShipment();
if (shipment == null)
{
return(RedirectToCart("The shopping cart is not exist"));
}
var shippingAddress = (contact.PreferredShippingAddress ?? contact.ContactAddresses.FirstOrDefault())?.ConvertToOrderAddress(CartWithValidationIssues.Cart);
if (shippingAddress == null)
{
return(RedirectToCart("The shipping address is not exist"));
}
shipment.ShippingAddress = shippingAddress;
var shippingMethodViewModels = _shipmentViewModelFactory.CreateShipmentsViewModel(CartWithValidationIssues.Cart).SelectMany(x => x.ShippingMethods);
var shippingMethodViewModel = shippingMethodViewModels.Where(x => x.Price != 0)
.OrderBy(x => x.Price)
.FirstOrDefault();
//If product is virtual set shipping method is Free
if (shipment.LineItems.FirstOrDefault().IsVirtualVariant())
{
shippingMethodViewModel = shippingMethodViewModels.Where(x => x.Price == 0).FirstOrDefault();
}
if (shippingMethodViewModel == null)
{
return(RedirectToCart("The shipping method is invalid"));
}
shipment.ShippingMethodId = shippingMethodViewModel.Id;
var paymentAddress = (contact.PreferredBillingAddress ?? contact.ContactAddresses.FirstOrDefault())?.ConvertToOrderAddress(CartWithValidationIssues.Cart);
if (paymentAddress == null)
{
return(RedirectToCart("The billing address is not exist"));
}
var totals = _orderGroupCalculator.GetOrderGroupTotals(CartWithValidationIssues.Cart);
var payment = CartWithValidationIssues.Cart.CreateCardPayment();
payment.BillingAddress = paymentAddress;
payment.CardType = "Credit card";
payment.PaymentMethodId = new Guid("B1DA37A6-CF19-40D5-915B-B863D74D8799");
payment.PaymentMethodName = "GenericCreditCard";
payment.Amount = CartWithValidationIssues.Cart.GetTotal().Amount;
payment.CreditCardNumber = creditCard.CreditCardNumber;
payment.CreditCardSecurityCode = creditCard.SecurityCode;
payment.ExpirationMonth = creditCard.ExpirationMonth ?? 1;
payment.ExpirationYear = creditCard.ExpirationYear ?? DateTime.Now.Year;
payment.Status = PaymentStatus.Pending.ToString();
payment.CustomerName = contact.FullName;
payment.TransactionType = TransactionType.Authorization.ToString();
CartWithValidationIssues.Cart.GetFirstForm().Payments.Add(payment);
var issues = _cartService.ValidateCart(CartWithValidationIssues.Cart);
if (issues.Keys.Any(x => issues.HasItemBeenRemoved(x)))
{
return(RedirectToCart("The product is invalid"));
}
var order = _checkoutService.PlaceOrder(CartWithValidationIssues.Cart, new ModelStateDictionary(), new CheckoutViewModel());
//await _checkoutService.CreateOrUpdateBoughtProductsProfileStore(CartWithValidationIssues.Cart);
//await _checkoutService.CreateBoughtProductsSegments(CartWithValidationIssues.Cart);
await _recommendationService.TrackOrder(HttpContext, order);
var homePage = _contentLoader.Get <PageData>(ContentReference.StartPage) as CommerceHomePage;
if (homePage?.OrderConfirmationPage != null)
{
var orderConfirmationPage = _contentLoader.Get <OrderConfirmationPage>(homePage.OrderConfirmationPage);
var queryCollection = new NameValueCollection
{
{ "contactId", contact.PrimaryKeyId?.ToString() },
{ "orderNumber", order.OrderLink.OrderGroupId.ToString() }
};
var urlRedirect = new UrlBuilder(orderConfirmationPage.StaticLinkURL)
{
QueryCollection = queryCollection
};
return(Json(new { Redirect = urlRedirect.ToString() }));
}
return(RedirectToCart("Something went wrong"));
}
public async Task <ActionResult> AddToCart(RequestParamsToCart param)
{
var warningMessage = string.Empty;
ModelState.Clear();
if (CartWithValidationIssues.Cart == null)
{
_cart = new CartWithValidationIssues
{
Cart = _cartService.LoadOrCreateCart(_cartService.DefaultCartName),
ValidationIssues = new Dictionary <ILineItem, List <ValidationIssue> >()
};
}
var result = _cartService.AddToCart(CartWithValidationIssues.Cart, param.Code, param.Quantity, param.Store, param.SelectedStore);
if (result.EntriesAddedToCart)
{
_orderRepository.Save(CartWithValidationIssues.Cart);
await _recommendationService.TrackCart(HttpContext, CartWithValidationIssues.Cart);
if (string.Equals(param.RequestFrom, "axios", StringComparison.OrdinalIgnoreCase))
{
var product = "";
var entryLink = _referenceConverter.GetContentLink(param.Code);
var entry = _contentLoader.Get <EntryContentBase>(entryLink);
if (entry is BundleContent || entry is PackageContent)
{
product = entry.DisplayName;
}
else
{
var parentProduct = _contentLoader.Get <EntryContentBase>(entry.GetParentProducts().FirstOrDefault());
product = parentProduct?.DisplayName;
}
if (result.ValidationMessages.Count > 0)
{
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
CountItems = (int)CartWithValidationIssues.Cart.GetAllLineItems().Sum(x => x.Quantity),
Message = product + " is added to the cart successfully.\n" + result.GetComposedValidationMessage(),
SubTotal = CartWithValidationIssues.Cart.GetSubTotal()
}));
}
return(Json(new ChangeCartJsonResult
{
StatusCode = 1,
CountItems = (int)CartWithValidationIssues.Cart.GetAllLineItems().Sum(x => x.Quantity),
Message = product + " is added to the cart successfully.",
SubTotal = CartWithValidationIssues.Cart.GetSubTotal()
}));
}
return(MiniCartDetails());
}
return(new HttpStatusCodeResult(500, result.GetComposedValidationMessage()));
}
