public ActionResult Create(OrderEditModel itemRaw) { if (ModelState.IsValid) { try { var itemDto = new OrderDTO { Date = itemRaw.Date, Price = itemRaw.Price, Products = itemRaw.SelectedProducts.Select((v) => ProductService.Get(v)).ToList(), CustomerId = itemRaw.CustomerId, }; OrderService.Add(itemDto); return(RedirectToAction("Index")); } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } } return(View(itemRaw)); }
public ActionResult EditOrder(OrderEditModel model) { IOrderRepository orderRepository = new OrderRepository(); //Order order = orderRepository.getOrder(model.id); EditOrderModel orderEdit = new EditOrderModel(); orderEdit.id = model.id; orderEdit.idStatus = model.idStatus; orderEdit.load.Name = model.load.Name; orderEdit.load.Price = model.load.Price; orderEdit.load.Weight = model.load.Weight; orderEdit.load.LoadType = model.load.LoadType; orderEdit.vehicle.Name = model.vehicle.Name; orderEdit.route.StartPoint = model.route.StartPoint; orderEdit.route.EndPoint = model.route.EndPoint; orderEdit.customer.Name = model.customer.Name; orderEdit.customer.Surname = model.customer.Surname; orderEdit.customer.Address = model.customer.Address; orderEdit.customer.PhoneNumber = model.customer.PhoneNumber; orderEdit.customer.Firm = model.customer.Firm; orderEdit.driver.Name = model.driver.Name; orderEdit.driver.Surname = model.driver.Surname; orderEdit.driver.Address = model.driver.Address; orderEdit.driver.PhoneNumber = model.driver.PhoneNumber; orderEdit.driver.Firm = model.driver.Firm; orderRepository.updateOrder(orderEdit); return(RedirectToAction("OrderList", "Order")); }
// добавление данных public ViewResult Create(int page = 1, string returnUrl = "", string sort = "") { ViewData["Title"] = "Добавление новой заявки"; OrderEditModel editModel = new OrderEditModel() { Order = new Order() { DocDate = DateTime.Now }, Note = new Note(), NoteViewModel = new NoteViewModel() { Notes = repository.Notes.Where(p => p.DataID == 0) }, CommonLogViewModel = new CommonLogViewModel() { CommonLogs = repository.CommonLogs.Where(p => p.ActionID == 0) }, Page = page, ReturnUrl = returnUrl, Sort = sort }; FillSelectItems(editModel); return(View("Edit", editModel)); }
public ActionResult Edit(OrderEditModel model) { if (ModelState.IsValid) { foreach (int productId in model.SelectedProducts) { var product = bll.Products.GetAll().First(p => p.ProductID == productId); //db.Products.Attach(product); model.Order.Products.Add(product); //db.Entry<Product>(product).State = EntityState.Unchanged; } bll.Orders.Update(model.Order); return(RedirectToAction("Index")); } model.AllProductItems = bll.Products.GetAll().Select(p => new SelectListItem { Text = p.Name, Value = p.ProductID.ToString() }).ToList(); model.CustomerItems = bll.Customers.GetAll().Select(c => new SelectListItem() { Text = c.Name, Value = c.CustomerID.ToString() }).ToList(); model.CustomerItems.First(c => c.Value == model.Order.CustomerID.ToString()).Selected = true; return(View(model)); }
public ActionResult Edit(OrderEditModel oem) { if (oem != null) { var pList = db.pList.AsNoTracking().Where(p => p.OrderId == oem.OrderId).ToList(); foreach (var item in oem.OrderitemList) { var order = pList.Where(p => p.ProductId == item.id).ToList().ElementAt(0); if (item.Number == 0) { db.pList.Remove(order); pList.Remove(order); } else { ProductList pl = new ProductList(); pl.Number = item.Number; pl.OrderId = oem.OrderId; pl.ProductId = item.id; pl.ProductListId = order.ProductListId; db.Entry(pl).State = EntityState.Modified; } } if (pList.Count() == 0) { var order = db.Orders.Find(oem.OrderId); db.Orders.Remove(order); } db.SaveChanges(); return(RedirectToAction("Index")); } return(View(oem)); }
// заполнение выпадающих списков public void FillSelectItems(OrderEditModel editModel) { editModel.Order.itemsSC = new SelectList(repository.SCs, "SC_ID", "SCDesc"); editModel.Order.itemsStatus = new SelectList(repository.Statuses, "StatusID", "StatusDesc"); editModel.Order.itemsCompType = new SelectList(repository.CompensationTypes, "TypeID", "TypeDesc"); editModel.Order.itemsDep = new SelectList(repository.Departments, "DepartmentID", "DepartmentDesc"); }
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 ActionResult Delete(int id = 0) { Order order = db.Orders.Find(id); if (order == null) { return(HttpNotFound()); } OrderEditModel oem = new OrderEditModel(); List <OrderItem> list = new List <OrderItem>(); IEnumerable <ProductList> pList = from pl in db.pList let k = pl.OrderId where order.OrderID.Equals(k) select pl; var LpList = pList.ToList(); foreach (var pitem in LpList) { OrderItem oi = new OrderItem(); IEnumerable <Product> p = from product in db.Products let k = product.ProductID where pitem.ProductId.Equals(k) select product; oi.id = p.ElementAt(0).ProductID; oi.Number = pitem.Number; oi.Price = p.ElementAt(0).Price; list.Add(oi); } oem.OrderId = id; oem.OrderitemList = list; return(View(oem)); }
public async Task <IActionResult> EditOrder(int id, [Bind("Id,ExactReturnDate,Damaged")] OrderEditModel orEd) { id = orEd.Id; var order = await _context.OrderDetails.SingleOrDefaultAsync(x => x.Id == id); order.ExactReturnDate = orEd.ExactReturnDate; order.Damaged = orEd.Damaged; if (id != order.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(order); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrderExists(order.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index), "Admin")); } return(View(order)); }
// вызов формы на редактирование public IActionResult Edit(int orderID, string returnUrl = "", int page = 1, string sort = "") { ViewData["Title"] = "Редактирование заявки"; OrderEditModel editModel = new OrderEditModel() { Order = repository.Orders.FirstOrDefault(p => p.ID == orderID), Note = new Note() { NoteDate = DateTime.Today, DataID = orderID, UserID = User.Identity.Name }, NoteViewModel = new NoteViewModel() { Notes = repository.Notes.Where(p => p.DataID == orderID).OrderBy(p => p.NoteDate) }, CommonLogViewModel = new CommonLogViewModel() { CommonLogs = repository.CommonLogs.Where(p => p.ActionID == orderID).OrderBy(p => p.ActionDate) }, Page = page, CurrentID = orderID, ReturnUrl = returnUrl, Sort = sort }; if (editModel.Order != null) { ViewData["Title"] = "Редактирование заявки №" + Convert.ToString(editModel.Order.Number); } FillSelectItems(editModel); return(View(editModel)); }
// GET: Order/Edit/5 public ActionResult Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Order order = bll.Orders.GetSingle((int)id); if (order == null) { return(HttpNotFound()); } //ViewBag.CustomerID = new SelectList(db.Customers, "CustomerID", "Name", order.CustomerID); OrderEditModel model = new OrderEditModel(); model.Order = order; model.AllProductItems = bll.Products.GetAll().Select(p => new SelectListItem { Text = p.Name, Value = p.ProductID.ToString() }).ToList(); model.SelectedProducts = order.Products.Select(p => p.ProductID).ToList(); model.CustomerItems = bll.Customers.GetAll().Select(c => new SelectListItem() { Text = c.Name, Value = c.CustomerID.ToString() }).ToList(); model.CustomerItems.First(c => c.Value == order.CustomerID.ToString()).Selected = true; return(View(model)); }
public async Task Put(int id, [FromBody] OrderEditModel value) { var order = AutoMapper.Mapper.Map <OrderEditModel, OrderDto>(value); order.UserFirstName = User.Identity.Name; order.Id = id; await _service.Update(order); }
public ActionResult Edit(int code) { Order order = orderService.GetOrderByCode(code); OrderEditModel orderEM = Mapper.Map <Order, OrderEditModel>(order); orderEM.StatusList = GetSelectList(order.StatusId); return(View(orderEM)); }
public void AddSubmitsAndRedirectsToEditOnSucccessTest() { var model = new OrderEditModel(); var result = _controller.Add(model) as RedirectToRouteResult; Assert.IsNotNull(result); Assert.AreEqual("Edit", result.RouteValues["action"]); _mockDataAccess.Verify(x => x.AddOrder(It.IsAny<Order>()), Times.Once()); }
public ActionResult Edit(OrderEditModel editModel) { Order order = orderService.GetOrderByCode(editModel.OrderNumber); order.ShipmentDate = editModel.ShipmentDate; order.StatusId = Guid.Parse(editModel.StatusId); orderService.EditOrder(order); return(RedirectToAction("Index")); }
public void AddReturnsViewOnErrorTest() { var model = new OrderEditModel(); _controller.ModelState.AddModelError("Foo", "Some error"); var result = _controller.Add(model) as ViewResult; Assert.IsNotNull(result); Assert.IsNotNull(model); }
public async Task <OrderSalepoint> Add(OrderEditModel order) { OrderSalepoint newOrder = await this.salepointOrdersApi.AddOrder(order); this.AddedOrders.Add(newOrder); this.AddedOrdersUpdated?.Invoke(this, new ServiceEvent <SalepointAddedOrdersEvents>(SalepointAddedOrdersEvents.AddedOrder, newOrder)); return(newOrder); }
public async Task <ActionResult> Patch(int id, [FromBody] OrderEditModel editModel) { var order = await _db.Orders.FindAsync(id); if (order == null) { return(NotFound()); } order.State = editModel.State; await _db.SaveChangesAsync(); return(NoContent()); }
public ActionResult CreateOrder( [Bind(Include = "UniqueID, DateCreated, SalesChannel, TermsAndConditions")] OrderEditModel k) { if (!ModelState.IsValid) { return(View("EditOrder", k)); } var order = new Order(); k.Update(order); Orders.Instance.Add(order); return(RedirectToAction("Index")); }
public ActionResult DeleteConfirmed(OrderEditModel oem) { Order order = db.Orders.Find(oem.OrderId); db.Orders.Remove(order); var pList = db.pList.Where(p => p.OrderId == oem.OrderId).ToList(); foreach (var item in pList) { db.pList.Remove(item); } db.SaveChanges(); return(RedirectToAction("Index")); }
public ActionResult Add(OrderEditModel newOrder) { if (ModelState.IsValid) { var entity = Mapper.Map(newOrder, new Order()); var id = DataAccess.AddOrder(entity); TempData["SuccessMessage"] = "Order was successfully added"; return RedirectToAction("Edit", new {id}); } ViewBag.ButtonLabel = "Add"; PopulateDropDowns(); return View(newOrder); }
/// <summary> /// Edits Order at Order ID /// </summary> public void EditOrderByKey(int orderKey, int menuKey, string comment) { using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(ConnectionStringHelper.CnnVal("CanteenMenuDB"))) { OrderEditModel orderEditModel = new OrderEditModel { OrderKey = orderKey, MenuKey = menuKey, Comment = comment }; connection.Execute("dbo.OrderEditByKey @OrderKey, @MenuKey, @Comment", orderEditModel); } }
public static PurchaseOrderType Map(OrderEditModel model) { return(new PurchaseOrderType { id = model.Id, orderDate = model.Date, orderDateSpecified = true, shipped = model.Shipped, shippedSpecified = true, Items = new [] { model.BillTo, model.ShipTo }, ItemsElementName = new[] { ItemsChoiceType.billTo, ItemsChoiceType.shipTo }, items = Map(model.Products) }); }
public ActionResult Edit(int id, OrderEditModel itemRaw) { if (ModelState.IsValid) { try { var itemDto = new OrderDTO { Id = id, Date = itemRaw.Date, Price = itemRaw.Price, Products = itemRaw.SelectedProducts.Select((v) => ProductService.Get(v)).ToList(), CustomerId = itemRaw.CustomerId, }; OrderService.Update(itemDto); return(RedirectToAction("Index")); } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } } else { var itemDto = OrderService.Get(id); itemRaw = new OrderEditModel { CustomerId = itemDto.CustomerId, Date = itemDto.Date, Price = itemDto.Price, Products = itemDto.Products.Select((v) => new ProductViewModel() { Id = v.Id, Name = v.Name, Price = v.Price, }).ToList(), SelectedProducts = itemDto.Products.Select((v) => v.Id).ToList(), ProductsSelectList = ProductService.GetAll().Select((v) => new SelectListItem() { Text = v.Name, Value = v.Id.ToString() }), }; } return(View(itemRaw)); }
public ActionResult EditOrder( [Bind(Include = "UniqueID, DateCreated, SalesChannel, TermsAndConditions")] OrderEditModel e) { if (!ModelState.IsValid) { return(View("EditOrder", e)); } var order = Orders.Instance.Find(x => x.IsThisUniqueId(e.UniqueId)); if (order == null) { return(HttpNotFound()); } e.Update(order); return(RedirectToAction("Index")); }
public async Task <ActionResult> Save(OrderEditModel model) { model.Products = Products; var order = Mappers.Map(model); if (!string.IsNullOrWhiteSpace(order.id)) { await client.Orders.Put(order, order.id); } else { await client.Orders.Post(order); } Products.Clear(); return(RedirectToAction("Index")); }
// GET: Products/Create public ActionResult Create() { var item = new OrderEditModel { Price = 0, Date = DateTime.Now, Products = new List <ProductViewModel>(), SelectedProducts = new List <int>(), ProductsSelectList = ProductService.GetAll().Select((v) => new SelectListItem() { Text = v.Name, Value = v.Id.ToString() }), }; ViewBag.CustomersIds = new SelectList(CustomerService.GetAll(), "Id", "Name", null); return(View(item)); }
public async Task <IActionResult> Edit(int id) { var order = await _context.Orders.Include(i => i.Creator).SingleOrDefaultAsync(o => o.Id == id); if (order == null) { return(NotFound()); } if (order.CreatorId != CurrentUserId) { if (AllowAdminOverride() == false) { ErrorMessage = "You don't have access to this order."; return(RedirectToAction("Index")); } Message = "Warning, Admin editing order for user."; } if (order.Status != OrderStatusCodes.Created) { ErrorMessage = "You can't edit an order that has been confirmed."; return(RedirectToAction("Index")); } var joined = await _orderService.PopulateTestItemModel(); var proc = await _labworksService.GetPrice(processingCode); var model = new OrderEditModel { TestItems = joined.ToArray(), Order = order, InternalProcessingFee = Math.Ceiling(proc.Cost), ExternalProcessingFee = Math.Ceiling(proc.Cost * _appSettings.NonUcRate), Defaults = new OrderEditDefaults { DefaultEmail = order.Creator.Email } }; return(View(model)); }
public ActionResult Edit(int id) { var orderDto = _orderService.GetOrderDtoById(id); if (orderDto != null) { var model = new OrderEditModel { Id = orderDto.Id, ManagerName = orderDto.ManagerName, ProductName = orderDto.ProductName, Price = orderDto.Price, Date = orderDto.Date, ClientName = orderDto.ClientName }; return(View(model)); } return(RedirectToAction("Index")); }
public void Update__ValidEditModel__Success() { const string noteText = "created note"; var orderId = this.order.Id; var editModel = new OrderEditModel { Id = orderId, Note = noteText, }; this.GetService().Update(editModel); var orderFromDb = this.nhSessionHelper.ReturnInNewSession(x => x.Get <Order>(orderId)); orderFromDb.ShouldNot(Be.Null); orderFromDb.Id.ShouldEqual(orderId); orderFromDb.Version.ShouldNot(Be.Empty); orderFromDb.Note.ShouldEqual(noteText); }
public async Task <IActionResult> Create() { var joined = await _orderService.PopulateTestItemModel(); var proc = await _labworksService.GetPrice(processingCode); var user = _context.Users.Single(a => a.Id == CurrentUserId); var model = new OrderEditModel { TestItems = joined.ToArray(), InternalProcessingFee = Math.Ceiling(proc.Cost), ExternalProcessingFee = Math.Ceiling(proc.Cost * _appSettings.NonUcRate), Defaults = new OrderEditDefaults { DefaultAccount = user.Account?.ToUpper(), DefaultEmail = user.Email, DefaultCompanyName = user.CompanyName, DefaultAcAddr = user.BillingContactAddress, DefaultAcEmail = user.BillingContactEmail, DefaultAcName = user.BillingContactName, DefaultAcPhone = user.BillingContactPhone, }, }; if (!string.IsNullOrWhiteSpace(user.ClientId)) { //Has a default client id, so try to get defaults: var defaults = await _labworksService.GetClientDetails(user.ClientId); if (defaults != null) { model.Defaults.DefaultAccount = model.Defaults.DefaultAccount ?? defaults.DefaultAccount; model.Defaults.DefaultClientId = defaults.ClientId; model.Defaults.DefaultClientIdName = defaults.Name; model.Defaults.DefaultSubEmail = defaults.SubEmail; model.Defaults.DefaultCopyEmail = defaults.CopyEmail; } } return(View(model)); }
public async Task <IActionResult> EditOrder(int?id) { if (id == null) { return(NotFound()); } var order = await _context.OrderDetails.SingleOrDefaultAsync(x => x.Id == id); if (order == null) { return(NotFound()); } OrderEditModel orEd = new OrderEditModel() { Id = order.Id, ExactReturnDate = order.ExactReturnDate, Damaged = order.Damaged }; return(PartialView("EditOrder", orEd)); }
public IActionResult Edit(OrderEditModel editModel) { if (ModelState.IsValid) { try { if (editModel.Order.ID == 0) // если это добавление, то нумеруем автоматически { editModel.Order.Number = (repository.Orders.Max(p => p.Number) ?? 0) + 1; } repository.Save(editModel.Order); } catch (Exception e) { TempData["message"] = $"Ошибка сохранения: {e.Message}"; return(View(editModel)); } TempData["message"] = $"Запись № \"{editModel.Order.Number}\" сохранена!"; CommonLog log = new CommonLog() { Action = "Orders", ActionID = editModel.Order.ID, ActionDate = DateTime.Now, UserDesc = User.Identity.Name, TxtMsg = (editModel.Order.ID == 0) ? "Добавление: " : "Изменение: " + GetOrderDesc(editModel.Order), _UID = Guid.NewGuid() }; logRepository.Save(log); return(RedirectToAction("Index", new { page = editModel.Page, currentID = editModel.Order.ID, sort = editModel.Sort })); } else { FillSelectItems(editModel); return(View(editModel)); } }
public ActionResult Edit(OrderEditModel order) { if (ModelState.IsValid) { var entity = Mapper.Map(order, new Order()); DataAccess.UpdateOrder(entity); TempData["SuccessMessage"] = "Order was successfully updated"; return RedirectToAction("Edit", new { id = order.Id }); } ViewBag.ButtonLabel = "Update"; PopulateDropDowns(); return View(order); }