public ActionResult Create(OrderFormModel model, [DataSourceRequest] DataSourceRequest request)
{
Contract.Requires(model != null);
if (this.ModelState.IsValid)
{
var order = this.OrderRepository.Create();
var orderHistory = this.OrderHistoryRepository.Create();
OrderFormModel.ToData(order, model);
var product = this.ProductRepository.GetQueryable().FirstOrDefault(s => s.Id == model.ProductId);
if (order.Products == null)
{
order.Products = new List <Product>();
}
order.Products.Add(product);
orderHistory.Amount = product.StorageCapacity;
orderHistory.Price = product.Price;
this.OrderHistoryRepository.Insert(orderHistory);
this.OrderRepository.Insert(order);
this.UnityOfWork.Save();
model.Id = order.Id;
}
return(this.JsonNet(new[] { model }.ToDataSourceResult(request, this.ModelState)));
}
public ActionResult Index(OrderFormModel model)
{
if (ModelState.IsValid)
{
Order order = new Order {
Product = model.Product,
ShippingAddress = model.OrderShipping,
EmailAddress = model.OrderEmail,
Quantity = model.OrderQty
};
IOrderService service = new OrderService();
service.ProcessOrder(order);
return(View("Success"));
}
else
{
if (model.Product.Id > 0)
{
IProductService service = new ProductService();
model = new OrderFormModel {
Product = service.GetProduct(model.Product.Id)
};
return(View(model));
}
else
{
return(RedirectToRoute("Default"));
}
}
}
public async Task <IActionResult> FinishOrderConfirm(OrderFormModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var shoppingCartId = this.HttpContext.Session.GetShoppingCartId();
var items = this.shoppingCartManager.GetItems(shoppingCartId);
if (items.Count() == 0)
{
return(BadRequest());
}
var itemsWithDetails = await this.GetCartItems(items);
var userId = this.userManager.GetUserId(User);
await this.orders.CreateOrderAsync(userId, model.Address, itemsWithDetails);
shoppingCartManager.Clear(shoppingCartId);
TempData.AddSuccessMessage($"Your order has been successfully listed!");
return(RedirectToPage("/Orders/UserOrders", new { id = userId }));
}
public ActionResult Edit(int orderId)
{
var order = _orderService.GetOrderById(orderId);
OrderFormModel orderFormModel = Mapper.Map <Order, OrderFormModel>(order);
return(View(model: orderFormModel));
}
//Update the booking table and return the json sending to wms
public SendOrderToWMSModel UpdateOrderPage(OrderFormModel order)
{
Booking getbooking = new Booking();
getbooking = getAllBookings(order.BookingId.ToString());
getbooking.UpdatedDate = DateTime.Now;
getbooking.Shipper.Name = order.ShipperName;
getbooking.Shipper.Address1 = order.ShipperAddress1;
getbooking.Shipper.Address2 = order.ShipperAddress2;
getbooking.Shipper.Contact1 = order.ShipperContactNo;
getbooking.Shipper.Email = order.ShipperEmail;
getbooking.Shipper.UpdatedDate = DateTime.Now;
getbooking.Consignee.Name = order.ConsigneeName;
getbooking.Consignee.Address1 = order.ConsigneeAddress1;
getbooking.Consignee.Address2 = order.ConsigneeAddress2;
getbooking.Consignee.ContactNumber = order.ConsigneeContactNo;
getbooking.Consignee.Email = order.ConsigneeEmail;
getbooking.Consignee.UpdatedDate = DateTime.Now;
__context.Update(getbooking);
__context.SaveChanges();
SendOrderToWMSModel sendDataToWMSModel = new SendOrderToWMSModel();
sendDataToWMSModel = SendOrderDataToWMS(order, order.BookingId);
return(sendDataToWMSModel);
}
public IActionResult UpdateOrderForm([FromBody] OrderFormModel orderdata)
{
if (ModelState.IsValid)
{
SendOrderToWMSModel sendBackToWMS = new SendOrderToWMSModel();
sendBackToWMS = _dataAccessProvider.UpdateOrderPage(orderdata);
return(Ok(sendBackToWMS));
}
return(BadRequest(ModelState));
}
public ActionResult Index(int id)
{
ViewBag.Title = "Place Your Order";
IProductService service = new ProductService();
OrderFormModel model = new OrderFormModel {
Product = service.GetProduct(id)
};
return(View(model));
}
public IActionResult Index()
{
_logger.LogDebug("Index loaded");
var viewModel = new OrderFormModel {
Districts = District.StandardDistricts.Select(
d => new SelectListItem {
Value = d.ToLower(),
Text = d
})
};
return(View(viewModel));
}
public ActionResult Edit(OrderFormModel newOrder, bool continueEditing)
{
if (ModelState.IsValid)
{
var order = Mapper.Map <OrderFormModel, Order>(newOrder);
_orderService.EditOrder(order);
return(continueEditing ? RedirectToAction("Edit", "Order", new { id = order.Id })
: RedirectToAction("Index", "Order"));
}
else
{
return(View("Edit", newOrder));
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
var key = this.HttpContext.Session.GetShopingCartKey();
var items = this.shoppingCartManager.GetAllCartItems(key);
var allBooksInCurrentShoppingCart = this.bookService.GetBooksInCurrentShoppingCart(items);
var model = new OrderFormModel
{
UserInfo = this.userService.GetUserModelForForm(this.User.Identity.Name),
BooksInfo = allBooksInCurrentShoppingCart
};
return(View(model));
}
public SendOrderToWMSModel SendOrderDataToWMS(OrderFormModel orderFormModel, Guid bookId)
{
SendOrderToWMSModel sendOrderToWms = new SendOrderToWMSModel();
OrderInfoModel orderInfo = new OrderInfoModel();
sendOrderToWms.BookingId = bookId;
sendOrderToWms.CompletionDate = orderFormModel.CompletionDate;
sendOrderToWms.CompletionTime = orderFormModel.CompletionTime;
orderInfo.Remarks = orderFormModel.Remarks;
orderInfo.OrderItems = orderFormModel.orderItems;
sendOrderToWms.OrderInfo = orderInfo;
return(sendOrderToWms);
}
public ActionResult Delete([DataSourceRequest] DataSourceRequest request, OrderFormModel model)
{
Contract.Requires(model != null);
var order = this.OrderRepository.GetQueryable().SingleOrDefault(s => s.Id == model.Id);
if (order == null)
{
throw new NullReferenceException("Objednavka nenalezena.");
}
this.OrderRepository.Delete(order);
this.UnityOfWork.Save();
return(this.JsonNet(new[] { model }.ToDataSourceResult(request, this.ModelState)));
}
public IActionResult CreateOrderDetail([FromBody] OrderFormModel orderdata)
{
BookingModel bookingModel = new BookingModel();
Consignee consignee = new Consignee();
Shipper shipper = new Shipper();
if (ModelState.IsValid)
{
Guid bookingobj = Guid.NewGuid();
Guid consigneeobj = Guid.NewGuid();
Guid shipperobj = Guid.NewGuid();
bookingModel.BookingId = bookingobj;
consignee.ConsigneeId = consigneeobj;
shipper.ShipperId = shipperobj;
shipper.Name = orderdata.ShipperName;
shipper.Address1 = orderdata.ShipperAddress1;
shipper.Address2 = orderdata.ShipperAddress2;
shipper.Contact1 = orderdata.ShipperContactNo;
shipper.Email = orderdata.ShipperEmail;
consignee.Name = orderdata.ConsigneeName;
consignee.Address1 = orderdata.ConsigneeAddress1;
consignee.Address2 = orderdata.ConsigneeAddress2;
consignee.ContactNumber = orderdata.ConsigneeContactNo;
consignee.Email = orderdata.ConsigneeEmail;
bookingModel.CreatedDate = DateTime.Now;
bookingModel.UpdatedDate = DateTime.Now;
consignee.CreatedDate = DateTime.Now;
consignee.UpdatedDate = DateTime.Now;
shipper.CreatedDate = DateTime.Now;
shipper.UpdatedDate = DateTime.Now;
bookingModel.ClientId = orderdata.ClientId;
bookingModel.CreatedBy = "User";
consignee.CreatedBy = "User";
shipper.CreatedBy = "User";
bookingModel.Consignee = consignee;
bookingModel.Shipper = shipper;
_dataAccessProvider.AddOrderDetails(bookingModel.Consignee, bookingModel.Shipper, bookingModel);
SendOrderToWMSModel sendOrderToWMS = new SendOrderToWMSModel();
sendOrderToWMS = _dataAccessProvider.SendOrderDataToWMS(orderdata, bookingobj);
return(Ok(sendOrderToWMS));
}
return(BadRequest(ModelState));
}
public IActionResult FinishOrder(OrderFormModel model)
{
var shoppingCartId = this.HttpContext.Session.GetShoppingCartId();
var items = this.shoppingCartManager.GetItems(shoppingCartId);
if (!items.Any())
{
TempData.AddErrorMessage("За да направите покупка, първо добавете продукти в количката.");
return(RedirectToAction("Items", nameof(ShoppingCart)));
}
var userId = this.userManager.GetUserId(User);
this.orders.Create(model.Address, model.Comment, items, userId);
shoppingCartManager.Clear(shoppingCartId);
TempData.AddSuccessMessage("Успешна покупка.");
return(RedirectToAction("List"));
}
public ActionResult Update([DataSourceRequest] DataSourceRequest request, OrderFormModel model)
{
Contract.Requires(model != null);
if (this.ModelState.IsValid)
{
var order = this.OrderRepository.GetById(model.Id);
if (order == null)
{
throw new Exception("Objednávka nenalezen.");
}
OrderFormModel.ToData(order, model);
this.OrderRepository.Update(order);
this.UnityOfWork.Save();
}
return(this.JsonNet(new[] { model }.ToDataSourceResult(request, this.ModelState)));
}
public async Task <ActionResult> SellOrder(OrderFormModel orderFormModel, FormCollection collection)
{
if (ModelState.IsValid)
{
orderFormModel.ECurrency = collection["ECurrency"] + "";
orderFormModel.AmountUSD = collection["AmountUSD"] + "";
orderFormModel.AmountNaira = collection["AmountNaira"] + "";
orderFormModel.AccountName = collection["AccountName"] + "";
orderFormModel.WalletAddress = collection["WalletAddress"] + "";
orderFormModel.BankName = collection["BankName"] + "";
orderFormModel.PaymentMethod = collection["PaymentMethod"] + "";
orderFormModel.FullName = collection["FullName"] + "";
orderFormModel.Email = collection["Email"] + "";
orderFormModel.PhoneNo = collection["PhoneNo"] + "";
string notifyMessage = "<p>New Sell Order Form Has Been Submitted:</p>"
+ "<p>=======================================</p>"
+ "<p>Submitted by: " + orderFormModel.FullName + "</p>"
+ "<p>Email: " + orderFormModel.Email + "</p>"
+ "<p>E-Currency: " + orderFormModel.ECurrency + "</p>"
+ "<p>Amount in USD: " + orderFormModel.AmountUSD + "</p>"
+ "<p>Amount in Naira: " + orderFormModel.AmountNaira + "</p>"
+ "<p>Account Name: " + orderFormModel.AccountName + "</p>"
+ "<p>Wallet Address: " + orderFormModel.WalletAddress + "</p>"
+ "<p>Bank Name: " + orderFormModel.BankName + "</p>"
+ "<p>Payment Method: " + orderFormModel.PaymentMethod + "</p>"
+ "<p>===============================================</p>";
await SendNotification(notifyMessage, orderFormModel.Email, "*****@*****.**");
return(RedirectToAction("Index", "Home"));
}
ViewBag.Message = "Your SellOrder description page.";
return(View(orderFormModel));
}
/// <summary>
/// The read.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// The <see cref="ActionResult"/>.
/// </returns>
public ActionResult Read([DataSourceRequest] DataSourceRequest request)
{
var productItems = this.OrderRepository.GetQueryable().Select(OrderFormModel.ToModel());
return(this.Json(productItems.ToDataSourceResult(request), JsonRequestBehavior.AllowGet));
}
public Task <string> PlaceOrder(OrderFormModel orderForm)
{
return(Task.FromResult(Guid.NewGuid().ToString()));
}
public async Task <string> PlaceOrder(OrderFormModel orderForm)
{
var orderNumber = await HttpClient.GetStringAsync($"api/Checkout/{orderForm}");
return(orderNumber);
}
public CheckoutService(ICartService cartService)
{
CartService = cartService;
OrderForm = new OrderFormModel();
}
public ActionResult Create()
{
var order = new OrderFormModel();
return(View(order));
}
