public async Task <OrderCreateViewModel> AddOrder(OrderCreateViewModel model)
{
var order = new Order
{
isOrder = true,
report_date = model.reportDate,
shop_id = model.shopId
};
order.OrderDetails = model.products.Select(p => new OrderDetail
{
prod_id = p.id,
cost = p.price.Value,
count = p.count
}).ToList();
var id = 0;
try
{
id = await ordersRepo.AddOrderAsync(order);
var orderDal = await ordersRepo.GetByIdAsync(id);
await strategy.UpdateAverageCost(Direction.Order, orderDal);
}
catch (Exception)
{
throw new Exception("Случилась ошибка при добавлении прихода.");
}
model.id = id;
return(model);
}
public ActionResult Create(OrderCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
_orderManager.Add(Mapper.Map <OrderCreateViewModel, Order>(model));
return(RedirectToAction("Index"));
}
catch (ValidationException exception)
{
model.Pharmacies = new SelectList(_pharmacyManager.FindAll(), "Id", "Number");
model.Types = new SelectList(new List <object>()
{
new { Id = 2, Value = "Purchase" }, new { Id = 1, Value = "Sale" }
}, "Id", "Value");
ModelState.AddModelError("", "Validation data error! Change values!");
return(View(model));
}
catch
{
model.Pharmacies = new SelectList(_pharmacyManager.FindAll(), "Id", "Number");
model.Types = new SelectList(new List <object>()
{
new { Id = 2, Value = "Purchase" }, new { Id = 1, Value = "Sale" }
}, "Id", "Value");
ModelState.AddModelError("", "Adding new record error!");
return(View(model));
}
}
public IActionResult Edit(int Id, [Bind("Id,CustomerId,OrderNo,OrderDate,Products,Customer,Status,ShippingAddress,PaymentMethod,Phone,Products")] OrderCreateViewModel order)
{
if (Id != order.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var aOrder = _mapper.Map <Order>(order);
bool isUpdated = _orderManager.Update(aOrder);
if (isUpdated)
{
var orders = _orderManager.GetAll();
ViewBag.SuccessMessage = "Order Updated Successfully!";
return(View("Index", orders));
}
//}
}
else
{
ViewBag.ErrorMessage = "Update Failed!";
}
order.OrderList = _orderManager.GetAll().ToList();
return(View(order));
}
public async Task <IActionResult> Create(OrderCreateViewModel orderCVM)
{
if (ModelState.IsValid)
{
//_context.Add(order);
//_context.Database.ExecuteSqlCommand("sp_Add_Recipient @RName", name);
try
{
//await _context.SaveChangesAsync();
await _context.Database.ExecuteSqlCommandAsync("INSERT INTO [order] ([recipient_id]) VALUES ( @OrderId ); ", new SqlParameter("@OrderId", orderCVM.RecipientId));
}
catch (Exception)
{
// ModelState.AddModelError("", "Out of Instock!!");
ViewData["RecipientId"] = new SelectList(await _context.GetRecipientsForSelection(), "RId", "IdFullName", orderCVM.RecipientId);
// ViewData["StatusId"] = new SelectList(_context.OrderStatus, "StatusId", "Content", orderCVM.StatusId);
// ViewData["VolunteerId"] = new SelectList(await _context.GetVolunteersForSelection(null), "VId", "IdFullName", order.VolunteerId);
orderCVM.StatusMessage = "Oops, Out of Instock!! ";
return(View(orderCVM));
}
//return RedirectToAction(nameof(Index));
ViewData["RecipientId"] = new SelectList(await _context.GetRecipientsForSelection(), "RId", "IdFullName");
orderCVM.StatusMessage = string.Format("Order for Recipient: {0} is Created!", _context.Recipient.FindAsync(orderCVM.RecipientId).Result.FirstName);
return(View(orderCVM));
}
ViewData["RecipientId"] = new SelectList(await _context.GetRecipientsForSelection(), "RId", "IdFullName", orderCVM.RecipientId);
// ViewData["StatusId"] = new SelectList(_context.OrderStatus, "StatusId", "Content", order.StatusId);
// ViewData["VolunteerId"] = new SelectList(await _context.GetVolunteersForSelection(null), "VId", "IdFullName", order.VolunteerId);
orderCVM.StatusMessage = "Oops, Something went wrong ! ";
return(View(orderCVM));
}
public async Task <IActionResult> Create(OrderCreateViewModel model)
{
var browserId = this.HttpContext.GetBrowserId();
model.BrowserId = browserId;
model.ShoppingCart = await this.shoppingCartService.GetAsync(browserId);
model.UserId = this.User.Identity.IsAuthenticated
? this.User.GetIdentifier()
: string.Empty;
if (model.ShoppingCart.Items.Any(i => i.Count > i.Product.Availability))
{
this.ShowNotification(
$"Insufficient availability of some products, " +
$"please go to your Shopping cart for more information.");
return(View());
}
await this.orderService.CreateAsync(model);
await this.shoppingCartService.RemoveAsync(browserId);
this.HttpContext.ClearBrowserId();
this.ShowNotification(
"Thank you for your order. We will contact you soon.",
NotificationType.Success);
return(RedirectToHome());
}
public IActionResult Order(OrderCreateViewModel model)
{
if (ModelState.IsValid)
{
var order = new Order()
{
OrderId = model.TableId,
Using = true,
StarTime = DateTime.Now,
EndTime = DateTime.Now
};
var result = orderRepository.Edit(order);
var pod = new ProductOrderDetail()
{
ProductId = model.ProductId,
OrderDetailId = model.OrderDetailId,
ProductOrderDetailId = model.ProductOrderDetailId,
Count = model.Count
};
var result2 = productOrderDetailRepository.Create(pod);
if (result != null && result2 != null)
{
var url = "https://localhost:44366/Home/Index/" + model.TableId;
return(Redirect(url));
}
}
return(View());
}
// GET: Orders/Create
public ActionResult Create()
{
OrderCreateViewModel ordervm = new OrderCreateViewModel();
Usuario usuario = db.Usuarios.Find(SessionHelper.GetUser());
ViewBag.Title = "Pedido del Centro " + usuario.Center?.Descripcion;
ordervm.CenterId = usuario.CenterId.Value;
ordervm.OrderProductViewModels = new List <OrderProductViewModel>();
var products = db.Products.Where(x => x.Enable).ToList();
// var centerProducts = db.CenterProducts.Where(x => x.CenterId == ordervm.CenterId).ToList();
var center = db.Centers.Where(x => x.Id == ordervm.CenterId).Include(x => x.CenterProducts).FirstOrDefault();
var centerProducts = center.CenterProducts;
ordervm.TieneStockSinCargar = center.TieneStockSinCargar();
foreach (var item in products)
{
OrderProductViewModel orderProduct = new OrderProductViewModel
{
Product = item.Descripcion,
ProductId = item.Id,
ProductType = item.SupplieMedical.Descripcion,
Quantity = 0,
QuantityDelivered = 0,
OutStock = item.OutStock,
Stock = centerProducts.Where(x => x.ProductId == item.Id).Select(x => x.Stock).FirstOrDefault()
};
ordervm.OrderProductViewModels.Add(orderProduct);
}
return(View(ordervm));
}
public async Task CreateAsync(OrderCreateViewModel model)
{
var orderItems = new List <OrderItem>();
foreach (var item in model.ShoppingCart.Items)
{
orderItems.Add(new OrderItem
{
Count = item.Count,
Product = await this.productRepository.GetAsync(item.Product.Id)
});
}
var order = this.orderFactory.CreateInstance(
model.BrowserId,
model.CustomerName,
model.CustomerPhoneNumber,
model.DeliveryAddress,
model.UserId,
model.ShoppingCart.TotalAmount,
orderItems);
await this.orderRepository.AddAsync(order);
foreach (var item in order.Items)
{
var product = await this.productRepository.GetAsync(item.Product.Id);
product.Availability -= item.Count;
await this.productRepository.UpdateAsync(product);
}
}
public ActionResult CreateIndividualOrder(OrderCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
var transaction = NHibernateSession.Current.BeginTransaction();
try
{
var order = _orderService.Create(
Guid.NewGuid(),
viewModel.SupplierId,
viewModel.Instructions,
viewModel.CurrencyId);
transaction.Commit();
return(RedirectToAction("PendingOrders"));
}
catch (DomainValidationException dex)
{
transaction.Rollback();
ModelState.UpdateFromDomain(dex.Result);
}
finally
{
transaction.Dispose();
}
}
viewModel.Currencies = _currencyService.GetCurrencies().ToSelectList();
return(View(viewModel));
}
public async Task <IActionResult> Create(string id)
{
var requestCulture = HttpContext.Features.Get <IRequestCultureFeature>();
var cultCode = requestCulture.RequestCulture.UICulture.Name;
var exRes = new ExecutionResult();
if (string.IsNullOrEmpty(id))
{
return(RedirectToAction(nameof(Index)));
}
var pizza = await _context.Pizzas
.SingleOrDefaultAsync(m => m.NameEn == id);
if (pizza == null)
{
exRes.AddError(_localizer["Requested pizza could not be found."]).PushTo(TempData);
return(RedirectToAction(nameof(Index)));
}
var prices = _context.PizzaPriceInfo.Where(info => info.PriceCategoryId == pizza.PriceCategoryId);
var vm = new OrderCreateViewModel
{
ImagePath = pizza.ImagePath,
Name = cultCode == "lt-LT" ? pizza.NameLt : pizza.NameEn,
Prices = prices,
Description = cultCode == "lt-LT" ? pizza.DescriptionLt : pizza.DescriptionEn
};
vm.MinPrice = vm.Prices.DefaultIfEmpty(new PizzaPriceInfo()).Min(p => p.Price);
return(View(vm));
}
public IActionResult OrderCreationForm(OrderCreateViewModel model)
{
if (model.Tables == null)
{
model.Tables = new List <Table>();
}
var usrID = HttpContext.Session.GetInt32("userID");
var waiterId = _context.Users.Where(w => w.UserId == (int)usrID).Include(e => e.Employee).ThenInclude(w => w.Waiter).FirstOrDefault().Employee.Waiter.WaiterId;
var table = _context.Tables.Find(model.CurrentTable);
model.Tables.Add(table);
var order = new Order {
Duration = 0, ManagedByWaiterId = waiterId, OrderDate = DateTime.Now, State = (int)OrderState.Created, Price = 0.0
};
_context.Add(order);
_context.SaveChanges();
foreach (var t in model.Tables)
{
var to = new TableOccupancy {
OrderId = order.OrderId, TableId = t.TableNum
};
_context.Add(to);
}
_context.SaveChanges();
return(RedirectToAction("OrderList"));
}
public async Task <OrderCreateViewModel> AddCancellations(OrderCreateViewModel model)
{
var order = new Order
{
isOrder = false,
report_date = model.reportDate,
shop_id = model.shopId
};
order.OrderDetails = model.products.Select(p => new OrderDetail
{
prod_id = p.id,
cost = costRepo.GetByProdId(p.id).FirstOrDefault() != null && costRepo.GetByProdId(p.id).FirstOrDefault().value.HasValue ?
costRepo.GetByProdId(p.id).FirstOrDefault().value.Value : 0,
count = p.count
}).ToList();
var id = 0;
try
{
id = await ordersRepo.AddCancellationAsync(order);
var orderDal = (await ordersRepo.GetCancellationsByShopIdInDateRange(order.shop_id, model.reportDate.AddSeconds(-1), model.reportDate)).Last(p => p.id == id);
await strategy.UpdateAverageCost(Direction.Cancellation, orderDal);
}
catch (Exception)
{
throw new Exception("Добавление списания не удалось.");
}
model.id = id;
return(model);
}
public async Task Create_Order_fail()
{
var pizza = _context.Pizzas.Single(e => e.NameEn == "Havaian");
var order = new OrderCreateViewModel {
Name = pizza.NameEn, Description = pizza.DescriptionLt, ImagePath = pizza.ImagePath, Comment = "dad", Quantity = -1, SizeId = 1
};
if (!Validator.TryValidateObject(order, new ValidationContext(order), null, true))
{
_controller.ModelState.AddModelError("err", "Error");
}
var res = await _controller.Create(pizza.NameEn, order);
Assert.IsType <ViewResult>(res);
order = new OrderCreateViewModel {
Name = pizza.NameEn, Description = pizza.DescriptionLt, ImagePath = pizza.ImagePath, Comment = "dad", Quantity = 3, SizeId = 2
};
if (!Validator.TryValidateObject(order, new ValidationContext(order), null, true))
{
_controller.ModelState.AddModelError("err", "Error");
}
res = await _controller.Create(pizza.NameEn, order);
Assert.IsType <ViewResult>(res);
}
// GET: Orders/Create
public IActionResult Create(int id)
{
OrderCreateViewModel model = new OrderCreateViewModel();
model.BusinessID = id;
model.UserID = User.FindFirstValue(ClaimTypes.NameIdentifier);
model.BusMenu = _businessMenuManager.GetBusinessMenuForBusiness(id);
if (model.BusMenu != null)
{
model.MenuItems = _menuItemManager.GetMenuItems(model.BusMenu.MenuID).Data;
model.OrderLines = new List <OrderLine>();
foreach (var item in model.MenuItems)
{
OrderLine newOrderLine = new OrderLine
{
ItemID = item.ItemID,
Amount = 0
};
model.OrderLines.Add(newOrderLine);
}
}
return(View(model));
}
private void ConvertCreateModelToBasicModel(OrderCreateViewModel createModel, Order orderEntity)
{
if (createModel.ItemsFormList == null)
{
createModel.ItemsFormList = new List <ItemBasicViewModel>();
}
var selectedItems = createModel.ItemsFormList.Select(i => i.ID).ToList();
var orderItems = orderEntity.Rented_Items.Select(i => i.ItemID).ToList();
foreach (int orderItemsID in orderItems)
{
if (!selectedItems.Contains(orderItemsID))
{
m_Context.RentedItems.Remove(orderEntity.Rented_Items.Where(i => i.ItemID == orderItemsID).FirstOrDefault());
m_Context.Items.Where(i => i.ID == orderItemsID).FirstOrDefault().Avaiable = "1";
}
}
foreach (ItemBasicViewModel selectedItem in createModel.ItemsFormList)
{
if (!orderItems.Contains(selectedItem.ID))
{
orderEntity.Rented_Items.Add(new RentedItem()
{
ItemID = selectedItem.ID,
OrderID = orderEntity.ID
});
m_Context.Items.Where(i => i.ID == selectedItem.ID).FirstOrDefault().Avaiable = "0";
}
}
}
public async Task <IActionResult> Create([FromBody] OrderCreateViewModel order)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var success = await _domainService.Create(new Order
{
UserId = order.UserId,
OrderItems = order.OrderItems.Select(x => new OrderItem
{
ProductId = x.ProductId,
Amount = x.Amount,
CurrentPrice = x.CurrentPrice
}).ToList()
});
if (success)
{
return(Ok("Order created."));
}
else
{
return(NotFound("User or product not found."));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
// GET: Orders/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var order = await _bll.Orders.FindAsync(id);
if (order == null)
{
return(NotFound());
}
var vm = new OrderCreateViewModel()
{
Order = order,
ShipperSelectList = new SelectList(await _bll.Shippers.AllAsync(),
nameof(Shipper.Id), nameof(Shipper.ShipperName)),
ShopSelectList = new SelectList(await _bll.Shops.GetShopByUserShopIdForDropDown(User.GetShopId()),
nameof(Shop.Id), nameof(Shop.ShopName))
};
return(View(vm));
}
public ActionResult Edit(int id)
{
OrderCreateViewModel vm = new OrderCreateViewModel();
vm.Model = _orderService.Get(id);
return(View("Create", GetCreateViewModel(vm)));
}
//private Context db2 = new Context();
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
HttpContextBase objContext = controllerContext.HttpContext;
OrderCreateViewModel obj = new OrderCreateViewModel();
obj.order.Annotation = objContext.Request.Form["OrderInfo"];
return(obj);
}
public ServiceResult Add(OrderCreateViewModel createModel)
{
var v_item = _mapper.Map <Order>(createModel.Model);
m_Context.Orders.Add(v_item);
ConvertCreateModelToBasicModel(createModel, v_item);
v_item.Date_Rented = DateTime.Now;
return(SaveChanges());
}
public ActionResult Create(OrderCreateViewModel model, CreateOrderSubmitEnum submit)
{
ModelState.Clear();
var instance = new CreateOrderInstance(this, submit);
instance.Provider.Execute(model);
return(View(PartialViewConstants.CreatePartial, model));
}
public IActionResult Create(OrderCreateViewModel vm)
{
if (ModelState.IsValid)
{
return(RedirectToAction("Create2", "Order", new { id = vm.CategoryId }));
}
// if not valid
return(View(vm));
}
public ActionResult Create()
{
OrderCreateViewModel vm = new OrderCreateViewModel()
{
Model = new OrderDetailViewModel()
};
return(View(GetCreateViewModel(vm)));
}
public IActionResult Create()
{
var model = new OrderCreateViewModel();
model.Locations = _customerServices.GetLocations();
return(View(model));
}
public async Task <IActionResult> AddWithDeliveryRequest([FromBody] OrderCreateViewModel request)
{
var command = Mapper.Map <OrderWithDeliveryRequestCreateCommand>(request);
command.ManagerId = Convert.ToInt32(User.Claims.First(c => c.Type == "Id").Value);
var id = await _commandFunctionality.AddWithDeliveryRequestAsync(command);
return(ResponseWithData(StatusCodes.Status201Created, id));
}
// GET: /Order/Create
public ActionResult Create()
{
OrderCreateViewModel model = new OrderCreateViewModel();
model.Customers = GetAllCustomers();
model.ShipTypes = GetAllShipTypes();
model.EstimatedShipDate = DateTime.Now;
//NO VIEWBAG: ViewBag.CustomerId = new SelectList(db.Customers, "CustomerId", "FirstName");
return(View(model));
}
public ActionResult Create(OrderCreateViewModel viewModel)
{
if (ModelState.IsValid == false)
{
return(View(viewModel));
}
var dto = Mapper.Map <OrderCreateViewModel, OrderDto>(viewModel);
this._orderService.CreateOrder(dto);
return(RedirectToAction("Index"));
}
public IActionResult Create()
{
var user = _userManager.GetUserAsync(User);
var orderCreateModel = new OrderCreateViewModel
{
User = user.Result,
Cart = _cartRepository.GetAll().Where(n => n.UserId == user.Result.Id).ToList()
};
return(View(orderCreateModel));
}
public ActionResult Create(OrderCreateViewModel ordersCreateViewModel)
{
if (!ModelState.IsValid)
{
return(View(ordersCreateViewModel));
}
_orderService.Add(ordersCreateViewModel);
return(RedirectToAction("Index"));
}
// GET: Orders/Create
public async Task <IActionResult> Create()
{
var vm = new OrderCreateViewModel()
{
ShipperSelectList = new SelectList(await _bll.Shippers.AllAsync(),
nameof(Shipper.Id), nameof(Shipper.ShipperName)),
ShopSelectList = new SelectList(await _bll.Shops.GetShopByUserShopIdForDropDown(User.GetShopId()),
nameof(Shop.Id), nameof(Shop.ShopName))
};
return(View(vm));
}
