// GET: Orders/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Order order = db.Orders.Find(id);
db.Entry(order).Reference(x => x.Client).Load();
db.Entry(order).Reference(x => x.Product).Load();
if (order.Client != null)
{
var client = db.Clients.FirstOrDefault(x => x.ID == order.Client.ID);
if (client != null)
{
ViewBag.Client = $"{client.Name} {client.LastName}";
}
}
if (order.Product != null)
{
var product = db.Products.FirstOrDefault(x => x.ID == order.Product.ID);
if (product != null)
{
ViewBag.Product = product.Name;
}
}
if (order == null)
{
return(HttpNotFound());
}
return(View(order));
}
public void DeleteById(Guid id)
{
var order = _context.Orders.FirstOrDefault(x => x.Id == id);
_context.Entry(order).State = EntityState.Deleted;
_context.SaveChanges();
}
public async Task <IHttpActionResult> Approve(int id, [FromBody] int estimatedTime)
{
var order = await _dbSet.Where(p => p.OrderID == id).SingleOrDefaultAsync();
if (order == null)
{
return(NotFound());
}
order.Approve(estimatedTime);
_dbSet.Attach(order);
_context.Entry(order).State = EntityState.Modified;
await _context.SaveChangesAsync();
var orderDTO = (OrderDTO) new OrderDTO().InjectFrom(order);
orderDTO.StatusDescription = ((OrderStatus)order.Status).ToString();
var endPoint = await _bus.GetSendEndpoint(_sendToUri);
await endPoint.Send <IApproveOrderCommand>(new
{
OrderID = order.OrderID,
EstimatedTime = order.EstimatedTime.Value,
Status = order.Status,
CorrelationId = order.CorrelationId,
Timestamp = DateTime.UtcNow
});
return(Ok(orderDTO));
}
public ActionResult <Order> PutOrder(int id, Order order)
{
if (id != order.OrderID)
{
return(BadRequest("Id cannot be modified!"));
}
try
{
orderDb.Entry(order).State = EntityState.Modified;
foreach (OrderDetail item in order.OrderDetails)
{
orderDb.Entry(item).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 void UpdateOrder(Order old_order, Order updated_order)
{
// Cannot change the ID, inherit it from the original item.
old_order.Id = updated_order.Id;
_context.Entry(old_order).CurrentValues.SetValues(updated_order);
_context.SaveChanges();
}
public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
public async Task UpdateAsync(T entity)
{
if (_dbContext.Entry(entity).State != EntityState.Modified)
{
_dbContext.Entry(entity).State = EntityState.Modified;
}
await _dbContext.SaveChangesAsync();
}
public ActionResult <Merchant> SetAccount(Merchant merchant)
{
try
{
orderDb.Entry(merchant).State = EntityState.Modified;
orderDb.SaveChanges();
}
catch (Exception e)
{
return(Content("修改失败"));
}
return(merchant);
}
public Customer SetAccountService(Customer customer)
{
Customer failCus = null;
try
{
orderDB.Entry(customer).State = EntityState.Modified;
orderDB.SaveChanges();
}
catch (Exception e)
{
return(failCus);
}
return(customer);
}
public async Task <IActionResult> PutOrder(int id, Order order)
{
if (id != order.OrderID)
{
return(BadRequest());
}
_context.Entry(order).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public override void Update(OrderItem entity)
{
OrderItem target = _Context.OrderItems.Where(c => c.Id == entity.Id).FirstOrDefault();
_Context.Entry(target).CurrentValues.SetValues(entity);
_Context.SaveChanges();
}
public async Task <IActionResult> PutOrderDetails([FromRoute] int id, [FromBody] OrderDetails orderDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderDetails.id)
{
return(BadRequest());
}
_context.Entry(orderDetails).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderDetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public override void Update(Product entity)
{
Product target = _Context.Products.Where(c => c.Id == entity.Id).FirstOrDefault();
_Context.Entry(target).CurrentValues.SetValues(entity);
_Context.SaveChanges();
}
public ActionResult Edit([Bind(Include = "Id,OrderDate,TableNumber,Details")] Order order, string submit)
{
// submitには押されたボタンのvalueが格納されます
if (submit == "Add Details")
{
// 明細追加が押された
order.Details.Add(new Detail()
{
OrderId = order.Id
});
return(View(order));
}
if (ModelState.IsValid)
{
var list = order.Details.Where(item => item.Id == 0).ToList();
foreach (var item in list)
{
db.Details.Add(item);
}
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(order));
}
public async Task <ActionResult <Order> > PutOrder(Guid?id, Order order)
{
if (id == null || order == null)
{
return(BadRequest());
}
var existingorder = await _context.Orders.FindAsync(id);
if (existingorder == null)
{
return(BadRequest(new { Message = $"Order with id:{id} does not exist" }));
}
order.Id = existingorder.Id;
_context.Entry(existingorder).CurrentValues.SetValues(order);
try
{
await _context.SaveChangesAsync();
return(Ok(new { Message = $"Order id:{existingorder.Id} updated" }));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IActionResult> PutGood(long id, Good good)
{
if (id != good.GoodId)
{
return(BadRequest());
}
_context.Entry(good).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GoodExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult <Order> PutOrder(string id, Order order)
{
if (id != order.Id)
{
return(BadRequest("Id cannot be modified!"));
}
try
{
var oldItems = orderDb.OrderItems.Where(item => item.OrderId == id);
orderDb.OrderItems.RemoveRange(oldItems);
orderDb.Entry(order).State = EntityState.Modified;
orderDb.OrderItems.AddRange(order.Items);
orderDb.SaveChanges();
}
catch (Exception e)
{
string error = e.Message;
if (e.InnerException != null)
{
error = e.InnerException.Message;
}
return(BadRequest(error));
}
return(NoContent());
}
public ActionResult <Order> PutOrder(long orderCode, Order updateOrder)
{
try
{
if (orderCode != updateOrder.OrderCode)
{
return(BadRequest("Order code can't be modified."));
}
//移除旧订单项
var oldItems = orderDb.OrderItems.Where(i => i.OrderId == orderCode);
orderDb.OrderItems.RemoveRange(oldItems);
//添加修改后的订单项
updateOrder.Items.ForEach(i => i.Commodity = null);
orderDb.OrderItems.AddRange(updateOrder.Items);
//订单标记为修改
orderDb.Entry(updateOrder).State = EntityState.Modified;
orderDb.SaveChanges();
}
catch (Exception e)
{
string errorMessage = e.Message;
if (e.InnerException.Message != null)
{
errorMessage = e.InnerException.Message;
}
return(BadRequest(errorMessage));
}
return(NoContent());
}
public Result Update(string Ext_Id)
{
Result res = new Result();
CompanyMaster companyMaster = new CompanyMaster();
try
{
using (var db = new OrderContext())
{
companyMaster = db.CompanieMasters.Where(c => c.Ext_Id.Equals(Ext_Id)).FirstOrDefault();
}
if (companyMaster != null)
{
using (var db = new OrderContext())
{
db.Entry(companyMaster).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
return(new Result {
type = ResultType.SUCCESS
});
}
catch (Exception e)
{
return(new Result {
type = ResultType.FAILED, message = e.Message
});
}
}
public Result <ResourceType> Delete(long id)
{
try
{
res = new Result <ResourceType>();
using (var db = new OrderContext())
{
ResourceType resourceType;
resourceType = db.ResourceTypes.Where(rt => rt.Id == id).FirstOrDefault();
if (resourceType != null)
{
db.Entry(resourceType).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
res.type = ResultType.SUCCESS;
}
else
{
res.type = ResultType.FAILED;
}
}
return(res);
}
catch (Exception e)
{
res.type = ResultType.FAILED;
return(res);
}
}
public ActionResult Edit(Order order, int[] selWork, int[] selMat)
{
Order newOrder = db.Orders.Find(order.Id);
newOrder.Number = order.Number;
newOrder.ZakazchikId = order.ZakazchikId;
newOrder.Materials.Clear();
if (selMat != null)
{
foreach (var m in db.Materials.Where(ma => selMat.Contains(ma.Id)))
{
newOrder.Materials.Add(m);
}
}
newOrder.Works.Clear();
if (selWork != null)
{
foreach (var w in db.Works.Where(wo => selWork.Contains(wo.Id)))
{
newOrder.Works.Add(w);
}
}
db.Entry(newOrder).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult <Order> UpdateOrder(long orderCode, Order updateOrder)
{
try
{
Order oldOrder = orderDb.Orders.
Include(o => o.Customer).
Include(o => o.Items).
ThenInclude(i => i.Commodity).
FirstOrDefault(order => order.OrderCode == orderCode);
if (oldOrder != null)
{
oldOrder.Customer = updateOrder.Customer;
oldOrder.Items = updateOrder.Items;
orderDb.Entry(oldOrder).State = EntityState.Modified;
orderDb.SaveChanges();
}
}
catch (Exception e)
{
string errorMessage = e.Message;
if (e.InnerException.Message != null)
{
errorMessage = e.InnerException.Message;
}
return(BadRequest(errorMessage));
}
return(NoContent());
}
public ActionResult Edit([Bind(Include = "Id,Email,Password,RoleId")] User user)
{
if (ModelState.IsValid)
{
string pwd = GetHash(user.Password);
db.Entry(user).State = EntityState.Modified;
user.Password = pwd;
db.SaveChanges();
// Обновление Логина в куках (by User.Identity.Name)
//при изменении логина
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1,
user.Email,
DateTime.Now,
DateTime.Now.AddMinutes(30),
false,
"someData",
FormsAuthentication.FormsCookiePath);
// encrypt the ticket
string encTicket = FormsAuthentication.Encrypt(ticket);
// create the cookie
Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
return(View(user));
}
ViewBag.RoleId = new SelectList(db.Roles, "Id", "Name", user.RoleId);
return(View(user));
}
public async Task <IActionResult> PutClient(int id, Client client)
{
if (id != client.Id)
{
return(BadRequest());
}
_context.Entry(client).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutProduct(int id, Product product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != product.Id)
{
return(BadRequest());
}
db.Entry(product).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutOrderModel(int id, OrderModel orderModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderModel.Id)
{
return(BadRequest());
}
db.Entry(orderModel).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult <Order> PutOrderItem(int id, Order order)
{
if (id != order.OrderId)
{
return(BadRequest("Do not modify id."));
}
try {
orderDB.Entry(order).State = EntityState.Modified;
orderDB.SaveChanges();
}
catch (Exception e) {
string error = e.InnerException != null ? e.InnerException.Message : e.Message;
return(BadRequest(error));
}
return(NoContent());
}
public async Task <T> UpdateAsync(T entity)
{
dbContext.Entry(entity).State = EntityState.Modified;
await dbContext.SaveChangesAsync();
return(entity);
}
public IHttpActionResult Update(int id, OrderItem orderItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderItem.Id)
{
return(BadRequest());
}
db.Entry(orderItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult <Order> UpdateOrder(int id, Order order)
{
if (id != order.OrderId)
{
return(BadRequest("Id cannot be modified!"));
}
try
{
orderDB.Entry(order).State = EntityState.Modified;
orderDB.SaveChanges();
}
catch (Exception error)
{
return(BadRequest(error.InnerException.Message));
}
return(NoContent());
}
