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);
}
