public IActionResult Index()
{
ViewData["Title"] = "List of orders";
ViewData.Add("Message", $"The numbers of orders is: {StaticDb.Orders.Count}");
ViewData["User"] = StaticDb.Users.First();
List <Order> orders = StaticDb.Orders;
List <OrderDetailsViewModel> orderDetailsViewModels = new List <OrderDetailsViewModel>();
foreach (Order order in orders)
{
//orderDetailsViewModels.Add(new OrderDetailsViewModel
//{
// Id = order.Id,
// PaymentMethod = order.PaymentMethod,
// PizzaName = order.Pizza.Name,
// UserFullName = $"{order.User.FirstName} {order.User.LastName}"
//});
orderDetailsViewModels.Add(OrderMapper.OrderToViewModel(order));
}
return(View(orderDetailsViewModels));
}
public override void Execute(object parameter)
{
// TODO: Step1. Validate
OrderMapper categoryMapper = new OrderMapper();
Order category = categoryMapper.Map(orderAddViewModel.CurrentOrder);
category.Creator = Kernel.CurrentUser;
if (category.Id != 0)
{
DB.OrderRepository.Update(category);
}
else
{
DB.OrderRepository.Add(category);
}
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
orderAddViewModel.CurrentWindow.Close();
}
public IActionResult Index()
{
List <Order> ordersDb = StaticDb.Orders;
List <OrderListViewModel> orderListViewModels = ordersDb
.Select(x => OrderMapper.OrderToOrderListViewModel(x)).ToList();
//List<OrderListViewModel> orderListViewModels = new List<OrderListViewModel>();
//foreach(Order orderDb in ordersDb)
//{
// orderListViewModels.Add(OrderMapper.OrderToOrderListViewModel(orderDb));
//}
//ViewData["Message"] = $"The number of orders is: {ordersDb.Count}";
ViewData["Message"] = StaticDb.Message;
ViewData["Title"] = "Orders list";
ViewData["Date"] = DateTime.Now.ToShortDateString();
ViewData["FirstUser"] = StaticDb.Users.First();
return(View(orderListViewModels));
}
/// <summary>
/// This is the action that returns the view with the form filled with data for editing
/// </summary>
/// <param name="id">id of the order that we want to edit</param>
/// <returns></returns>
public IActionResult EditOrder(int?id)
{
if (id == null)
{
return(View("BadRequest"));
}
Order order = StaticDb.Orders.FirstOrDefault(x => x.Id == id);
if (order == null)
{
return(View("ResourceNotFound"));
}
//we want to send view model to the view
OrderViewModel orderViewModel = OrderMapper.OrderToOrderViewModel(order);
//we have to send the users, so that <option> items are generated in the select list for users
//the right user is bound by mapping the UserId from the view model with the value attribute from the <option> tags
ViewBag.Users = StaticDb.Users.Select(x => UserMapper.ToUserDDViewModel(x));
ViewBag.Pizzas = StaticDb.Pizzas.Select(p => PizzaMapper.ToPizzaDDViewModel(p));
return(View(orderViewModel));
}
public ActionResult Create(PaymentViewModel pvm)
{
pvm.OrderDate = DateTime.Now;
cart = (List <Item>)TempData["cart"];
if (ModelState.IsValid)
{
Payment _payment = PaymentMapper.To_Payment_Create_ViewModel(pvm);
_repository.Create(_payment);
_repository.Save();
List <Order> order = OrderMapper.To_order_Create_Cart(cart, _payment.PaymentID);
foreach (Order ord in order)
{
_repoorder.Create(ord);
_repoorder.Save();
EntitieServices.EntitiProductShop.Product pr = _repositoryproduct.Select(ord.ProductId);
pr.Quantity = pr.Quantity - ord.ProductQuantity;
_repositoryproduct.Save();
}
}
Session["cart"] = null;
return(RedirectToAction("Index", "Products"));
}
public override async Task <Order> FindAsync(params object[] id)
{
var order = await RepositoryDbContext.Set <Domain.Order>().FindAsync(id);
RepositoryDbContext.Entry(order).State = EntityState.Detached;
return(OrderMapper.MapFromDomain(await RepositoryDbSet.Where(a => a.Id == order.Id)
.Include(m => m.Description).ThenInclude(t => t.Translations)
.Include(a => a.Shipper).ThenInclude(aa => aa.ShipperName).ThenInclude(t => t.Translations)
.Include(a => a.Shipper).ThenInclude(aa => aa.ShipperAddress).ThenInclude(t => t.Translations)
.Include(a => a.Shipper).ThenInclude(aa => aa.PhoneNumber).ThenInclude(t => t.Translations)
.Include(a => a.Shop).ThenInclude(aa => aa.ShopName).ThenInclude(t => t.Translations)
.Include(a => a.Shop).ThenInclude(aa => aa.ShopAddress).ThenInclude(t => t.Translations)
.Include(a => a.Shop).ThenInclude(aa => aa.ShopContact).ThenInclude(t => t.Translations)
.Include(a => a.Shop).ThenInclude(aa => aa.ShopContact2).ThenInclude(t => t.Translations)
.Include(a => a.ProductsInOrder).ThenInclude(a => a.Product).ThenInclude(aa => aa.ProductName).ThenInclude(t => t.Translations)
.Include(a => a.ProductsInOrder).ThenInclude(a => a.Product).ThenInclude(aa => aa.Length).ThenInclude(t => t.Translations)
.Include(a => a.ProductsInOrder).ThenInclude(a => a.Product).ThenInclude(aa => aa.Weight).ThenInclude(t => t.Translations)
.Include(a => a.ProductsInOrder).ThenInclude(a => a.Product).ThenInclude(aa => aa.ManuFacturerItemCode).ThenInclude(t => t.Translations)
.Include(a => a.ProductsInOrder).ThenInclude(a => a.Product).ThenInclude(aa => aa.ShopCode).ThenInclude(t => t.Translations)
.FirstOrDefaultAsync()));
}
public void OrderFromStringTest(string row, int id, string name, string abbreviation, decimal taxRate, string productType, decimal area, decimal materialCostPerSquareFoot, decimal laborCostPerSquareFoot, decimal materialCost, decimal laborCost, decimal taxAmt, decimal total)
{
Order actual = OrderMapper.FromString(row);
Product product = new Product
{
ProductType = productType,
CostPerSquareFoot = materialCostPerSquareFoot,
LaborCostPerSquareFoot = laborCostPerSquareFoot,
};
Tax tax = new Tax
{
TaxRate = taxRate,
StateAbbreviation = abbreviation
};
Order expected = new Order()
{
OrderNumber = id,
CustomerName = name,
OrderTax = tax,
OrderProduct = product,
Area = area,
};
Assert.AreEqual(expected.OrderTax.StateAbbreviation, actual.OrderTax.StateAbbreviation);
Assert.AreEqual(expected.OrderTax.TaxRate, actual.OrderTax.TaxRate);
Assert.AreEqual(expected.OrderProduct.ProductType, actual.OrderProduct.ProductType);
Assert.AreEqual(expected.OrderProduct.CostPerSquareFoot, actual.OrderProduct.CostPerSquareFoot);
Assert.AreEqual(expected.OrderProduct.LaborCostPerSquareFoot, actual.OrderProduct.LaborCostPerSquareFoot);
Assert.AreEqual(expected.OrderNumber, actual.OrderNumber);
Assert.AreEqual(expected.CustomerName, actual.CustomerName);
Assert.AreEqual(expected.Area, actual.Area);
Assert.AreEqual(expected.LaborCost, actual.LaborCost);
Assert.AreEqual(expected.MaterialCost, actual.MaterialCost);
Assert.AreEqual(expected.Tax, actual.Tax);
Assert.AreEqual(expected.Total, actual.Total);
}
public static List <Products> LoadProducts()
{
List <Products> products = new List <Products>();
try
{
using (StreamReader sr = new StreamReader("Products.txt"))
{
string row = sr.ReadLine();
while ((row = sr.ReadLine()) != null)
{
Products c = OrderMapper.ToProducts(row);
products.Add(c);
}
}
}
catch (Exception)
{
Console.WriteLine("This is not a valid product type");
}
return(products);
}
/// <summary>
/// Create order
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(OrderCartViewModel model)
{
if (model == null)
{
throw new NullReferenceException();
}
if (model.CartId == null)
{
return(new NotFoundResultModel <Guid>());
}
var cartRequest = await _cartService.GetCartByIdAsync(model.CartId);
if (!cartRequest.IsSuccess)
{
return(cartRequest.Map(Guid.Empty));
}
var cart = cartRequest.Result;
var order = OrderMapper.Map(cart, model.Notes);
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
_commerceContext.CartItems.RemoveRange(cart.CartItems);
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
public IActionResult Details(int?id)
{
if (id == null)
{
return(new EmptyResult());
}
//ViewBag.Message = "You are on the order details page";
ViewBag.Message = StaticDb.Message;
ViewBag.User = StaticDb.Users.First();
//orderDb -> DB
Order orderDb = StaticDb.Orders.FirstOrDefault(x => x.Id == id);
if (orderDb == null)
{
//return new EmptyResult();
return(View("ResourceNotFound")); //first look in Order folder, then in Shared
}
//view model -> data to the view
OrderDetailsViewModel orderDetailsViewModel = OrderMapper.OrderToOrderDetailsViewModel(orderDb);
return(View(orderDetailsViewModel));
}
public IActionResult Details(int?id)
{
ViewBag.User = StaticDb.Users.First(); //if we want to return the user additionally
ViewBag.Title = "Order Details";
if (id == null)
{
//return new EmptyResult();
return(View("BadRequest"));
}
Order order = StaticDb.Orders.FirstOrDefault(x => x.Id == id);
if (order == null)
{
// return new EmptyResult();
return(View("ResourceNotFound"));
}
OrderDetailsViewModel orderDetailsViewModel = OrderMapper.OrderToOrderDetailsViewModel(order);
return(View(orderDetailsViewModel));
}
public void OrderFromStringTest(string row, int id, string name, string abbreviation, decimal taxRate, string productType, decimal area, decimal materialCostPerSquareFoot, decimal laborCostPerSquareFoot, decimal materialCost, decimal LaborCost, decimal Tax, decimal Total)
{
FlooringOrder actual = OrderMapper.ToOrder(row);
//FlooringProduct product = new FlooringProduct
//{
// ProductType = productType,
// CostPerSquareFoot = materialCostPerSquareFoot,
// LaborCostPerSquareFoot = laborCostPerSquareFoot,
//};
//FlooringTax tax = new FlooringTax
//{
// TaxRate = taxRate,
// StateAbbreviation = abbreviation
//};
FlooringOrder expected = new FlooringOrder()
{
OrderNumber = id,
CustomerName = name,
Area = area,
TaxRate = taxRate,
State = abbreviation,
ProductType = productType,
CostPerSquareFoot = materialCostPerSquareFoot,
LaborCostPerSquareFoot = laborCostPerSquareFoot,
};
Assert.AreEqual(expected.State, actual.State);
Assert.AreEqual(expected.TaxRate, actual.TaxRate);
Assert.AreEqual(expected.ProductType, actual.ProductType);
Assert.AreEqual(expected.CostPerSquareFoot, actual.CostPerSquareFoot);
Assert.AreEqual(expected.LaborCostPerSquareFoot, actual.LaborCostPerSquareFoot);
Assert.AreEqual(expected.OrderNumber, actual.OrderNumber);
Assert.AreEqual(expected.CustomerName, actual.CustomerName);
Assert.AreEqual(expected.Area, actual.Area);
Assert.AreEqual(expected.LaborCost, actual.LaborCost);
Assert.AreEqual(expected.MaterialCost, actual.MaterialCost);
Assert.AreEqual(expected.Tax, actual.Tax);
Assert.AreEqual(expected.Total, actual.Total);
}
public async Task <IActionResult> Create([FromBody] Web.Request.ResourceViewModels.Order order)
{
try
{
var model = OrderMapper.MapOrderRequestToDomain(order);
var newOrder = await _orderService.CreateOrder(model);
var response = OrderMapper.MapDomainToOrderResponse(newOrder);
response.Links = new System.Collections.Generic.List <HyperMediaLink>
{
new HyperMediaLink
{
Rel = "self",
Uri = $"http://localhost:52776/api/order/{newOrder.Id}"
},
new HyperMediaLink
{
Rel = "update",
Uri = $"http://localhost:52776/api/order/{newOrder.Id}"
},
new HyperMediaLink
{
Rel = "complete",
Uri = $"http://localhost:52776/api/order/{newOrder.Id}"
}
};
return(Created($"http://localhost:52776/api/order/{newOrder.Id}", response));
}
catch (Exception)
{
return(new ObjectResult("Internal Server Error")
{
StatusCode = StatusCodes.Status500InternalServerError
});
}
}
public void StringToOrderMapperTest(string row, int orderNumber, string customerName, string state, decimal taxRate, string productType, decimal area, decimal costPerFoot, decimal laborPerFoot, decimal material, decimal labor, decimal tax, decimal total)
{
Product product = new Product()
{
ProductType = productType,
CostPerSquareFoot = costPerFoot,
LaborCostPerSquareFoot = laborPerFoot
};
Tax taxes = new Tax()
{
StateAbbreviation = state,
TaxRate = taxRate
};
Order order = new Order()
{
OrderNumber = orderNumber,
CustomerName = customerName,
Area = area,
OrderProduct = product,
OrderTax = taxes
};
Order result = OrderMapper.StringToOrder(row);
Assert.AreEqual(result.OrderNumber, order.OrderNumber);
Assert.AreEqual(result.CustomerName, order.CustomerName);
Assert.AreEqual(result.OrderTax.TaxRate, order.OrderTax.TaxRate);
Assert.AreEqual(result.OrderProduct.ProductType, order.OrderProduct.ProductType);
Assert.AreEqual(result.Area, order.Area);
Assert.AreEqual(result.OrderProduct.CostPerSquareFoot, order.OrderProduct.CostPerSquareFoot);
Assert.AreEqual(result.OrderProduct.LaborCostPerSquareFoot, order.OrderProduct.LaborCostPerSquareFoot);
Assert.AreEqual(result.MaterialCost, order.MaterialCost);
Assert.AreEqual(result.LaborCost, order.LaborCost);
Assert.AreEqual(result.Tax, order.Tax);
Assert.AreEqual(result.Total, order.Total);
}
public ActionResult UpdateOrder(OrderPO form)
{
ActionResult oReponse = RedirectToAction("Index", "Order");
if (ModelState.IsValid)
{
try
{
form.UserID = (Int64)Session["UserID"];
OrdersDO dataObject = OrderMapper.MapPoToDo(form);
dataAccess.UpdateOrder(dataObject);
}
catch (Exception ex)
{
oReponse = View(form);
}
}
else
{
oReponse = View(form);
}
return(oReponse);
}
/// <summary>
/// Create order
/// </summary>
/// <param name="productId"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(Guid?productId)
{
var userRequest = await _userManager.GetCurrentUserAsync();
if (!userRequest.IsSuccess)
{
return(userRequest.Map(Guid.Empty));
}
var productRequest = await _productService.GetProductByIdAsync(productId);
if (!productRequest.IsSuccess)
{
return(productRequest.Map(Guid.Empty));
}
var product = productRequest.Result;
var order = OrderMapper.Map(product);
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
order.UserId = userRequest.Result.Id;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
public IActionResult Details(int id)
{
if (id < 1)
{
return(NotFound());
}
try
{
var employee = (employeeService.GetEmployeeById(id));
var protocols = new List <ProtocolViewModel>();
if (employee.Protocols != null && employee.Protocols.Any())
{
protocols = ProtocolMapper.MapManyToViewModel(employee.Protocols).ToList();
}
var orders = new List <OrderViewModel>();
if (employee.Orders != null && employee.Orders.Any())
{
orders = OrderMapper.MapManyToViewModel(employee.Orders).ToList();
}
var mappedEmployee = EmployeeMapper.MapToViewModel(employee, employee.EmployeesQualifications, protocols, orders);
var result = new EmployeeDetailsViewModel(QualificationMapper.MapManyToViewModel(qualificationService.GetQualifications()).ToList())
{
Employee = mappedEmployee,
};
return(View(result));
}
catch (Exception ex)
{
return(NotFound(ex));
}
}
public MapperTests()
{
lock (sync)
{
if (!configured)
{
Mapper.Reset();
Mapper.Initialize(config =>
{
config.AddProfile(new OrderMappingProfile());
config.AddProfile(new OrderedMealMappingProfile());
config.AddProfile(new RestaurantMappingProfile());
config.AddProfile(new StatusMappingProfile());
config.AddProfile(new OrderViewModelMapperProfile());
});
configured = true;
Mapper.AssertConfigurationIsValid();
}
}
_orderMapper = new OrderMapper();
_orderdedMealMapper = new OrderedMealMapper();
_restaurantMapper = new RestaurantMapper();
_createOrderViewModel = new CreateOrderViewModel();
}
public IActionResult CreateOrder(OrderViewModel orderViewModel)
{
//increment the id in the database
orderViewModel.Id = StaticDb.Orders.Last().Id + 1;
//validate if user with the selected id exists
User userDb = StaticDb.Users.FirstOrDefault(x => x.Id == orderViewModel.UserId);
if (userDb == null)
{
return(View("ResourceNotFound"));
}
//validate if pizza with the entered name exists
Pizza pizzaDb = StaticDb.Pizzas.FirstOrDefault(x => x.Name == orderViewModel.PizzaName);
if (pizzaDb == null)
{
return(View("ResourceNotFound"));
}
//we add only domain models in the database
StaticDb.Orders.Add(OrderMapper.ToOrder(orderViewModel));
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([FromBody] OrderCreateRequest requestModel)
{
DateTime utcNow = DateTime.UtcNow;
//map to entity
Order order = OrderMapper.MapFromOrderCreateRequestToOrder(requestModel, utcNow);
db.Orders.Add(order);
await db.SaveChangesAsync();
Order createdOrder = await db.Orders.IncludeAll().AsNoTracking().SingleOrDefaultAsync(o => o.Id == order.Id);
var filePath = _excelService.CreateAndSaveFile(createdOrder);
if (!string.IsNullOrEmpty(filePath))
{
_emailService.SendEmail(filePath, createdOrder.Category.Name);
}
//map to response
OrderResponse orderResponse = OrderMapper.MapFromOrderToOrderResponse(order);
return(CreatedAtAction(nameof(GetById), new { id = order.Id }, orderResponse));
}
public override void Execute(object parameter)
{
SureDialogViewModel sureViewModel = new SureDialogViewModel();
sureViewModel.DialogText = UIMessages.DeleteSureMessage;
SureDialog dialog = new SureDialog();
dialog.DataContext = sureViewModel;
dialog.ShowDialog();
if (dialog.DialogResult == true)
{
OrderMapper mapper = new OrderMapper();
Order order = mapper.Map(orderViewModel.CurrentOrder);
order.IsDeleted = true;
order.Creator = Kernel.CurrentUser;
DB.OrderRepository.Update(order);
int no = orderViewModel.SelectedOrder.No;
orderViewModel.Orders.Remove(orderViewModel.SelectedOrder);
List <OrderModel> orderModelList = orderViewModel.Orders.ToList();
Enumeration.Enumerate(orderModelList, no - 1);
orderViewModel.AllOrders = orderModelList;
orderViewModel.UpdateDataFiltered();
orderViewModel.SelectedOrder = null;
orderViewModel.CurrentOrder = new OrderModel();
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public OrderPizzaVM GetOrderById(int id)
{
var order = _orderRepo.GetById(id);
return(OrderMapper.OrderToOrderVM(order));
}
public async void CheckoutAsync(Order order)
{
int orderId = await purchaseClient.CreatePurchase(OrderMapper.Map(order)).ConfigureAwait(false);
}
public async Task <string> AddItemToCart(string skuId)
{
var buyer = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (buyer != null)
{
DBContext _context = new DBContext();
OrderModel order = OrderMapper.Mapper(_context.Order.Include(x => x.Buyer).Include(x => x.Seller).Include(x => x.Address).Where(x => x.BuyerId == Guid.Parse(buyer)).FirstOrDefault());
SkuStocksModel stock = StockMapper.Mapper(_context.Stocks.Include(x => x.Seller).Include(x => x.Sku).Where(x => x.SellerId == order.Seller.Id && x.Sku.Id == Guid.Parse(skuId)).FirstOrDefault());
if (stock != null)
{
OrderItemsModel item = OrderItemsMapper.Mapper(_context.OrderItems.Include(x => x.Sku).Include(x => x.Seller).Include(x => x.Order).Where(x => x.SkuId == Guid.Parse(skuId) && x.OrderId == order.Id).FirstOrDefault());
if (item == null)
{
item = new OrderItemsModel();
item.Id = Guid.NewGuid();
item.Seller = order.Seller;
item.Sku = stock.Sku;
item.Order = order;
item.Quantity = 1;
_context.Add(OrderItemsMapper.Mapper(item));
var currentOrder = _context.Order.Find(order.Id);
currentOrder.SubTotal += item.Sku.Price;
currentOrder.Total += item.Sku.Price;
_context.Update(currentOrder);
}
else
{
var currentItem = _context.OrderItems.Find(item.Id);
currentItem.Id = item.Id;
currentItem.OrderId = order.Id;
currentItem.Quantity += 1;
currentItem.SellerId = order.Seller.Id;
currentItem.SkuId = stock.Sku.Id;
_context.Update(currentItem);
var currentOrder = _context.Order.Find(order.Id);
currentOrder.SubTotal += item.Sku.Price;
currentOrder.Total += item.Sku.Price;
_context.Update(currentOrder);
}
var newstock = _context.Stocks.Find(stock.Id);
newstock.Id = stock.Id;
newstock.SellerId = order.Seller.Id;
newstock.SkuId = stock.Sku.Id;
newstock.AvailableQuantity -= 1;
newstock.LastUpdate = DateTime.Now;
_context.Update(newstock);
_context.SaveChanges();
return("OK");
}
return("ESSE PRODUTO NÃO TEM ESTOQUE PARA O LOJISTA SELECIONADO");
}
else
{
return("FAIL");
}
}
public async Task <ActionResult <IEnumerable <PublicApi.v1.DTO.OrderWithProductCount> > > GetOrders(string search, int?pageIndex, int?pageSize)
{
if ((pageIndex != null && pageIndex < 1) || (pageSize != null && pageSize < 1))
{
return(BadRequest());
}
var order = (await _bll.Orders.GetAllByShopDTOAsync(User.GetShopId(), search, pageIndex, pageSize)).Select(e => OrderMapper.MapFromBLL(e)).ToList();
return(order);
}
public void setAddress() //set attr
{
address = OrderMapper.GetOrderAddress(orderID);
}
public void setProductID() //set attr
{
pID = OrderMapper.GetOrderProductID(orderID);
}
public IEnumerable <Order> Get()
{
IEnumerable <OrderEntity> entities = _orderRepository.Get();
return(OrderMapper.MapToModels(entities));
}
public Order Get(string id)
{
OrderEntity order = _orderRepository.Get(id);
return(OrderMapper.MapToModel(order));
}
public void setDate() //set attr
{
OrderDate = OrderMapper.GetOrderDate(orderID);
}
