public AddOrderWindow()
{
InitializeComponent();
viewModel = new AddOrderViewModel();
viewModel.currUser = (Users)Application.Current.Properties["CurrentUser"];
this.DataContext = viewModel;
}
public IActionResult AddNewOrder(AddOrderViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var availableItems = _unitOfWork.ProductRepository.GetQuantityInStock(model.ProductId);
if (model.Quantity > availableItems)
{
ModelState.AddModelError("", _localizer["MaxQuantityExceeded"]);
return(View(model));
}
var product = _unitOfWork.ProductRepository.FindBy(a => a.ProductId == model.ProductId).FirstOrDefault();
product.QuantityInStock -= model.Quantity;
var newOrder = new ProductOrder
{
Product = product,
QuantityOrdered = model.Quantity,
Client = _userManager.FindByNameAsync(User.Identity.Name).Result
};
_unitOfWork.ProductOrderRepository.Add(newOrder);
_unitOfWork.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
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 async Task <int> Add(AddOrderViewModel orderViewModel)
{
Order order = new Order()
{
OrderName = orderViewModel.OrderName,
OrderAddress = orderViewModel.OrderAddress,
OrderEmail = orderViewModel.OrderEmail,
OrderPhone = orderViewModel.OrderPhone,
OrderNote = orderViewModel.OrderNote,
TotalMoney = orderViewModel.TotalMoney,
PaymentStatus = 0
};
_daxoneDBContext.Orders.Add(order);
var res = await _daxoneDBContext.SaveChangesAsync();
var ods = JsonConvert.DeserializeObject <List <OrderDetailViewModel> >(orderViewModel.OrderDetails);
foreach (var p in ods)
{
OrderDetail od = new OrderDetail()
{
ProductId = p.Id,
OrderId = order.Id,
Price = p.Price,
Quantity = p.Quantity
};
_daxoneDBContext.OrderDetails.Add(od);
await _daxoneDBContext.SaveChangesAsync();
}
return(res);
}
public async Task <IActionResult> PlaceOrder([FromBody] AddOrderViewModel orderViewModel)
{
if (!ModelState.IsValid)
{
throw new Exception("Bad Request");
}
var order = mapper.Map <AddOrderViewModel, Order>(orderViewModel);
try
{
await context.Orders.AddAsync(order);
await context.SaveChangesAsync();
order.TrackingId = ApplicationConstants.TRACKING_ID_INITIAL + order.Id;
context.Orders.Update(order);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest($"An error occurred when add the order: { ex.Message }"));
}
}
public IActionResult AddOrder([FromForm] AddOrderViewModel orderData)
{
try
{
if (ModelState.IsValid)
{
var order = orderService.GetById(orderData.OrderId);
var route = routeService.GetById(orderData.RouteId);
RouteEntry entry = new RouteEntry()
{
Id = Guid.NewGuid()
};
entry.SetOrder(order);
entry.SetType(orderData.type);
routeService.AddEntry(route.Id.ToString(), entry);
}
return(PartialView("_AddOrderPartial", orderData));
}
catch (Exception e)
{
logger.LogError("Failed to create a new Order {@Exception}", e.Message);
logger.LogDebug("Failed to create a new Order {@ExceptionMessage}", e);
return(BadRequest(e.Message));
}
}
public IActionResult Add(AddOrderViewModel addOrderViewModel)
{
if (ModelState.IsValid)
{
Order newOrder = new Order()
{
OrderNumber = addOrderViewModel.OrderNumber,
DueDate = addOrderViewModel.DueDate,
//Driver = null,
//matches the
TrailerForLoad = context.Trailers.Where(x => x.TrailerID == addOrderViewModel.TrailerID).Single(),
CustomerOrders = context.Customers.Single(x => x.CustomerID == addOrderViewModel.CustomerID),
//Driver = context.Employees.ToList()
};
context.Orders.Add(newOrder);
trailerSelected = context.Trailers.Where(x => x.TrailerID == addOrderViewModel.TrailerID).Single();
//newOrder.TrailerForLoad = trailerSelected;
trailerSelected.TrailerStatus = "Unavailable";
context.SaveChanges();
return(Redirect("/Order"));
}
return(View(addOrderViewModel));
}
public ActionResult Add(int customerId = 0)
{
AddOrderViewModel model = new AddOrderViewModel();
model.OrderDate = DateTime.Now.ToString("dd/MM/yyyy");
model.CustomerId = customerId;
// set viewbag data
var sands = db.Sands
.OrderBy(s => s.SandName)
.Select(q1 => new SelectListItem
{
Value = q1.SandId.ToString(),
Text = "\u00A0" + q1.SandName
})
.ToList();
var boats = db.Boats
.OrderBy(b => b.BoatCode)
.Select(q1 => new SelectListItem
{
Value = q1.BoatId.ToString(),
Text = "\u00A0" + q1.BoatCode + " - " + q1.BoatOwner
})
.ToList();
ViewBag.Sands = sands;
ViewBag.Boats = boats;
return(View(model));
}
public IActionResult OrderPackage(int id)
{
AddOrderViewModel vm = new AddOrderViewModel();
vm.PackageId = id;
vm.Packages = _repoPackage.GetSingle(p => p.PackageId == vm.PackageId);
return(View(vm));
}
public AddOrderView()
{
InitializeComponent();
var vm = new AddOrderViewModel();
vm.Navigation = Navigation;
BindingContext = vm;
}
public void LoadAddOrderPage()
{
IWindowManager manager = new WindowManager();
AddOrderViewModel add = new AddOrderViewModel();
manager.ShowDialog(add, null, null);
Reload();
}
public void LoadModifyOrderPage(OrderDTO order)
{
IWindowManager manager = new WindowManager();
AddOrderViewModel modify = new AddOrderViewModel(order);
manager.ShowDialog(modify, null, null);
Reload();
}
public void AddItemCommand_SelectedComicBookIsNull_ValidCall()
{
var model = new AddOrderViewModel(null, null, null, null, new User[1]);
model.OrderItems = new ObservableCollection <OrderItemInputModel>();
model.AddItemCommand.Execute();
Assert.Empty(model.OrderItems);
}
public IActionResult Add()
{
// passes in the list of available trailers in the order form
IList <Trailer> trailerForLoad = context.Trailers.Include(c => c.Status == "Avaliable").ToList();
AddOrderViewModel addOrderViewModel = new AddOrderViewModel(trailerForLoad);
return(View(addOrderViewModel));
}
public async Task <IActionResult> AddOrder([FromBody] AddOrderViewModel orderViewModel)
{
var res = await _orderService.Add(orderViewModel);
if (res == 0)
{
return(BadRequest());
}
return(Ok(res));
}
public void RemoveItemCommand_SelectedOrderItemIsNull_ValidCall()
{
var model = new AddOrderViewModel(null, null, null, null, new User[1]);
model.OrderItems = new ObservableCollection <OrderItemInputModel>();
model.SelectedComicBook = TestData.GetComicBooksSample().First();
model.AddItemCommand.Execute();
model.SelectedOrderItem = null;
model.RemoveItemCommand.Execute();
Assert.NotEmpty(model.OrderItems);
}
public void AddItemCommand_SelectedComicBookAlreadyInCollection_ValidCall()
{
var model = new AddOrderViewModel(null, null, null, null, new User[1]);
model.OrderItems = new ObservableCollection <OrderItemInputModel>();
model.SelectedComicBook = TestData.GetComicBooksSample().First();
model.AddItemCommand.Execute();
model.SelectedComicBook = TestData.GetComicBooksSample().First();
model.AddItemCommand.Execute();
Assert.Single(model.OrderItems);
}
public IActionResult Add()
{
var products = productRepository.GetAllProducts();
var model = new AddOrderViewModel()
{
OrderStatusSelectList = new SelectList(orderStatusNames, "Key", "Value"),
AvailableCarriersSelectList = new SelectList(carrierNames, "Key", "Value"),
AvailableProductsSelectList = new SelectList(products, "Id", "Name")
};
return(View(model));
}
public async Task <IActionResult> CreateOrder(AddOrderViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View("Index", model));
}
var products = await this.productsRepository.Get(model.OrderItems.Select(x => x.Id).ToArray())
.ConfigureAwait(false);
var order = new Order
{
CustomerName = model.CustomerName,
Address = model.Address,
Comment = model.Comment,
Delivery = model.Delivery,
Email = model.Email,
Payment = model.Payment,
PhoneNumber = model.PhoneNumber,
OrderItems = model.OrderItems
.Select(x => new OrderItem
{
Color = x.Color,
Size = x.Size,
Count = x.Count,
Price = x.Price,
Product = products[x.Id]
})
.ToList()
};
var added = await this.ordersRepository.Add(order).ConfigureAwait(false);
var templatePath = "Emails/NewOrder.cshtml";
await this.emailService.Send(
order,
this.appSettings.Value.EmailForOrders,
this.appSettings.Value.PhoneNumber,
templatePath);
await this.emailService.Send(
this.appSettings.Value.EmailForOrders,
"Поступил новый заказ",
$"Поступил новый заказ {added.Id}");
return(this.RedirectToAction("Success", new SuccessViewModel {
OrderId = added.Id
}));
}
private AddOrderViewModel GetAddOrderViewModel()
{
AddOrderViewModel addOrder = new AddOrderViewModel()
{
CustomerList = _customer.GetCustomerList(),
OrderDate = DateTime.Now,
ProductList = _product.GetProducts(),
EmployeeList = _employee.GetEmployees(),
ShipperList = _shipper.GetShippers(),
Quantity = 1
};
return(addOrder);
}
public void AddItemCommand_WithoutErrors_ValidCall()
{
var model = new AddOrderViewModel(null, null, null, null, new User[1]);
model.OrderItems = new ObservableCollection <OrderItemInputModel>();
model.SelectedComicBook = TestData.GetComicBooksSample().First();
model.AddItemCommand.Execute();
var actualItem = model.OrderItems.First();
Assert.NotNull(actualItem);
Assert.Equal(model.SelectedComicBook, actualItem.ComicBook);
Assert.Equal(0, actualItem.Discount);
Assert.Equal(1, actualItem.Quantity);
}
public IActionResult OrderList(string id)
{
string[] splitId = id.Split(';');
var orderId = splitId[0];
string RouteId = splitId[1];
AddOrderViewModel model = new AddOrderViewModel()
{
OrderId = orderId,
OrderList = GetOrderList(),
RouteId = RouteId
};
return(PartialView("_AddOrderPartial", model));
}
public static OrderDataModel ToDataModel(this AddOrderViewModel addOrderViewModel)
{
return(new OrderDataModel
{
Cheese = addOrderViewModel.cheese,
Comment = "",
CreateDate = DateTime.Now,
Meat = addOrderViewModel.meat,
Rate = 0,
Salad = addOrderViewModel.salad,
Status = Enumeration.OrderStatus.Pending,
TotalPrice = addOrderViewModel.total_price,
UserId = 0
});
}
public IActionResult Add()
{
// holds in the list of available trailers
IList <Trailer> trailerForLoad = context.Trailers.Where(c => c.TrailerStatus == "Available").ToList();
// to hold a list of customers in the the Customer table
IList <Customer> customerOrder = context.Customers.ToList();
// passes both lists to the AddOrderViewModel constructor to make the available in the form
AddOrderViewModel addOrderViewModel = new AddOrderViewModel(trailerForLoad, customerOrder);
return(View(addOrderViewModel));
}
public IActionResult CreateOrderPost([FromForm] AddOrderViewModel model)
{
Claim userIdClaim = HttpContext.User.Identities.First().Claims.First();
if (userIdClaim.Value == null)
{
return(RedirectToAction("Login", "Account"));
}
bool result = this.orderService.AddOrder(model.BookId, model.Address, model.PaymentMethod, Convert.ToInt32(userIdClaim.Value));
if (!result)
{
return(RedirectToAction("GetAllBooks", "Book"));
}
return(RedirectToAction("CreateOrder"));
}
public IActionResult Add(int CustomerID)
{
Customer myCustomer = _context.Customer.Where(x => x.ID == CustomerID).FirstOrDefault();
if (myCustomer == null)
{
return(Redirect("/Orders/FindCustomer"));
}
else
{
AddOrderViewModel myOrder = new AddOrderViewModel();
myOrder.Products = _context.Products.ToList();
myOrder.Customer = myCustomer;
return(View(myOrder));
}
}
public MainViewModel()
{
HomeViewModel = new HomeViewModel();
OrdersViewModel = new OrdersViewModel();
CustomerViewModel = new CustomersViewModel();
AddCustomerViewModel = new AddCustomerViewModel();
AddOrderViewModel = new AddOrderViewModel();
CurrentView = HomeViewModel;
HomeViewCommand = new RelayCommand(o => { CurrentView = HomeViewModel; });
OrdersViewCommand = new RelayCommand(o => { CurrentView = OrdersViewModel; });
CustomerViewCommand = new RelayCommand(o => { CurrentView = CustomerViewModel; });
AddCustomerViewCommand = new RelayCommand(o => { CurrentView = AddCustomerViewModel; });
AddOrderViewCommand = new RelayCommand(o => { CurrentView = AddOrderViewModel; });
}
public async Task <ActionResult> Post(AddOrderViewModel order)
{
//Mapping should ideally be separated but it's out of scope for this demo
//N.B. AutoMapper can be harmful
var input = new MakeOrderWorkflowInput
(
orderItems: order.OrderItems.Select
(
_ => new MakeOrderWorkflowInput.OrderItem(description: _.Description, count: _.Count)
).ToList()
);
await this.makeOrderWorkflow.ExecuteAsync(input);
return(Ok());
}
public IActionResult AddOrder(AddOrderViewModel addOrderViewModel)
{
if (ModelState.IsValid)
{
Order newOrder = new Order
{
CustomerName = addOrderViewModel.CustomerName
};
context.Orders.Add(newOrder);
context.SaveChanges();
return(Redirect("/Order/ViewOrder/" + newOrder.OrderId));
}
return(View(addOrderViewModel));
}
public async Task <ActionResult> Post(AddOrderViewModel order)
{
//Mapping should ideally be separated but it's out of scope for this demo
//N.B. AutoMapper can be harmful
var serviceModel = new AddOrderServiceModel
{
OrderItems = order.OrderItems.Select(_ => new AddOrderItemServiceModel
{
Count = _.Count,
Description = _.Description
})
};
await this.orderService.MakeOrderAsync(serviceModel);
return(Ok());
}
