public IActionResult Index()
{
//Checking if the user is a guest or not. If hes not a guest, he will create a temp OrderId and store it in the cookies
//If the user is authenticated, an OrderId will be created, only if the user doesnt have an order which is currently open
if (!HttpContext.User.Identity.IsAuthenticated)
{
if (HttpContext.Request.Cookies["tempOrder_id"] == null)
{
var orderId = Guid.NewGuid();
string test = Convert.ToString(orderId);
CookieOptions cookie = new CookieOptions();
cookie.Expires = DateTime.Now.AddDays(7);
Response.Cookies.Append("tempOrder_id", test, cookie);
}
else
{
return(View());
}
}
else
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
Guid GuidUserId = Guid.Empty;
Guid.TryParse(userId, out GuidUserId);
_ordersService.AddOrder(GuidUserId);
}
return(View());
}
public IActionResult addOrder(Guid id)
{
var product = _productsService.GetProduct(id);
CreateOrderModel model = new CreateOrderModel();
model.Order = new OrderViewModel();
model.Order.Id = Guid.NewGuid();
model.Order.DatePlaced = DateTime.Now;
model.Order.MemberEmail = User.Identity.Name;
model.OrderDetails = new OrderDetailsViewModel();
model.OrderDetails.Id = Guid.NewGuid();
model.OrderDetails.Price = product.Price;
model.OrderDetails.ProductFk = product.Id;
model.OrderDetails.OrderFk = model.Order.Id;
model.OrderDetails.Quantity = 1;
try {
_ordersService.AddOrder(model.Order, model.OrderDetails);
TempData["feedback"] = "Order was added successfully";
ModelState.Clear();
} catch {
TempData["warning"] = "Order was not added. Check your details";
return(RedirectToAction("Error", "Home"));
}
return(RedirectToAction("Index", "Products"));
}
public async Task Post([FromBody] OrderEditModel value)
{
var order = AutoMapper.Mapper.Map <OrderEditModel, OrderDto>(value);
order.UserFirstName = User.Identity.Name;
await _service.AddOrder(order);
}
public IActionResult RescueProducts([FromBody] Orders orders)
{
var userPoints = _pointsService.GetPointsByUserId(orders.UserId);
var product = _productsAppService.GetById(orders.ProductId);
if (userPoints.TotalPoints < product.RescuePoints)
{
return(BadRequest("O saldo de pontos é menor que o total de pontos do produto"));
}
var userExtract = new UserExtract
{
InitialPoints = userPoints.TotalPoints,
PointsBalance = userPoints.TotalPoints - product.RescuePoints,
TransactionDate = DateTime.Now.Date,
TransactionPoints = product.RescuePoints,
TransactionType = Domain.Enums.TransactionTypeEnum.Output,
UserId = orders.UserId
};
orders.CreatedAt = DateTime.Now.Date;
_userExtractService.AddUserExtract(userExtract);
_ordersService.AddOrder(orders);
return(Ok(orders));
}
public IActionResult Pay()
{
try {
List <ProductViewModel> products = GetProducts();
DateTime datePlaced = DateTime.Now;
string email = User.Identity.Name;
//create order
OrderViewModel order = new OrderViewModel();
order.DatePlaced = datePlaced;
order.UserEmail = email;
order.Id = _ordersService.AddOrder(order);
foreach (var item in products)
{
OrderDetailsViewModel orderDetailsViewModel = new OrderDetailsViewModel();
orderDetailsViewModel.Order = _mapper.Map <Order>(order);
orderDetailsViewModel.Product = _mapper.Map <Product>(item);
orderDetailsViewModel.Price = item.Price;
orderDetailsViewModel.Quantity = item.Quantity;
_orderDetailsService.AddOrderDetails(orderDetailsViewModel);
}
HttpContext.Session.SetString(SessionKeyName, "");
TempData["feedback"] = ("Payment was successful");
_logger.LogInformation("User payed successfully");
}
catch (Exception e)
{
TempData["error"] = ("Error occured while paying! We will look into it!");
_logger.LogError("Error occurred " + e.Message);
return(RedirectToAction("Error", "Home"));
}
return(RedirectToAction("Index"));
}
public ActionResult <GetOrderModel> PostOrder([FromBody] PostOrderModel postOrderModel)
{
Order order = _mapper.Map <PostOrderModel, Order>(postOrderModel);
Order addedOrder;
try {
addedOrder = _service.AddOrder(order);
} catch (RequestException ex) {
if (ex.Code == OrderExceptionCodes.RestaurantNotFound)
{
return(NotFound(new{ message = "Restaurant id does not exist" }));
}
if (ex.Code == OrderExceptionCodes.ProductNotFound)
{
return(NotFound(new{ message = "Product id does not exist" }));
}
if (ex.Code == OrderExceptionCodes.ProductNotBelongingToRestaurant)
{
return(BadRequest(new{ message = "Product is not from restaurant" }));
}
if (ex.Code == OrderExceptionCodes.BadOrderProduct)
{
return(BadRequest(new{ message = "Bad OrderProduct data" }));
}
return(BadRequest(new{ message = "Unknown error" }));
}
return(Ok(_mapper.Map <Order, GetOrderModel>(addedOrder)));
}
public async Task <IActionResult> IndexAsync()
{
var cart = _cart.GetCart(Request);
if (cart.Items.Count < 1)
{
return(Redirect("/"));
}
OrderInfoRequest orderInfo = new OrderInfoRequest();
orderInfo.CustomerId = Int32.Parse(User.Claims.Where(c => c.Type == "UserId").First().Value);
cart.Items.ForEach(cartItem =>
{
orderInfo.Items.Add(new Item {
ProductId = cartItem.ProductId, Quantity = cartItem.Quantity
});
});
var(statusCode, result) = await _order.AddOrder(orderInfo);
if (result == null)
{
ViewData["OrderError"] = "ERROR!!!";
return(View());
}
ViewData["OrderResult"] = result;
_cart.ClearCartCookie(Response);
return(View());
}
public ActionResult AddOrder(AddOrderViewModel AddOrder)
{
OrderViewModel order = new OrderViewModel()
{
CustomerID = AddOrder.CustomerID,
EmployeeID = AddOrder.EmployeeID,
OrderDate = DateTime.Now,
RequiredDate = DateTime.Now.AddDays(7),
ShippedDate = DateTime.Now.AddDays(2),
Freight = 20,
ShipName = _shipper.GetShippers().Where(c => c.ShipperID == AddOrder.ShipperID).FirstOrDefault().CompanyName,
ORDER_DETAILS = new List <OrderDetailViewModel>(new OrderDetailViewModel[] {
new OrderDetailViewModel()
{
ProductID = AddOrder.ProductID,
Quantity = AddOrder.Quantity,
UnitPrice = AddOrder.UnitPrice,
Discount = 1
}
})
};
int result = _order.AddOrder(order);
if (result > 0)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
return(View());
}
public IActionResult PurchaseOrder(Guid orderId)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
Guid GuidUserId = Guid.Empty;
Guid.TryParse(userId, out GuidUserId);
var cookieOrderId = HttpContext.Request.Cookies["tempOrder_id"];
Guid GuidCookieOrderId = Guid.Empty;
Guid.TryParse(cookieOrderId, out GuidCookieOrderId);
try
{
_ordersService.CloseOrder(orderId, GuidUserId);
_ordersService.AddOrder(GuidUserId);
if (orderId == GuidCookieOrderId)
{
Response.Cookies.Delete("tempOrder_id");
}
TempData["Success"] = "Your Order Has been Successfully Checked Out.";
}
catch (Exception ex)
{
TempData["Warning"] = ex.Message;
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Post([FromForm] OrderDTO orderDTO)
{
try
{
await _ordersService.AddOrder(orderDTO);
return(Ok("Order record added successfully"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> AddOrder(int ticketId)
{
var ticket = await ticketsService.GetTicketById(ticketId);
await ticketsService.ChangeTicketStatus(ticket, TicketStatuses.WaitingForConfirmation);
await ordersService.AddOrder(new Order
{
TicketId = ticket.Id,
Status = (int)OrderStatuses.WaitingForConfirmation,
UserId = userManager.GetUserId(User)
});
return(View("InstructionOrderAdded"));
}
public IActionResult checkout(OrderViewModel data, Guid ordid, Guid prodId, string email)
{
try
{
email = User.Identity.Name;
_ordersService.AddOrder(data, email);
_orderDetailsService.AddOrderDetails(ordid, prodId, email);
TempData["feedback"] = "Checking out succesful"; //change wherever we are using viewdata to use tempdata
return(RedirectToAction("Index"));
}
catch (Exception)
{
return(RedirectToAction("Error", "home"));
}
}
public async Task <Order> CreateOrder(CreateOrderInput createOrderInput)
{
try
{
Order _order = await _ordersService.AddOrder(createOrderInput);
return(_order);
}
catch (Exception ex)
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage(ex.Message)
.SetCode("CREATE_ERROR")
.Build());
}
}
public ActionResult <Order> AddOrder([FromBody] Order order)
{
return(OrdersService.AddOrder(order));
}
public IActionResult FastOrder(Guid id, string firstName, string lastName, string phoneNumber)
{
bool isDataValid = this.ValidateFastOrderData(firstName, lastName, phoneNumber);
if (!isDataValid)
{
return(BadRequest());
}
Order myOrder = new Order()
{
OrderDate = DateTime.UtcNow.AddHours(+2),
OrderStatus = OrderStatus.Confirmed
};
ordersService.AddOrder(myOrder);
Product product = productsService.GetById(id);
OrderItem item = new OrderItem()
{
ProductId = product.Id,
Quantity = 1,
UnitPrice = product.Price,
SubTotal = product.Price
};
myOrder.OrderItems.Add(item);
myOrder.PaymentMethod = PaymentMethod.PayToCourier;
myOrder.ShippingMethod = ShippingMethod.ToAddress;
myOrder.TotalAmountInclTax = item.SubTotal;
myOrder.TotalAmountExclTax = Math.Round(myOrder.TotalAmountInclTax / Constants.TaxAmount, 2);
myOrder.TaxAmount = myOrder.TotalAmountInclTax - myOrder.TotalAmountExclTax;
if (myOrder.TotalAmountInclTax < Constants.MinPriceFreeShipping)
{
myOrder.ShippingTax = Constants.ShippingTax;
}
else
{
myOrder.ShippingTax = 0m;
}
ShortContactInfo contactInfo = new ShortContactInfo();
contactInfo.FirstName = firstName;
contactInfo.LastName = lastName;
contactInfo.PhoneNumber = phoneNumber;
ShortContactInfo newInfo = new ShortContactInfo()
{
FirstName = firstName,
LastName = lastName,
PhoneNumber = phoneNumber
};
newInfo.Orders.Add(myOrder);
shortContactInfoService.Add(newInfo);
ordersService.Update(myOrder);
return(RedirectToAction("ShortOrderCompleted"));
}
public async Task <IActionResult> AddOrder([FromBody] DTO.Order order)
{
var result = await ordersService.AddOrder(order);
return(Ok(result));
}
public async Task <IActionResult> AddOrder(AddOrderDto newOrder)
{
return(Ok(await _orderService.AddOrder(newOrder)));
}
public Task AddOrder(NewOrderDto order)
{
order.PersonId = GetPersonId();
return(_ordersService.AddOrder(order, HttpContext.RequestAborted));
}
public OrderDto PostOrder(OrderDto newOrder, int userId)
{
return(_ordersService.AddOrder(newOrder, userId));
}
public IActionResult Checkout()
{
try
{
var n = _cartService.GetItems().Where(x => x.Email == User.Identity.Name).FirstOrDefault();
//var ord = _ordersService.GetOrder(User.Identity.Name);
var email = User.Identity.Name;
//getcart id
//var cart = _productsService.GetProduct(id);
//var cartId= GetCart(); implmement
var order = new OrderViewModel()
{
UserEmail = email,
DatePlaced = DateTime.Now
};
_ordersService.AddOrder(order);
/*
* var orderid = _ordersService.GetOrder(email).Id;
*
* foreach (var x in n.CartItems)
* {
* var orderDetails = new OrderDetailsViewModel()
* {
* Price = x.Product.Price,
* Quantity = x.Quantity,
* ProductFk = x.Product.Id,
* OrderId = order.Id
* };
* _orderDetailsService.AddOrderDetails(orderDetails);
* }
*/
TempData["feedback"] = "Order was added successfully";
}
catch (Exception ex)
{
//log error
TempData["warning"] = "Order was not added! " + ex;
return(RedirectToAction("error", "Home"));
}
return(RedirectToAction("Index", "Products"));
/*
* if (_ordersService.Checkout(User.Identity.Name))
* {
* TempData["feedback"] = "Your order was created";
* //empty cart
* return RedirectToAction("Index", "Products");
* }
* else
* {
* TempData["feedback"] = "Something went wrong with your order!";
* return RedirectToAction("Index", "Products");
* }
*/
}
