public ActionResult SaveData(OrderDetailChangeViewModel orderdetails)
{
if (orderdetails.updated != null)
{
foreach (var updated in orderdetails.updated)
{
_orderDetailService.Update(updated);
}
}
if (orderdetails.deleted != null)
{
foreach (var deleted in orderdetails.deleted)
{
_orderDetailService.Delete(deleted);
}
}
if (orderdetails.inserted != null)
{
foreach (var inserted in orderdetails.inserted)
{
_orderDetailService.Insert(inserted);
}
}
_unitOfWork.SaveChanges();
return(Json(new { Success = true }, JsonRequestBehavior.AllowGet));
}
public async Task <JsonResult> SaveData(OrderDetailChangeViewModel orderdetails)
{
if (orderdetails.updated != null)
{
foreach (var item in orderdetails.updated)
{
_orderDetailService.Update(item);
}
}
if (orderdetails.deleted != null)
{
foreach (var item in orderdetails.deleted)
{
_orderDetailService.Delete(item);
}
}
if (orderdetails.inserted != null)
{
foreach (var item in orderdetails.inserted)
{
_orderDetailService.Insert(item);
}
}
await _unitOfWork.SaveChangesAsync();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
public JsonResult Delete(string id = null)
{
var orderid = _orderDetailService.GetOrderDetailById(new Guid(id)).OrderID;
_orderDetailService.Delete(new Guid(id));
_orderDetailService.SaveChanges();
OrderViewModel model = null;
Order order = _orderService.GetOrderById(orderid);
order.Amount = _orderService.GetAmountOfOrder(orderid);
order.TotalCost = order.Amount - order.Discount;
_orderService.Update(order);
_orderService.SaveChanges();
model = Mapper.Map <Order, OrderViewModel>(order);
try
{
return(Json(new
{
status = true,
data = model
}));
}
catch (Exception ex)
{
return(Json(new
{
status = false
}));
}
}
public ActionResult OrderDetailDelete(int id)
{
var order = _orderDetailService.GetbyId(id);
_orderDetailService.Delete(order);
return(RedirectToAction("ListOrdered"));
}
public ActionResult Delete(int id)
{
var order = _orderService.GetById(id);
var result = false;
if (order != null)
{
var orderdetails = _orderDetailService.GetOrderById(order.Id);
foreach (var orderdetail in orderdetails)
{
_orderDetailService.Delete(orderdetail);
}
result = _orderService.Delete(order);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public ActionResult OrderDetailGrid_Destroy([DataSourceRequest] DataSourceRequest request, OrderDetailItem detailItem)
{
if (detailItem != null)
{
_orderDetailService.Delete(detailItem);
this.ShowNotification(NotificationType.Success, "Detail item was successfully removed from Order.");
}
return(Json(ModelState.ToDataSourceResult(), JsonRequestBehavior.AllowGet));
}
public IActionResult Detele(Guid id)
{
var res = _orderDetailService.Delete(id);
if (res > 0)
{
return(StatusCode(200));
}
return(NoContent());
}
public void Delete(int id)
{
var orderDetails = _orderDetailService.GetAll();
var orderDetail = orderDetails.Where(x => x.OrderDetailsId == id);
foreach (var item in orderDetail)
{
_orderDetailService.Delete(item);
}
}
public IActionResult Delete(OrderDetail orderDetail)
{
var result = _orderDetailService.Delete(orderDetail);
if (result.Success)
{
return(Ok());
}
return(BadRequest());
}
public IActionResult Delete(int orderDetailId)
{
var result = _orderDetailService.Delete(orderDetailId);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ValidationResult Remove(OrderDetail orderDetail)
{
BeginTransaction();
ValidationResult.Add(_service.Delete(orderDetail));
if (ValidationResult.IsValid)
{
Commit();
}
return(ValidationResult);
}
public HttpResponseMessage Delete(HttpRequestMessage request, int id)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var oldOrderDetail = _orderDetailService.Delete(id);
_orderDetailService.Save();
var responseData = Mapper.Map <OrderDetail, OrderDetailViewModel>(oldOrderDetail);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public bool Delete(int id)
{
var entity = _OrderDetailService.GetOrderDetailById(id);
if (entity == null)
{
return(false);
}
if (_OrderDetailService.Delete(entity))
{
return(true);
}
return(false);
}
public ActionResult Delete(int id, FormCollection collection)
{
IOrderDetailService service = ServiceFactory.GetOrderDetailService();
//Product product = service.Get(id);
try
{
service.Delete(id);
// TODO: Add delete logic here
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public HttpResponseMessage Delete(HttpRequestMessage request, int id)
{
return(CreateHttpRespone(request, () =>
{
HttpResponseMessage respone = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
_TagService.Delete(id);
_TagService.SaveChanges();
respone = request.CreateResponse(HttpStatusCode.OK);
}
return respone;
}));
}
public IActionResult KendoDestroy([DataSourceRequest] DataSourceRequest request, OrderDetailModel model)
{
string deleteMessage = string.Empty;
try
{
_service.Delete(model.OrderDetailId);
}
catch (Exception ex)
{
deleteMessage = CommonHelper.GetErrorMessage(ex);
}
ModelState.Clear();
if (!string.IsNullOrEmpty(deleteMessage))
{
ModelState.AddModelError(deleteMessage, deleteMessage);
}
return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
}
public IActionResult Delete(int id)
{
_orderDetailService.Delete(id);
return Ok();
}
public ActionResult Delete(Guid id)
{
_orderDetailService.Delete(id);
return(RedirectToAction("Index"));
}
public bool Delete(long id)
{
orderDetailService = OrderDetailService.Instance;
return(orderDetailService.Delete(id));
}
private void RemoveOrderDetail(object sender, EventArgs e)
{
_orderDetailService.Delete(_viewModel.SelectedCutItem.OrderDetailId);
}
public ActionResult Delete(int id, int IdOrderDetail, int IdSchedule)
{
string error = _orderDetailService.Delete(IdOrderDetail);
return(RedirectToAction("EditOrder", new { id = id, IdSchedule = IdSchedule }));
}
public IHttpActionResult Delete(Guid key)
{
_orderDetailService.Delete(key);
_unitOfWorkAsync.Commit();
return(StatusCode(HttpStatusCode.OK));
}
