public async Task <IActionResult> CreateOrder([FromBody] CreateOrderViewModel order)
{
if (order == null)
{
return(Json(BadRequest()));
}
var orderItem = mapper.mapOrder(order);
string orderId = orderItem.Id;
await orderRepository.Add(orderItem);
foreach (var product in order.productList)
{
var productItem = await productRepository.Get(product.productId);
await productService.changeStock(product.productId, product.quantity, Constants.REDUCE,
productRepository);
var detailsItem = mapper.mapOrderDetails(productItem, product, orderId);
await orderDetailsRepository.Add(detailsItem);
}
orderService.SendOrderConfirmation(order, productRepository, orderItem.Id);
return(Json(Ok(orderItem)));
}
public async Task <IActionResult> Create([Bind("OrderId,ProductId,Quantity,Price,TotalProductPrice")] OrderDetails orderDetails)
{
if (ModelState.IsValid)
{
orderDetails.TotalProductPrice = orderDetails.Price * orderDetails.Quantity;
await orderDetailsRepository.Add(orderDetails);
return(RedirectToAction("Details", new { id = orderDetails.OrderId }));
}
ViewData["OrderId"] = new SelectList(_context.Order, "Id", "Id", orderDetails.OrderId);
ViewData["ProductId"] = new SelectList(_context.Product, "Id", "Id", orderDetails.ProductId);
return(View(orderDetails));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
OrderDetails.TotalProductPrice = OrderDetails.Price * OrderDetails.Quantity;
await orderDetailsRepository.Add(OrderDetails);
return(RedirectToPage("./Index", new { id = parameterId }));
}
private void SaveModels(Quotation quotationLocal)
{
_quotationRepository.Add(quotationLocal);
_orderDetailsRepository.Add(_OrderAndOrderDetailsVM.OrderDetailsModel);
_orderRepository.Add(_OrderAndOrderDetailsVM.OrderModel);
try
{
_queries.SaveChanges();
}
catch (Exception ex)
{
}
}
public ResponseModel <Orders> CreateOrder(int customerId, List <ShoppingCart> shoppingCarts)
{
decimal totalAmount = 0;
foreach (ShoppingCart item in shoppingCarts)
{
Product product = _productRepository.FindById(item.ProductId);
totalAmount += product.Price * item.Quantity;
}
Orders order = new Orders
{
CustomerId = customerId,
OrderDate = DateTime.Now,
PaymentTypeId = (int)PaymentType.KrediKarti,
StatusId = (int)Status.Kabul,
TotalAmount = totalAmount,
ApprovedDate = DateTime.Now,
ApprovedById = 1
};
_ordersRepository.Add(order);
List <OrderDetails> orderDetails = shoppingCarts.Select(x => new OrderDetails
{
Count = x.Quantity,
OrderId = order.Id,
ProductId = x.ProductId
}).ToList();
foreach (OrderDetails item in orderDetails)
{
_orderDetailsRepository.Add(item);
Product product = _productRepository.FindById(item.ProductId);
product.StockQuantity = product.StockQuantity - item.Count;
_productRepository.Update(product);
}
_unitOfWork.Complete();
return(new ResponseModel <Orders>
{
IsSuccess = true,
Message = "Siparişiniz başarıyla alınmıştır",
Model = order
});
}
public IActionResult Checkout(cartVM CartVM)
{
if (ModelState.IsValid)
{
Product product = new Product();
List <Item> cart = new List <Item>();
cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart");
CartVM.OrderHeader.OrderDate = DateTime.Now;
CartVM.OrderHeader.Status = "Submitted";
foreach (var item in cart)
{
CartVM.OrderHeader.OrderTotal += (item.Product.Price * item.Quantity);
}
var userId = _userManager.GetUserId(this.User);
CartVM.OrderHeader.UserId = userId;
_iOrderH.Add(CartVM.OrderHeader);
foreach (var item in cart)
{
product = _iProd.GetFirstOrDefault(item.Product.Id);
OrderDetails orderDetails = new OrderDetails
{
OrderHeaderId = CartVM.OrderHeader.Id,
ProductId = item.Product.Id,
ProductQuantity = item.Quantity,
ProductName = item.Product.Name,
ProductPrice = (item.Product.Price * item.Quantity)
};
product.Quantity = product.Quantity - item.Quantity;
_iProd.Update(product);
_iOrderD.Add(orderDetails);
}
cart.Clear();
SessionHelper.SetObjectAsJson(HttpContext.Session, "cart", cart);
return(RedirectToAction("OrderConfirmation", "Cart", new { id = CartVM.OrderHeader.Id }));
}
return(View(nameof(Index)));
}
public Order Create(ref Order order, List <OrderDetail> orderDetails)
{
try
{
_orderRepository.Add(order);
_unitOfwork.Commit();
foreach (var orderDetail in orderDetails)
{
orderDetail.OrderID = order.OrderID;
_orderDetailRepository.Add(orderDetail);
}
return(order);
}
catch (Exception ex)
{
throw;
}
}
public bool Checkout(Order order)
{
var listCart = _cartRepository.GetCart(order.CustomerID);
order.OrderStatusId = _orderStatusRepository.GetByName("Pending").Id;
if (listCart.Count == 0)
{
return(false);
}
_orderRepository.Add(order);
if (!_orderRepository.Save())
{
return(false);
}
decimal totalCost = 0;
foreach (var cart in listCart)
{
var menuItem = _menuItemRepository.Get(cart.MenuItemId.Value);
var orderDetail = new OrderDetail()
{
OrderId = order.Id,
MenuItemId = menuItem.Id,
UnitCost = menuItem.Price.Value,
Quantity = cart.Count.Value,
};
totalCost += menuItem.Price.Value * cart.Count.Value;
_cartRepository.Delete(cart);
_orderDetailsRepository.Add(orderDetail);
}
order.Total = totalCost;
_cartRepository.Save();
_orderDetailsRepository.Save();
order.Total = totalCost;
return(_orderRepository.Update(order));
}
public IActionResult PostNewOrders([FromBody] PostManageOrdersVM _pmovm)
{
List <string> serviceIdList = _pmovm.idService.Split(',').ToList();
foreach (var serviceId in serviceIdList)
{
OrderDetails _OrderDetailsNueva = new OrderDetails();
var quotationLocal = new Quotation();
quotationLocal.Tasks = new List <TaskModel>();
_OrderDetailsNueva.Order = _queries.GetOrderByOrderId(_pmovm.orderId);
Guid id = Guid.Parse(serviceId);
_OrderDetailsNueva.Service = _queries.GetServiceFirstOrDefault(id);
var quotation = _queries.GetQuotationIncludeOrderTaskListMaterialWhereOrderIdEqualsOrderId(_pmovm.orderId);
var pics = _queries.GetQuotationIncludeOrderDetailsOrderTaskPicturesFirstOrDefaultWhereOrderIdEquals(_pmovm.orderId);
for (int i = 0; i < quotation.Tasks.Count; i++)
{
var _taskLocal = new TaskModel();
for (int f = 0; f < quotation.Tasks[i].ListMaterial.Count; f++)
{
if (_taskLocal.ListMaterial == null)
{
_taskLocal.ListMaterial = new List <Material>();
}
var mat = new Material();
mat.Description = quotation.Tasks[i].ListMaterial[f].Description;
mat.Name = quotation.Tasks[i].ListMaterial[f].Name;
mat.Price = 0;
_taskLocal.ListMaterial.Add(mat);
}
if (_taskLocal.Pictures == null)
{
_taskLocal.Pictures = new List <Picture>();
}
for (int e = 0; e < pics.Tasks[i].Pictures.Count; e++)
{
var picLocal = new Picture();
picLocal.PictureBytes = pics.Tasks[i].Pictures[e].PictureBytes;
picLocal.Tipo = PictureTypeEnum.Quotation;
_taskLocal.Pictures.Add(picLocal);
}
_taskLocal.Name = quotation.Tasks[i].Name;
_taskLocal.Duration = quotation.Tasks[i].Duration;
_taskLocal.Description = quotation.Tasks[i].Description;
quotationLocal.Tasks.Add(_taskLocal);
}
quotationLocal.Description = quotation.Description;
quotationLocal.OrderDetails = _OrderDetailsNueva;
quotationLocal.ProviderArrivalDate = DateTime.Now;
_OrderDetailsNueva.Status = SD.EstadoCotizando;
_quoationRepository.Add(quotationLocal);
_orderDetailsRepository.Add(_OrderDetailsNueva);
}
try
{
_queries.SaveChanges();
}
catch (Exception ex)
{
}
return(Ok());
}
public void Save(OrderDetails orderDetails)
{
_orderDetailsRepository.Add(orderDetails);
_unitOfWork.Complete();
}
public async Task <IActionResult> SummaryPost(IFormCollection collection, ProductUserViewModel ProductUserVM)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (User.IsInRole(MC.AdminRole))
{
//create order.
OrderHeader orderheader = new OrderHeader()
{
CreatedByUserId = claim.Value,
FinalOrderTotal = ProductUserViewModel.ProductList.Sum(x => x.TempSqFT * x.Price),
City = ProductUserViewModel.ApplicationUser.City,
StreetAddress = ProductUserViewModel.ApplicationUser.StreetAddress,
State = ProductUserViewModel.ApplicationUser.State,
PostalCode = ProductUserViewModel.ApplicationUser.Postal,
FullName = ProductUserViewModel.ApplicationUser.FullName,
Email = ProductUserViewModel.ApplicationUser.Email,
PhoneNumber = ProductUserViewModel.ApplicationUser.PhoneNumber,
OrderDate = DateTime.Now,
OrderStatus = MC.StatusPending
};
_order_header_repo.Add(orderheader);
_order_header_repo.Save();
foreach (var prod in ProductUserVM.ProductList)
{
OrderDetail orderDetail = new OrderDetail()
{
OrderHeaderId = orderheader.Id,
PricePerSqFt = prod.Price,
Sqft = prod.TempSqFT,
ProductId = prod.Id
};
_order_details_repo.Add(orderDetail);
}
_order_details_repo.Save();
string nonceFromTheClient = collection["payment_method_nonce"];
var request = new TransactionRequest
{
Amount = Convert.ToDecimal(orderheader.FinalOrderTotal),
PaymentMethodNonce = nonceFromTheClient,
OrderId = orderheader.Id.ToString(),
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
}
};
var gateway = _brain.GetGateWay();
Result <Transaction> result = gateway.Transaction.Sale(request);
if (result.Target.ProcessorResponseText == "Approved")
{
orderheader.TransactionId = result.Target.Id;
orderheader.OrderStatus = MC.StatusApproved;
}
else
{
orderheader.OrderStatus = MC.StatusCancelled;
}
_order_header_repo.Save();
return(RedirectToAction(nameof(InquiryConfirmation), new { id = orderheader.Id }));
}
else
{
//create inquiry.
var PathToTemplate = _webHostEnvironment.WebRootPath + Path.DirectorySeparatorChar.ToString() + "Templates" + Path.DirectorySeparatorChar.ToString()
+ "Inquiry.html";
var subject = "New Inquiry";
string HtmlBody = "";
using (StreamReader sr = System.IO.File.OpenText(PathToTemplate))
{
HtmlBody = sr.ReadToEnd();
}
StringBuilder productListSB = new StringBuilder();
foreach (var prod in ProductUserViewModel.ProductList)
{
productListSB.Append($" - Name: {prod.Name} <span style='font-size:14px;'> (ID: {prod.Id})</span><br/>");
}
string messageBdy = string.Format(HtmlBody,
ProductUserVM.ApplicationUser.FullName,
ProductUserVM.ApplicationUser.Email,
ProductUserVM.ApplicationUser.PhoneNumber,
productListSB.ToString());
await _emailSender.SendEmailAsync(MC.EmailAdmin, subject, messageBdy);
InquiryHeader inquiryHeader = new InquiryHeader()
{
ApplicationUserId = claim.Value,
FullName = ProductUserVM.ApplicationUser.FullName,
Email = ProductUserVM.ApplicationUser.Email,
PhhoneNumber = ProductUserVM.ApplicationUser.PhoneNumber,
InquiryDate = DateTime.Now
};
_headerRepo.Add(inquiryHeader);
_headerRepo.Save();
foreach (var prod in ProductUserVM.ProductList)
{
InquiryDetails inquiryDetail = new InquiryDetails()
{
InquiryHeaderId = inquiryHeader.Id,
ProductId = prod.Id
};
_detailRepo.Add(inquiryDetail);
}
TempData[MC.Success] = "Inquiry Sent Successfully";
_detailRepo.Save();
return(RedirectToAction(nameof(InquiryConfirmation)));
}
}
