//public ActionResult Save(string orderNo)
//{
// return View();
//}
//public JsonResult Save(OrderViewModel model)
//{
// model.Orders.Add(model.Order);
// return Json(model.Order, JsonRequestBehavior.AllowGet);
//}
public ActionResult Save(OrderViewModel model)
{
//model.Orders = db.Orders.ToList();
if (model.Order.OrderId > 0)
{
db.Entry(model.Order).State = EntityState.Modified;
db.SaveChanges();
}
else
{
db.Orders.Add(model.Order);
db.SaveChanges();
}
//if (saveChanges>0)
//{
// return View("Index", model);
//}
model.Orders = db.Orders.OrderByDescending(x => x.OrderId).ToList();
return(View("Index", model));
//model.Orders.Add(model.Order);
}
public ActionResult Edit(BigViewModel editOrder)
{
if (ModelState.IsValid)
{
db.Entry(editOrder.Order).State = EntityState.Modified;
db.SaveChanges();
//var dbw = db.OrderItem.Where(o => o.OrderId == editOrder.Order.Id);
foreach (var i in editOrder.orderItemsList)
{
if (i.Id == 0)
{
i.OrderId = editOrder.Order.Id;
db.OrderItem.Add(i);
}
var d = db.OrderItem.Find(i.Id);
d.Name = i.Name;
d.Quantity = i.Quantity;
d.Unit = i.Unit;
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProviderId = new SelectList(db.Provider, "Id", "Name", editOrder.Order.ProviderId);
return(View(editOrder));
}
public async Task <IHttpActionResult> PutOrder(Guid id, Order order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != order.Id)
{
return(BadRequest());
}
db.Entry(order).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <T> UpdateAsync(T obj)
{
Context.Entry(obj).State = EntityState.Modified;
await Context.SaveChangesAsync();
return(obj);
}
public async Task <IActionResult> PutOrder(int id, Order order)
{
if (id != order.OrderId)
{
return(BadRequest());
}
_ordersDbContext.Entry(order).State = EntityState.Modified;
try
{
await _ordersDbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IsOrderExists(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public IHttpActionResult PutCustomer(int id, Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != customer.Id)
{
return(BadRequest());
}
db.Entry(customer).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Edit(States states)
{
if (ModelState.IsValid)
{
db.Entry(states).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(states));
}
public ActionResult <Item> PutUpdatedRecord(long id, Item item)
{
if (id != item.Id)
{
return(BadRequest());
}
orderDbCtx.Entry(item).State = EntityState.Modified;
orderDbCtx.SaveChanges();
return(NoContent());
}
public ActionResult Edit([Bind(Include = "Id,Name,BeginDate,EndDate,PartnerContract,ParnerPhone")] Partner partner)
{
if (ModelState.IsValid)
{
db.Entry(partner).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(partner));
}
public ActionResult Edit(Inventory inventory)
{
if (ModelState.IsValid)
{
db.Entry(inventory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(inventory));
}
public ActionResult Edit([Bind(Include = "Id,OrderCode,OrderDate,ComplteDate,OrderStatus,Remark")] Order order)
{
if (ModelState.IsValid)
{
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(order));
}
public ActionResult Edit([Bind(Include = "Id,ProductId,ProductType,StartDate,EndDate,Quantity,TotalPrice,Remark")] OrderItem orderItem)
{
if (ModelState.IsValid)
{
db.Entry(orderItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderItem));
}
public ActionResult Edit([Bind(Include = "VendorId,Name")] Vendor vendor)
{
if (ModelState.IsValid)
{
db.Entry(vendor).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vendor));
}
public ActionResult Edit([Bind(Include = "OrderId,ClientId,Products,Price,Position")] Order order)
{
if (ModelState.IsValid)
{
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(order));
}
public ActionResult Edit([Bind(Include = "Id,PersonName,PersonPhone,PersonIdentity,CredentialType,OrderItemId,Remark")] PersonInfo personInfo)
{
if (ModelState.IsValid)
{
db.Entry(personInfo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.OrderItemId = new SelectList(db.OrderItems, "Id", "ProductId", personInfo.OrderItemId);
return(View(personInfo));
}
public ActionResult Edit([Bind(Include = "Id,CustomerId,CreationDate")] Order order)
{
if (ModelState.IsValid)
{
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CustomerId = new SelectList(db.Customers, "Id", "FirstName", order.CustomerId);
return(View(order));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,ComboCode,ComboName,ValidStartDate,ValidEndDate,Price,ProductPrice,ProductCommision,ProductSettlement,ProductContractPrice")] ComboProduct comboProduct)
{
if (ModelState.IsValid)
{
db.Entry(comboProduct).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(comboProduct));
}
public ActionResult Edit([Bind(Include = "OrderId,Name,PizzaSize,Quantity,PizzaPrice,TimeOFOrderCreated,CustomerId")] Order order)
{
if (ModelState.IsValid)
{
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CustomerId = new SelectList(db.Customers, "Id", "Name", order.CustomerId);
return(View(order));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,CName,CPhone,CIdentity,IdentityType,Level,CEmail")] Customer customer)
{
if (ModelState.IsValid)
{
db.Entry(customer).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(customer));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,SupplierName,Contract,Phone,Call,FixNumber,Remark")] Supplier supplier)
{
if (ModelState.IsValid)
{
db.Entry(supplier).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(supplier));
}
public async Task <ActionResult> Edit(Order order)
{
if (!ModelState.IsValid)
{
return(View("Edit", order));
}
var existingOrder = _dbContext.Orders.Include(o => o.OrderItems).First(o => o.Id == order.Id);
_dbContext.Entry(existingOrder).CurrentValues.SetValues(order);
if (order.OrderItems != null)
{
// remove deletions
foreach (var existingOrderItem in existingOrder.OrderItems.ToList())
{
if (!order.OrderItems.Any(i => i.Id == existingOrderItem.Id))
{
_dbContext.OrderItems.Remove(existingOrderItem);
}
}
// add/ update
foreach (var orderItem in order.OrderItems)
{
if (orderItem.Id > 0)
{
var existingOrderItem = existingOrder.OrderItems.First(i => i.Id == orderItem.Id);
_dbContext.Entry(existingOrderItem).CurrentValues.SetValues(orderItem);
}
else
{
existingOrder.OrderItems.Add(orderItem);
}
}
await _dbContext.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
public ActionResult Edit(Product product)
{
if (ModelState.IsValid)
{
db.Entry(product).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(db.Categories, "CategoryId", "Description", product.CategoryId);
ViewBag.VendorId = new SelectList(db.Vendors, "VendorId", "Name", product.VendorId);
return(View(product));
}
public ActionResult Edit([Bind(Include = "ComboProductId,ProductId,Quantity,ProductPrice,ProductCommision,ProductSettlement,ProductContractPrice")] ComboProductItem comboProductItem)
{
if (ModelState.IsValid)
{
db.Entry(comboProductItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ComboProductId = new SelectList(db.ComboProducts, "Id", "ComboCode", comboProductItem.ComboProductId);
ViewBag.ProductId = new SelectList(db.Products, "Id", "ProductName", comboProductItem.ProductId);
return(View(comboProductItem));
}
public ActionResult Edit([Bind(Include = "SaleId,ProductId,Quantity,UnitPrice")] SaleLineItem saleLineItem)
{
if (ModelState.IsValid)
{
db.Entry(saleLineItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProductId = new SelectList(db.Products, "Id", "ProductName", saleLineItem.ProductId);
ViewBag.SaleId = new SelectList(db.Sales, "SaleId", "SaleId", saleLineItem.SaleId);
return(View(saleLineItem));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,ProductName,ProductType,City,Spot,ValidStartDate,ValidEndDate,ProductCode,NeedFeedBack,Price,Commision,Borkerage,Settlement,ContractPrice,Cons,PartnerId,SupplierId")] Product product)
{
if (ModelState.IsValid)
{
db.Entry(product).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.PartnerId = new SelectList(db.Partners, "Id", "Name", product.PartnerId);
ViewBag.SupplierId = new SelectList(db.Suppliers, "Id", "SupplierName", product.SupplierId);
return(View(product));
}
public ActionResult <Order> PutOrder(long id, Order order)
{
if (id != order.Id)
{
return(BadRequest("Id cannot be modified!"));
}
try
{
OrderDb.Entry(order).State = EntityState.Modified;
OrderDb.SaveChanges();
}
catch (Exception e)
{
string error = e.Message;
if (e.InnerException != null)
{
error = e.InnerException.Message;
}
return(BadRequest(error));
}
return(NoContent());
}
public async Task <OrderDto> CreateOrderAsync(OrderDto order)
{
if (_context.Orders.Any())
{
order.Id = _context.Orders.Max(i => i.Id) + 1;
}
else
{
order.Id = 1;
}
order.LineItems.ForEach(item => item.OrderId = order.Id);
var entity = _mapper.Map <OrderEntity>(order);
_context.Entry(entity.Customer).State = EntityState.Unchanged;
await _context.Orders.AddAsync(entity);
await _context.SaveChangesAsync();
return(order);
}
public void Update(Order order)
{
_db.Order.Attach(order);
_db.Entry(order).State = EntityState.Modified;
}
public void SaveProduct(Product product)
{
dbContext.Entry(product).State = EntityState.Added;
dbContext.SaveChangesAsync();
}
public void Update(T obj)
{
table.Attach(obj);
_context.Entry(obj).State = EntityState.Modified;
}
