private void bindData()
{
string locale = CultureInfo.CurrentCulture.Name;
var MyOrders = OrdersProvider.GetOrdersInProcessing(DistributorID, locale);
OrdersGrid.DataSource = MyOrders;
}
public async Task <IHttpActionResult> GetCurrentUserOrders()
{
Guid userId = new Guid(this.User.Identity.GetUserId());
OrdersProvider ordersProvider = new OrdersProvider();
IEnumerable <OrderModel> userOrders = await ordersProvider.GetOrdersByUserId(userId);
return(this.Ok(userOrders));
}
public async Task <IHttpActionResult> GetOrderHistory(int orderId)
{
Guid userId = new Guid(this.User.Identity.GetUserId());
OrdersProvider ordersProvider = new OrdersProvider();
IEnumerable <StatusHistoryModel> orderItems = await ordersProvider.GetOrderHistory(orderId, userId);
return(this.Ok(orderItems));
}
public void TestRemoveAllCompletedOrders()
{
// Act
_mockOrderRepository.Setup(x => x.RemoveCompletedOrders()).Returns("Completed Orders Cleared");
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputRemoveAllCompletedOrdersAsProviderResponseWrapper = orderProvider.RemoveCompletedOrders();
// Assert
Assert.AreEqual("Completed Orders Cleared", outputRemoveAllCompletedOrdersAsProviderResponseWrapper.ResponseMessage);
}
public void TestGetOrdersReturnsNullOrders()
{
// Act
_mockOrderRepository.Setup(x => x.GetLateOrders()).Returns(CreateOrderDTOList(0));
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputGetOrdersAsProviderResponseWrapper = orderProvider.GetLateOrders();
// Assert
Assert.AreEqual("No late orders", outputGetOrdersAsProviderResponseWrapper.ResponseMessage);
}
private List <MyOrdersViewModel> GetMyOrdersFromSource(string id)
{
var orders = OrdersProvider.GetOrders(id, string.Empty, null, null, false, "DESC");
var myOrders = ConvertToMyorders(orders);
if (null != myOrders && myOrders.Any())
{
return(myOrders.OrderByDescending(o => o.Date).ToList());
}
return(new List <MyOrdersViewModel>());
}
public void TestCreateNullOrder()
{
// Arrange
Order newNullTestOrder = null;
// Act
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputCreateOrderDocumentsAsProviderResponseWrapper = orderProvider.CreateOrderDocument(newNullTestOrder);
// Assert
Assert.AreEqual("The form has not been fully complete, please send a completed form.", outputCreateOrderDocumentsAsProviderResponseWrapper.ResponseMessage);
}
public async Task <ActionResult> Order(int id)
{
OrdersProvider ordersProvider = new OrdersProvider();
SimpleOrderModel order = await ordersProvider.GetOrder(id);
if (order.PaymentMethodId == 1)
{
return(this.View("Epay", order));
}
return(this.Redirect("/order-accepted"));
}
public void TestGetOrdersReturnsOneLateOrder()
{
// Act
_mockOrderRepository.Setup(x => x.GetLateOrders()).Returns(CreateOrderDTOList(1));
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputGetOrdersAsProviderResponseWrapper = orderProvider.GetLateOrders();
List <OrderDTO> outputOrderList = JsonConvert.DeserializeObject <List <OrderDTO> >(outputGetOrdersAsProviderResponseWrapper.ResponseMessage);
// Assert
Assert.AreEqual(1, outputOrderList.Count);
Assert.AreEqual("Test0", outputOrderList[0].Id);
}
public void TestCreateInvalidOrder()
{
// Arrange
string nullCustomerFirst = null;
Order newInvalidTestOrder = CreateTestOrder(nullCustomerFirst);
// Act
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputCreateOrderDocumentsAsProviderResponseWrapper = orderProvider.CreateOrderDocument(newInvalidTestOrder);
// Assert
Assert.AreEqual("Some fields are completed incorrect. Please re-enter values again.", outputCreateOrderDocumentsAsProviderResponseWrapper.ResponseMessage);
}
public void TestCreateValidOrder()
{
// Arrange
string validCustomerFirst = "test";
Order newValidTestOrder = CreateTestOrder(validCustomerFirst);
// Act
_mockOrderRepository.Setup(x => x.CreateOrderDocument(It.IsAny <OrderDTO>())).Returns("New item Inserted");
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputCreateOrderDocumentsAsProviderResponseWrapper = orderProvider.CreateOrderDocument(newValidTestOrder);
// Assert
Assert.AreEqual("New item Inserted", outputCreateOrderDocumentsAsProviderResponseWrapper.ResponseMessage);
}
public async Task TestRemoveOrderInvalidID()
{
// Arrange
string invalidOrderID = "invalid";
// Act
OrdersProvider ordersProvider = new OrdersProvider(_mockOrdersRepository.Object, _mockHttpClient.Object);
ProviderResponseWrapper outputGetRemovedItemMessageAsPRW = await
ordersProvider.RemoveOrder(invalidOrderID);
// Asserts
Assert.AreEqual("No record matches given ID", outputGetRemovedItemMessageAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_NOT_FOUND, outputGetRemovedItemMessageAsPRW.ResponseHTMLType);
}
public async Task TestRemoveOrderNullID()
{
// Arrange
string nullOrderID = null;
// Act
OrdersProvider ordersProvider = new OrdersProvider(_mockOrdersRepository.Object, _mockHttpClient.Object);
ProviderResponseWrapper outputGetRemovedItemMessageAsPRW = await
ordersProvider.RemoveOrder(nullOrderID);
// Asserts
Assert.AreEqual("No order exists, null given", outputGetRemovedItemMessageAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_NOT_FOUND, outputGetRemovedItemMessageAsPRW.ResponseHTMLType);
}
public async Task TestCompletedOrderInvalidOrderID()
{
// Arrange
string orderDTOjson = "60242a787f13737283ef0bce";
// Act
OrdersProvider ordersProvider = new OrdersProvider(null, null);
ProviderResponseWrapper outputGetNullResponseAsPRW = await
ordersProvider.BoxOrderCreateAsync(orderDTOjson);
// Asserts
Assert.AreEqual("No Order ID document could be found.", outputGetNullResponseAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_NOT_FOUND, outputGetNullResponseAsPRW.ResponseHTMLType);
}
public async Task TestCompleteOrderNullOrderID()
{
// Arrange
string orderDTOjson = null;
// Act
OrdersProvider ordersProvider = new OrdersProvider(null, null);
ProviderResponseWrapper outputGetNullResponseAsPRW = await
ordersProvider.BoxOrderCreateAsync(orderDTOjson);
// Asserts
Assert.AreEqual("Please enter a Order ID.", outputGetNullResponseAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_BAD_REQUEST, outputGetNullResponseAsPRW.ResponseHTMLType);
}
public void TestGetOrdersReturnsOneThousandLateOrders()
{
// Act
_mockOrderRepository.Setup(x => x.GetLateOrders()).Returns(CreateOrderDTOList(1000));
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputGetOrdersAsProviderResponseWrapper = orderProvider.GetLateOrders();
List <OrderDTO> outputOrderList = JsonConvert.DeserializeObject <List <OrderDTO> >(outputGetOrdersAsProviderResponseWrapper.ResponseMessage);
// Assert
Assert.AreEqual(1000, outputOrderList.Count);
for (int i = 0; i < outputOrderList.Count; i++)
{
Assert.AreEqual("Test" + i.ToString(), outputOrderList[i].Id);
}
}
private async Task ExecuteOrderProcessAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Getting data from file...");
var ordersProvider = new OrdersProvider();
var orders = ordersProvider.GetOrdersFromCsv(Reader).Take(_maxMailsAtOnce).ToList();
if (!orders.Any())
{
return;
}
_logger.LogInformation($"Found {orders.Count} orders for send.");
_logger.LogInformation("Starting sending process...");
var orderMailService = new OrderMailService(_smtpClient, _logger);
await orderMailService.SendOrders(orders, stoppingToken);
}
public void SendNewOrderMail(int orderId)
{
HostingEnvironmentPolyfills.QueueBackgroundWorkItemPf(async ct =>
{
NewOrderEmailModel emailModel = new NewOrderEmailModel();
OrdersProvider ordersProvider = new OrdersProvider();
Order order = await ordersProvider.GetFullOrderData(orderId);
string toEmailAddress;
using (ApplicationDbContext appContext = new ApplicationDbContext())
{
string userId = order.UserId.ToString();
Address userAddress = await appContext.AddressInfos.FirstOrDefaultAsync(a => a.UserId == userId);
emailModel.Country = userAddress.Country;
emailModel.City = userAddress.City;
emailModel.District = userAddress.District;
emailModel.PostCode = userAddress.PostCode;
emailModel.Commune = userAddress.Commune;
emailModel.AddresDetails = userAddress.AddresDetails;
emailModel.FullName = string.Format("{0} {1} {2}", userAddress.FirstName, userAddress.MiddleName, userAddress.LastName);
emailModel.Phone = userAddress.Phone;
toEmailAddress = userAddress.Email;
}
emailModel.BaseUrl = ConfigurationManager.AppSettings["Site.BaseUrl"];
emailModel.ContactUsFormUrl = string.Concat(emailModel.BaseUrl, ConfigurationManager.AppSettings["Site.ContactUsFormUrl"].TrimStart('/'));
emailModel.OrdersPageUrl = string.Concat(emailModel.BaseUrl, ConfigurationManager.AppSettings["Site.OrdersPageUrl"].TrimStart('/'));
emailModel.OrderNumber = order.Id;
emailModel.CommissionPercents = order.HasCommission ? order.CommissionPercents : 0;
emailModel.DeliveryMerchant = order.DeliveryMerchant;
emailModel.ShippingPrice = order.ShippingPrice.ToString("N2") + "лв";
emailModel.TotalPrice = order.TotalPrice.ToString("N2") + "лв";
emailModel.Items = order.OrderDetails.Select(od => new Item()
{
Title = od.Article.Title,
Quantity = od.Quantity,
Price = od.ItemPrice.ToString("N2") + "лв"
}).ToList();
string emailContent = templateEngine.RenderTemplate("NewOrder", emailModel);
await this.mailSender.SendEmail(toEmailAddress, string.Format("{0}: Поръчка #{1}", emailModel.BaseUrl, emailModel.OrderNumber), emailContent);
});
}
public void ModifyOrderStatusInvalidOrderID()
{
// Arrange
string invalidOrderID = "Invalid Test ID";
string statusType = "Completed";
// Act
_mockOrderRepository.Setup(x => x.ModifyOrderStatus(It.IsAny <string>(), It.IsAny <string>())).Throws(new FormatException());
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputModifyOrderStatusAsPRW = orderProvider.ModifyOrderStatus(invalidOrderID, statusType);
// Assert
Assert.AreEqual("Order ID does not exist", outputModifyOrderStatusAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_BAD_REQUEST, outputModifyOrderStatusAsPRW.ResponseHTMLType);
}
public void ModifyOrderStatusSuccess()
{
// Arrange
string validOrderID = "5c979251a7d6851258d7b574";
string statusType = "Completed";
// Act
_mockOrderRepository.Setup(x => x.ModifyOrderStatus(It.IsAny <string>(), It.IsAny <string>())).Returns("Stock status has been adjusted.");
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputModifyOrderStatusAsPRW = orderProvider.ModifyOrderStatus(validOrderID, statusType);
// Assert
Assert.AreEqual(outputModifyOrderStatusAsPRW.ResponseMessage, "Stock status has been adjusted.");
Assert.AreEqual(outputModifyOrderStatusAsPRW.ResponseHTMLType, HTTPResponseCodes.HTTP_OK_RESPONSE);
}
public void ModifyOrderStatusNullOrderId()
{
// Arrange
string validOrderID = "";
string statusType = "";
// Act
_mockOrderRepository.Setup(x => x.ModifyOrderStatus(It.IsAny <string>(), It.IsAny <string>())).Throws(new NullReferenceException());
OrdersProvider orderProvider = new OrdersProvider(_mockOrderRepository.Object, null);
ProviderResponseWrapper outputModifyOrderStatusAsPRW = orderProvider.ModifyOrderStatus(validOrderID, statusType);
// Assert
Assert.AreEqual(outputModifyOrderStatusAsPRW.ResponseMessage, "No Order ID was given, please enter an Order ID");
Assert.AreEqual(HTTPResponseCodes.HTTP_BAD_REQUEST, outputModifyOrderStatusAsPRW.ResponseHTMLType);
}
public async Task GetOrdersReturnsAllOrders()
{
var options = new DbContextOptionsBuilder <OrdersDbContext>()
.UseSqlServer("Data Source=LAPTOP-U3V1724K;Initial Catalog=Microservices.Orders.Database;Integrated Security=True")
.Options;
var dbContext = new OrdersDbContext(options);
var orderProfile = new OrderProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(orderProfile));
var mapper = new Mapper(configuration);
var ordersProvider = new OrdersProvider(dbContext, null, mapper, configuration, null);
var order = await ordersProvider.GetAllOrdersAsync();
Assert.True(order.IsSuccess);
Assert.True(order.Orders.Any());
Assert.Null(order.ErrorMessage);
}
public async Task GetAllOrdersAsyncTest()
{
var options = new DbContextOptionsBuilder <OrdersDbContext>()
.UseInMemoryDatabase(nameof(GetAllOrdersAsyncTest))
.Options;
var dbContext = new OrdersDbContext(options);
CreateOrders(dbContext);
var orderProfile = new OrderProfile();
var configuration = new MapperConfiguration(config => config.AddProfile(orderProfile));
var mapper = new Mapper(configuration);
var ordersProvider = new OrdersProvider(dbContext, null, mapper);
var orders = await ordersProvider.GetOrdersAsync(1);
Assert.IsNotNull(orders.Orders);
Assert.IsTrue(orders.IsSuccess);
Assert.IsNull(orders.ErrorMessage);
}
public void SendOrderStatusChangedMail(int orderId, int oldStatusId, int newStatusId)
{
if (oldStatusId == newStatusId)
{
return;
}
HostingEnvironmentPolyfills.QueueBackgroundWorkItemPf(async ct =>
{
OrdersProvider ordersProvider = new OrdersProvider();
Task <OrderStatusModel> getNewStatusTask = ordersProvider.GetStatus(newStatusId);
Task <OrderStatusModel> getOldStatusTask = ordersProvider.GetStatus(oldStatusId);
OrderStatusChangedEmailModel emailModel = new OrderStatusChangedEmailModel();
emailModel.OrderNumber = orderId;
SimpleOrderModel orderModel = await ordersProvider.GetOrder(orderId);
string toEmailAddress;
using (ApplicationDbContext appContext = new ApplicationDbContext())
{
string userId = orderModel.UserId.ToString();
Address userAddress = await appContext.AddressInfos.FirstOrDefaultAsync(a => a.UserId == userId);
emailModel.FullName = string.Format("{0} {1} {2}", userAddress.FirstName, userAddress.MiddleName, userAddress.LastName);
toEmailAddress = userAddress.Email;
}
emailModel.BaseUrl = ConfigurationManager.AppSettings["Site.BaseUrl"];
OrderStatusModel newOrderStatus = await getNewStatusTask;
OrderStatusModel oldOrderStatus = await getOldStatusTask;
emailModel.NewOrderStatus = newOrderStatus.Name;
emailModel.OldOrderStatus = oldOrderStatus.Name;
string emailContent = templateEngine.RenderTemplate("OrderStatusChanged", emailModel);
await this.mailSender.SendEmail(toEmailAddress, string.Format("{0}: Статусът на поръчка #{1} беше променен", emailModel.BaseUrl, orderId), emailContent);
});
}
public async Task GetAllOrdersWdInvalidId()
{
var options = new DbContextOptionsBuilder <OrdersDbContext>()
.UseInMemoryDatabase(nameof(GetAllOrdersWdValidId))
.Options;
var dbContext = new OrdersDbContext(options);
SeedData(dbContext);
var ordersProfile = new OrderProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(ordersProfile));
var mapper = new Mapper(configuration);
var ordersProvider = new OrdersProvider(dbContext, null, mapper);
var results = await ordersProvider.GetOrdersAsync(-1);
Assert.False(results.IsSuccess);
Assert.Null(results.Orders);
Assert.NotNull(results.ErrorMessage);
}
public async Task GetOrdersReturnsAllOrdersByCustomerId()
{
var options = new DbContextOptionsBuilder <OrderDbContext>()
.UseInMemoryDatabase(nameof(GetOrdersReturnsAllOrdersByCustomerId))
.Options;
var dbContext = new OrderDbContext(options);
//Mock Object for the mapper
var orderProfile = new OrderProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(orderProfile));
var mapper = new Mapper(configuration);
var ordersProvider = new OrdersProvider(dbContext, null, mapper);
var order = await ordersProvider.GetOrdersAsync(1);
Assert.True(order.IsSuccess);
Assert.True(order.Orders.Any());
Assert.Null(order.ErrorMessage);
}
public async Task TestGetCompletedListOfItemsForOrder()
{
// Arrange
string orderDTOjson = JsonConvert.SerializeObject(CreateOrderDTO());
HttpContent content = new StringContent(orderDTOjson);
_mockHttpClient.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new HttpResponseMessage {
Content = content, StatusCode = HttpStatusCode.OK
}));
_mockOrdersRepository.Setup(x => x.GetOrder(It.IsAny <string>())).Returns(CreateOrderDTO());
// Act
OrdersProvider ordersProvider = new OrdersProvider(_mockOrdersRepository.Object, _mockHttpClient.Object);
ProviderResponseWrapper outputGetCompletedListOfItemsForOrderAsPRW = await
ordersProvider.BoxOrderCreateAsync(orderDTOjson);
// Asserts
Assert.AreEqual(outputGetCompletedListOfItemsForOrderAsPRW.ResponseMessage, orderDTOjson);
Assert.AreEqual(HTTPResponseCodes.HTTP_OK_RESPONSE, outputGetCompletedListOfItemsForOrderAsPRW.ResponseHTMLType);
}
public async Task TestRemoveOrderValidID()
{
// Arrange
string orderDTOjson = JsonConvert.SerializeObject(CreateBoxItems());
HttpContent content = new StringContent(orderDTOjson);
string validOrderID = "5c8818b2f81e697d3c82d90e";
_mockHttpClient.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new HttpResponseMessage {
Content = content, StatusCode = HttpStatusCode.OK
}));
_mockOrdersRepository.Setup(x => x.RemoveOrder(It.IsAny <string>())).Returns(CreateOrder());
// Act
OrdersProvider ordersProvider = new OrdersProvider(_mockOrdersRepository.Object, _mockHttpClient.Object);
ProviderResponseWrapper outputGetRemovedItemMessageAsPRW = await
ordersProvider.RemoveOrder(validOrderID);
// Asserts
Assert.AreEqual("Record has been successfully removed", outputGetRemovedItemMessageAsPRW.ResponseMessage);
Assert.AreEqual(HTTPResponseCodes.HTTP_OK_RESPONSE, outputGetRemovedItemMessageAsPRW.ResponseHTMLType);
}
public async Task <IHttpActionResult> ValidateAndSaveOrder(FullOrderModel order)
{
if (!this.ModelState.IsValid)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: invalid model state");
return(this.BadRequest(this.ModelState));
}
if (order.Items.Count() == 0)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: no items");
return(this.BadRequest("Empty order"));
}
OrderItemsGrouper itemsGrouper = new OrderItemsGrouper();
IList <OrderedItemModel> normalizedItems = itemsGrouper.NormalizeOrderedItems(order.Items.ToList());
if (normalizedItems == null)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: grouping error");
return(this.BadRequest("Different prices of the same item"));
}
OrderValidator orderValidator = new OrderValidator();
bool areOrderItemsValid = await orderValidator.ValidateOrderItems(normalizedItems);
if (!areOrderItemsValid)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: invalid quantities");
return(this.BadRequest("Invalid quantities"));
}
bool freeShipping = order.Coupones != null && order.Coupones.Any(c => c.FreeShipping.Value);
IModelTracker <DeliveryMethodModel> deliveryMethodModelTracker = new DeliveryMethodsTrackerFactory().GetDeliveryMethodsTracker(freeShipping);
IModelTracker <PaymentMethodModel> paymentMethodModelTracker = new PaymentMethodsTrackerFactory().GetPaymentMethodsTracker(freeShipping);
bool isLoyal = deliveryMethodModelTracker is FreeShippingDeliveryMethodsTracker;
DeliveryMethodsProvider deliveryMethodsProvider = new DeliveryMethodsProvider(deliveryMethodModelTracker);
PaymentMethodsProvider paymentMethodsProvider = new PaymentMethodsProvider(paymentMethodModelTracker);
if (order.Coupones != null)
{
bool areCouponesValid = await orderValidator.ValidateCoupones(this.User.Identity.GetUserId(), order);
if (!areCouponesValid)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: invalid coupones");
return(this.BadRequest("Invalid coupones"));
}
}
bool areOrderPricesValid = await orderValidator.ValidatePrices(order, deliveryMethodsProvider, paymentMethodsProvider);
if (!areOrderPricesValid)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: invalid prive");
return(this.BadRequest("Invalid price"));
}
StocksProvider stocksProvider = new StocksProvider();
bool stockQuantitiesUpdatedSuccessfully = await stocksProvider.UpdateStocks(
normalizedItems.Select(o => new StockChangeModel(o.ArticleId.Value, o.SizeId.Value, o.ColorId, -o.Quantity.Value)),
Logger.Current);
if (!stockQuantitiesUpdatedSuccessfully)
{
Logger.Current.LogWarning("Orders.ValidateAndSaveOrder: invalid quantities (update stocks)");
return(this.BadRequest("Invalid quantities"));
}
Task <DeliveryMethodModel> getDeliveryMethodTask = deliveryMethodsProvider.GetDeliveryMethodById(order.DeliveryMethodId.Value);
Task <PaymentMethodModel> getPaymentMethodTask = paymentMethodsProvider.GetPaymentMethodById(order.PaymentMethodId.Value);
DeliveryMethodModel deliveryMethod = await getDeliveryMethodTask;
PaymentMethodModel paymentMethod = await getPaymentMethodTask;
Order newOrder = new Order();
newOrder.UserId = new Guid(this.User.Identity.GetUserId());
newOrder.DeliveryMerchant = deliveryMethod.Name;
newOrder.DeliveryPrice = deliveryMethod.DeliveryPrice;
newOrder.PaymentMethodId = paymentMethod.Id;
newOrder.HasCommission = paymentMethod.ApplyDeliveryTax;
newOrder.CommissionPercents = deliveryMethod.CODTax;
newOrder.ShippingPrice = order.Total.Shipping.Value;
newOrder.ItemsPrice = order.Total.Order.Value;
newOrder.TotalPrice = order.Total.Full.Value;
newOrder.StatusId = 1;
newOrder.DateCreated = DateTime.UtcNow;
List <OrderDetail> orderDetails = new List <OrderDetail>();
foreach (OrderedItemModel orderedItem in normalizedItems)
{
OrderDetail orderDetail = new OrderDetail();
orderDetail.ItemId = orderedItem.ArticleId.Value;
orderDetail.SizeId = orderedItem.SizeId.Value;
orderDetail.ColorId = orderedItem.ColorId;
orderDetail.Quantity = orderedItem.Quantity.Value;
orderDetail.ItemPrice = orderedItem.Price.Value;
orderDetails.Add(orderDetail);
}
OrdersProvider ordersProvider = new OrdersProvider();
int newOrderId = await ordersProvider.SaveOrder(newOrder, orderDetails);
MailSendingFacade mailSender = new MailSendingFacade();
mailSender.SendNewOrderMail(newOrderId);
return(this.Ok(newOrderId));
}
protected void Page_Load(object sender, EventArgs e)
{
if (HLConfigManager.Configurations.DOConfiguration.IsResponsive && (Master as OrderingMaster).IsMobile())
{
//Response.Redirect("~/ordering/PriceList.aspx?ETO=False", false);
}
if (DisplayCCMessage && HLConfigManager.Configurations.DOConfiguration.AllowToDispalyCCMessage)
{
alertNoCC.Visible = true;
imgWarning.Visible = true;
imgWarning.ImageUrl = "~/Ordering/Images/Icons/smallWarningIcon.png";
lblCraditcard.Attributes["class"] = "cc-label";
lblCraditcard.Text = Convert.ToString(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"DisplayCCMessage") ?? "You do not have a valid Credit Card on file.");
lnkSavedCards.Text = Convert.ToString(HttpContext.GetGlobalResourceObject(
string.Format("{0}_ErrorMessage", HLConfigManager.Platform),
"DisplayCCLink") ?? " Click here to enter a new credit card or correct the existing ones");
}
if (!IsPostBack)
{
if (Session["showedAPFPopup"] == null)
{
Session["showedAPFPopup"] = false;
}
if (HLConfigManager.Configurations.DOConfiguration.IsChina)
{
var orders = OrdersProvider.GetOrdersInProcessing(DistributorID, Locale);
if (orders != null && orders.Any())
{
var orderNumber = orders.FirstOrDefault().OrderId;
ViewState["pendingOrderNumber"] = orderNumber;
var isOrderSubmitted = CheckPendingOrderStatus("CN_99BillPaymentGateway", orderNumber);
ViewState["isOrderSubmitted"] = isOrderSubmitted;
if (isOrderSubmitted)
{
lblDupeOrderMessage.Text =
string.Format(GetLocalResourceObject("PendingOrderSubmittedResource").ToString(),
orderNumber);
}
else
{
lblDupeOrderMessage.Text = GetLocalResourceObject("PendingOrderResource.Text") as string;
}
dupeOrderPopupExtender.Show();
divChinaPCMessageBox.Visible = SessionInfo.IsReplacedPcOrder;
}
}
if (Request.QueryString["SKU"] != null)
{
if (Request.QueryString["CMP"] != null)
{
navigateToProductDetailPage(Request.QueryString["SKU"], Request.QueryString["CMP"]);
}
else
{
navigateToProductDetailPage(Request.QueryString["SKU"], null);
}
}
(Master as OrderingMaster).SetPageHeader(GetLocalResourceObject("PageResource1.Title") as string);
// Make sure that a shopping cart exists.
if (ShoppingCart == null)
{
throw new ApplicationException("ShoppingCart is null. Shopping cart value is required.");
}
if (ShoppingCart != null && ShoppingCart.OrderCategory == OrderCategoryType.ETO)
{
(Master as OrderingMaster).SetPageHeader(GetLocalResourceObject("EventTickets.Title") as string);
Page.Title = GetLocalResourceObject("EventTickets.Title") as string;
}
dataBind();
//CatchRedirectedEvent();
DisplayAPFMessage();
SetNqsMessage();
// TODO: Please remove this code
// This is for HFF Modal control testing
//if (HL.MyHerbalife.Providers.ConfigurationManagement.HLConfigManager.Configurations.DOConfiguration.AllowHFFModal && this.ShoppingCart.OrderCategory == OrderCategoryType.RSO)
//{
// var _hFFModal = LoadControl("~/Ordering/Controls/HFFModal.ascx") as HFFModal;
// this.plHFFModal.Controls.Add(_hFFModal);
//}
if (SessionInfo != null && !SessionInfo.IsAPFOrderFromPopUp)
{
SessionInfo.IsAPFOrderFromPopUp = false;
}
var allowedCountries = HL.Common.Configuration.Settings.GetRequiredAppSetting("AllowAPFPopupForStandAloneContries", "CH");
if (!(bool)Session["showedAPFPopup"] && allowedCountries.Contains(Locale.Substring(3)) && (APFDueProvider.IsAPFDueWithinOneYear(DistributorID, Locale.Substring(3)) || APFDueProvider.IsAPFDueAndNotPaid(DistributorID, Locale)))
{
APFDuermndrPopUp.ShowPopUp();
}
if (HLConfigManager.Configurations.AddressingConfiguration.HasAddressRestriction)
{
List <DeliveryOption> shippingAddresses =
(Page as ProductsBase).GetShippingProvider()
.GetShippingAddresses((Page as ProductsBase).DistributorID,
(Page as ProductsBase).Locale)
.Where(s => s.HasAddressRestriction == true)
.ToList();
if (shippingAddresses.Count == 0)
{
AddressResPopUP1.ShowAddressRestrictionPopUp();
}
}
}
else
{
findAndSetFirstRootCategory(IsEventTicketMode);
}
if (null != ShoppingCart && null != ShoppingCart.DeliveryInfo)
{
hfWarehouseCode.Value = string.Format("Warehouse Code : {0}", ShoppingCart.DeliveryInfo.WarehouseCode);
}
DisplayELearningMessage();
if (HLConfigManager.Configurations.DOConfiguration.CheckSKUExpirationDate)
{
ExpireDatePopUp1.ShowPopUp();
}
}
