public async Task UpdateOrderAsync_UpdateOrderModel_ReturnsReadOrderModel(UpdateOrderModel model)
{
//Arrange
var order = OrderDumbData.GetEntity(model);
var categoriesList = CategoryDumbData.GetRandomEntities(2);
model.CategoryIds = categoriesList.Select(x => x.Id).ToList();
var expectedValue = _mapper.Map <ReadOrderModel>(order);
expectedValue.Categories = _mapper.Map <List <ReadCategoryModel> >(categoriesList);
var cancellationToken = new CancellationToken();
_orderRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>(), cancellationToken)).Returns(Task.FromResult(order));
_fileService.Setup(x => x.AddOrUpdateFileByIdAsync(It.IsAny <IFormFile>(), It.IsAny <Guid?>(), cancellationToken)).Returns(Task.FromResult((Guid?)expectedValue.IconId));
_categoryRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>(), cancellationToken)).Returns((Guid x) => Task.FromResult(categoriesList.FirstOrDefault(y => y.Id == x)));
_orderRepository.Setup(x => x.Update(It.IsAny <Order>()));
_unitOfWork.Setup(x => x.SaveChangesAsync(cancellationToken)).Returns(Task.CompletedTask);
// Act
var response = await _orderService.UpdateOrderAsync(model, order.Id, cancellationToken);
// Assert
_categoryRepository.Verify(x => x.GetByIdAsync(It.IsAny <Guid>(), cancellationToken), Times.Exactly(2));
_fileService.Verify(x => x.AddOrUpdateFileByIdAsync(It.IsAny <IFormFile>(), It.IsAny <Guid?>(), cancellationToken), Times.Once);
_orderRepository.Verify(x => x.GetByIdAsync(It.IsAny <Guid>(), cancellationToken), Times.Once);
_orderRepository.Verify(x => x.Update(It.IsAny <Order>()), Times.Once);
_unitOfWork.Verify(x => x.SaveChangesAsync(cancellationToken), Times.Once);
response.Should().BeEquivalentTo(expectedValue);
}
public UpdateOrderModel getOrderForEdit(int id)
{
UpdateOrderModel retValue;
ecom_Orders order = orderRepository.GetByID(id);
if (order != null)
{
retValue = new UpdateOrderModel()
{
Id = order.Id,
AddressOfRecipient = order.AddressOfRecipient,
FeeShip = order.FeeShip,
NameOfRecipient = order.NameOfRecipient,
OrderNote = order.OrderNote,
OrderStatus = order.OrderStatus,
PhoneOfRecipient = order.PhoneOfRecipient,
Status = order.Status,
DeliveryDate = order.DeliveryDate != null?((DateTime)order.DeliveryDate).ToString("dd/MM/yyyy"):""
};
return(retValue);
}
else
{
return(null);
}
}
public async Task <IActionResult> Update([FromBody] UpdateOrderModel updateOrderModel)
{
try
{
if (string.IsNullOrWhiteSpace(updateOrderModel.State))
{
return(BadRequest("State cannot be null!"));
}
var order = Uow.OrderRepository.Get(updateOrderModel.Id);
if (order == null)
{
return(NotFound("Order with given Id was not found!"));
}
var entity = Mapper.Map(updateOrderModel, order);
var updatedOrder = Uow.OrderRepository.Update(entity);
await Uow.CompleteAsync();
return(Ok(Mapper.Map <OrderModel>(Mapper.Map <OrderModel>(updatedOrder))));
}
catch (Exception e)
{
Console.WriteLine(e);
return(InternalServerError());
}
}
public Order UpdateOrder(UpdateOrderModel model)
{
var order = _context.Orders.Where(o => o.ID == model.OrderID)
.FirstOrDefault();
if (order == null)
{
return(null);
}
order.Status = model.Status;
if (order.Status == 3) // order is finished
{
// decrease quantity of products corresponding ordered items
var orderItems = _context.OrderItems.Where(i => i.OrderID == order.ID).ToList();
foreach (var item in orderItems)
{
var updatingProductVolume = _context.ProductVolumes
.Where(pv => pv.ProductID == item.ProductID && pv.VolumeValue == item.VolumeValue).FirstOrDefault();
updatingProductVolume.Quantity = updatingProductVolume.Quantity - item.Quantity;
_context.ProductVolumes.Update(updatingProductVolume);
}
}
_context.Orders.Update(order);
_context.SaveChanges();
return(order);
}
public IHttpActionResult Put(UpdateOrderModel updateOrderModel)
{
if (OrderService.AddCoordinateToOrder(updateOrderModel.OrderId, updateOrderModel.Coordinate))
{
return(Ok());
}
return(BadRequest());
}
public static Order GetEntity(UpdateOrderModel model)
{
return(new Order
{
Title = model.Title,
Description = model.Description,
Price = model.Price
});
}
public IActionResult UpdateOrder(UpdateOrderModel model)
{
var newOrder = _orderService.UpdateOrder(model);
if (newOrder == null)
{
return(NotFound(new { message = "Order not found!" }));
}
return(Ok(newOrder));
}
public IHttpActionResult UpdateOrder(UpdateOrderModel UpdateOrderModel)
{
try
{
var response = _iOrdersManagement.UpdateOrder(UpdateOrderModel);
return(Ok(response));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Update(UpdateOrderModel updateOrder)
{
var food = await _foodData.GetFood();
var order = await _orderData.GetOrderById(updateOrder.Id);
updateOrder.Total = updateOrder.Quantity * food.Where(f => f.Id == order.FoodId).First().Price;
await _orderData.UpdateOrderSP(updateOrder.Id, updateOrder.OrderName, updateOrder.Quantity, updateOrder.Total);
return(RedirectToAction("Display", new { updateOrder.Id }));
}
/// <summary>
/// To Update an Order
/// </summary>
/// <param name="UpdateOrderModel"></param>
/// <returns></returns>
public bool UpdateOrder(UpdateOrderModel UpdateOrderModel)
{
try
{
using (var dbContext = new OrderManagementEntities())
{
var products = new List <Product>();
var OrderStatusParentID = 1;
var userInfo = ValidateUser(UpdateOrderModel.UserID, dbContext);
if (!userInfo.isBuyer)
{
throw new Exception("Invalid User");
}
var orderInfo = dbContext.Orders.FirstOrDefault(x => x.UUID == UpdateOrderModel.OrderId);
if (orderInfo == null)
{
throw new Exception("Order Not found or Invalid Order");
}
if (orderInfo.UserID != userInfo.Id)
{
throw new Exception("Orders are not associated with give user");
}
var orderState = GetLookupValues(OrderStatusParentID, dbContext)
.FirstOrDefault(x => x.UUID == UpdateOrderModel.OrderState);
if (orderState == null)
{
throw new Exception("Invalid Order Status");
}
orderInfo.ShippingAddress = UpdateOrderModel.ShippingAddress;
orderInfo.Items = xmlSerialize(UpdateOrderModel.Items, dbContext, ref products, orderInfo);
orderInfo.OrderState = orderState.Id;
dbContext.Orders.Add(orderInfo);
dbContext.Entry(orderInfo).State = EntityState.Modified;
dbContext.SaveChanges();
//Updating Available Quantity of products
UpdateProductsAvailableQuantity(products);
return(true);
}
}
catch (Exception ex)
{
throw ex;
}
}
public ApiResponse <bool> UpdateOrder(int orderNo, UpdateOrderModel model)
{
if (orderNo < 0 || model == null)
{
throw new ApiBadRequestException("Bad request");
}
ApiResponse <bool> response = new ApiResponse <bool>()
{
Result = AskLeaveService.UpdateOrder(this.Member.Id, orderNo, model)
};
return(response);
}
public async Task <ReadOrderModel> UpdateOrderAsync(UpdateOrderModel model, Guid id, CancellationToken cancellationToken)
{
var order = await _orderRepository.GetByIdAsync(id, cancellationToken);
order.Title = model.Title;
order.Description = model.Description;
order.Price = model.Price;
order.IconId = await _fileService.AddOrUpdateFileByIdAsync(model.Icon, order.IconId, cancellationToken);
var categoryIds = order.Categories.Select(i => i.Category.Id).ToList();
foreach (var categoryId in categoryIds)
{
if (!model.CategoryIds.Contains(categoryId))
{
var orderCategory = order.Categories.First(i => i.Category.Id == categoryId);
order.Categories.Remove(orderCategory);
}
}
await _unitOfWork.SaveChangesAsync(cancellationToken);
foreach (var categoryId in model.CategoryIds)
{
if (!categoryIds.Contains(categoryId))
{
var category = await _categoryRepository.GetByIdAsync(categoryId, cancellationToken);
var orderCategory = new OrderCategory
{
Category = category,
Order = order
};
order.Categories.Add(orderCategory);
}
}
_orderRepository.Update(order);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ReadOrderModel>(order));
}
// GET: Admin/Order/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UpdateOrderModel order = orderService.getOrderForEdit((int)id);
if (order == null)
{
return(HttpNotFound());
}
ViewBag.Status = PopulateStatusDropDownList((Define.Status)order.Status);
ViewBag.OrderStatus = PopulateOrderStatusDropDownList((OrderStatus)order.OrderStatus);
return(View(order));
}
public async Task <OrderEntity> Update(Guid id, UpdateOrderModel model)
{
var order = Get(id);
if (order == null)
{
throw new NotFoundException($"Order with id: {id} not found");
}
order.Comments = model.Comments;
order.Amount = model.Amount;
order.CustomerEntityId = model.CustomerId;
order.ModifyUserId = model.ModifyUserId;
order.ModifyDate = DateTime.UtcNow.ToLocalTime();
order.StatusId = model.StatusId;
await _unitOfWork.CommitAsync();
return(order);
}
private static UpdateOrderModel CreateUpdateOrderRequest(string merchantData)
{
var orderRows = new List <OrderRow>
{
new OrderRow(
"ABC80",
"Computer",
MinorUnit.FromInt(4),
MinorUnit.FromDecimal(2000),
MinorUnit.FromDecimal(0),
MinorUnit.FromDecimal(6),
null,
null,
2)
};
var cart = new Cart(orderRows);
var updateModel = new UpdateOrderModel(cart, merchantData);
return(updateModel);
}
public async Task <IActionResult> UpdateOrderAsync([FromForm] UpdateOrderModel model, Guid orderId, CancellationToken cancellationToken)
{
var order = await _orderService.GetOrderByIdAsync(orderId, cancellationToken);
if (order == null)
{
return(NotFound());
}
var resultValidation = await _updateOrderModelValidator.ValidateAsync(model, cancellationToken);
resultValidation.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var item = await _orderService.UpdateOrderAsync(model, orderId, cancellationToken);
return(Ok(item));
}
public ActionResult Edit(UpdateOrderModel orderRequest)
{
if (ModelState.IsValid)
{
CultureInfo culture = CultureInfo.CreateSpecificCulture("vi-VN");
DateTimeStyles styles = DateTimeStyles.None;
DateTime outDeliveryDate;
if (!DateTime.TryParse(orderRequest.DeliveryDate, culture, styles, out outDeliveryDate))
{
return(View(orderRequest));
}
ecom_Orders updatedOrder = new ecom_Orders()
{
Id = orderRequest.Id,
FeeShip = orderRequest.FeeShip,
AddressOfRecipient = orderRequest.AddressOfRecipient,
NameOfRecipient = orderRequest.NameOfRecipient,
OrderNote = orderRequest.OrderNote,
PhoneOfRecipient = orderRequest.PhoneOfRecipient,
Status = orderRequest.Status,
OrderStatus = orderRequest.OrderStatus,
DeliveryDate = outDeliveryDate
};
bool result = orderService.UpdateOrder(updatedOrder);
if (result)
{
return(RedirectToAction("Index"));
}
else
{
return(View(orderRequest));
}
}
return(View(orderRequest));
}
public async Task <CommonResponseOrder> UpdateOrders(UpdateOrderModel updateOrderModel)
{
return(await ExecuteAll <CommonResponseOrder>("Crm.UpdateOrders", updateOrderModel));
}
/// <summary>
/// This request replaces the order rows of the specified order with the new appended in the call and sets the MerchantData on the order to the provided value.
/// <para>HTTP status code 200 indicates success, everything else indicates a failure.</para>
/// </summary>
/// <param name="orderId">The order Id you got from either <see cref="GetOrderAsync" /> or have stored since earlier</param>
/// <param name="data"><see cref="UpdateOrderModel" /></param>
/// <returns><see cref="CheckoutOrder" /></returns>
public async Task <SveaApiResponse <CheckoutOrder> > UpdateOrderAsync(long orderId, UpdateOrderModel data)
{
data.Validate();
string requestUrl = $"{_baseApiUrl}/api/orders/{orderId}";
AuthenticateRequest(data);
var updateOrderRequest = await ApiClient.PostAsync(requestUrl,
new StringContent(SveaUtils.ObjectToJsonConverter(data), Encoding.UTF8, "application/json")
);
return(await HandleResponse <CheckoutOrder>(updateOrderRequest));
}
public async Task <CommonResponseOrder> UpdateOrders(UpdateOrderModel updateOrderModel)
{
return(await _orderRepository.UpdateOrders(updateOrderModel));
}
public ActionResult Edit(UpdateOrderModel model)
{
var order = this.orderService.GetById(model.Id);
if (order == null)
{
this.TempData["Error"] = "Order can not be found";
this.Response.StatusCode = (int)HttpStatusCode.NotFound;
return this.View("Error");
}
if (order.UserId != this.User.Identity.GetUserId())
{
this.TempData["Error"] = "Order is not assigned to you";
this.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return this.RedirectToAction("Details", "ViewOrder", new { id = model.Id });
}
if (order.Status == Status.Delivered)
{
this.TempData["Error"] = "Delivered orders can not be updated";
this.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return this.RedirectToAction("Details", "ViewOrder", new { id = model.Id });
}
if (model.Status == Status.Delivered)
{
this.ModelState.AddModelError("Status", "Order can be set to status Delivered only through View Details menu");
}
if (model.Status == Status.Ready && string.IsNullOrEmpty(model.Solution))
{
this.ModelState.AddModelError("Soution", "Solution is required for orders with status Ready");
}
if (!this.ModelState.IsValid)
{
this.TempData["Error"] = "Input data errors. Look bellow";
return this.View(model);
}
order.ProblemDescription = model.ProblemDescription;
order.Solution = model.Solution;
order.Status = model.Status;
order.WarrantyStatus = model.WarrantyStatus;
order.LabourPrice = model.LabourPrice;
if (model.Status == Status.Ready)
{
order.RepairEndDate = DateTime.Now;
}
this.orderService.Update(order);
this.TempData["Success"] = "Order updated";
return this.RedirectToAction("Details", "ViewOrder", new { id = order.Id });
}
public async Task <ActionResult> UpdateOrder([FromBody] UpdateOrderModel model)
{
await _mediator.Send(new UpdateBuildingObjectsOrderCommand(model.Ids));
return(Ok());
}
/// <summary>
/// 修改申请信息
/// </summary>
/// <returns>修改状态</returns>
public bool UpdateOrder(int userId, int orderNo, UpdateOrderModel model)
{
using (var dbContext = new MissionskyOAEntities())
{
#region 申请信息
//查询申请信息是否存在
var orderEntities = dbContext.Orders.Where(o => o.OrderNo == orderNo);
var orderUsers = orderEntities.Select(o => o.UserId).ToArray();
var validateEntity = orderEntities.FirstOrDefault();
if (validateEntity == null)
{
Log.Error("申请记录不存在。");
throw new KeyNotFoundException("申请记录不存在。");
}
var validateOrder = validateEntity.ToModel();
//model转换
var applyModel = new ApplyOrderModel()
{
OrderType = validateOrder.OrderType,
StartDate = model.StartDate,
EndDate = model.EndDate,
IOHours = model.IOHours,
UserIds = orderUsers,
InformLeader = model.InformLeader,
WorkTransfer = model.WorkTransfer,
Recipient = model.Recipient
};
//var orderDet = new OrderDet()
//{
// StartDate = model.StartDate,
// EndDate = model.EndDate,
// StartTime = model.StartDate.TimeOfDay,
// EndTime = model.EndDate.TimeOfDay,
// Description = model.Description,
// InformLeader = model.InformLeader ?? false,
// WorkTransfer = model.WorkTransfer ?? false,
// Recipient = model.Recipient ?? 0,
// IOHours = model.IOHours
//};
//validateEntity.OrderDets = new List<OrderDet>() { orderDet };
//下一步审批人
var opprover =
dbContext.Users.FirstOrDefault(
it => validateEntity.NextAudit.HasValue && it.Id == validateEntity.NextAudit.Value);
#endregion
#region 验证
var validateMsg = string.Empty;
if (userId != validateOrder.ApplyUserId && (opprover != null && userId != opprover.Id))
{
Log.Error("用户不能修改申请单。");
throw new InvalidOperationException("用户不能修改申请单。");
}
if (DateTime.Compare(model.StartDate, DateTime.Now.AddDays(-15)) < 0)
{
validateMsg = "开始必须大于" + string.Format("{0:F}", DateTime.Now.AddDays(-15));
Log.Error(validateMsg);
throw new InvalidOperationException(validateMsg);
}
if (DateTime.Compare(model.StartDate, DateTime.Now.AddDays(15)) > 0)
{
validateMsg = "开始必须小于" + string.Format("{0:F}", DateTime.Now.AddDays(15));
Log.Error(validateMsg);
throw new InvalidOperationException(validateMsg);
}
if (model.StartDate >= model.EndDate)
{
validateMsg = "结束时间必须大于开始时间";
Log.Error(validateMsg);
throw new InvalidOperationException(validateMsg);
}
if (validateOrder.OrderType != OrderType.Overtime && validateOrder.OrderType != 0)
{
TimeSpan dspWorkingDayAm = DateTime.Parse("08:30").TimeOfDay;
TimeSpan dspWorkingDayPm = DateTime.Parse("18:30:59").TimeOfDay;
if (model.StartDate.TimeOfDay < dspWorkingDayAm)
{
throw new InvalidOperationException("开始时间必须大于等于上午8点半");
}
if (model.EndDate.TimeOfDay > dspWorkingDayPm)
{
throw new InvalidOperationException("结束时间必须小于等于下午6点半");
}
}
else
{
TimeSpan dspWorkingDayAm = DateTime.Parse("08:30").TimeOfDay;
if (model.StartDate.TimeOfDay < dspWorkingDayAm)
{
throw new InvalidOperationException("开始时间必须大于上午8点半");
}
}
var invalidUsers = IsOrderTimeAvailiable(applyModel, orderNo);
if (!string.IsNullOrEmpty(invalidUsers))
{
throw new InvalidOperationException(string.Format("用户({0})此申请时段已经占用。", invalidUsers));
}
#endregion
#region 更新信息
var existedUser = new List <int>(); //申请单原本已经有的用户
if ((int)OrderStatus.Apply == validateEntity.Status ||
(opprover != null && opprover.ToModel().IsAdminStaff))
{
#region 更新已存在的用户申请
orderEntities.ToList().ForEach(o =>
{
if (model.UserIds.Contains(o.UserId)) //更新用户申请单
{
OrderDet detailEntity = null;
if (o.OrderDets == null || o.OrderDets.Any() == false)
{
detailEntity = dbContext.OrderDets.FirstOrDefault(od => od.OrderId == o.Id);
}
else
{
detailEntity = o.OrderDets.FirstOrDefault();
}
//o.OrderType = (int)model.OrderType; 不能更新申请单类型
if (detailEntity != null)
{
detailEntity.StartDate = model.StartDate.Date;
detailEntity.EndDate = model.EndDate.Date;
detailEntity.IOHours = model.IOHours;
detailEntity.StartTime = model.StartDate.TimeOfDay;
detailEntity.EndTime = model.EndDate.TimeOfDay;
detailEntity.Description = model.Description;
detailEntity.InformLeader = model.InformLeader ?? detailEntity.InformLeader;
detailEntity.WorkTransfer = model.WorkTransfer ?? detailEntity.WorkTransfer;
detailEntity.Recipient = model.Recipient ?? detailEntity.Recipient;
}
existedUser.Add(o.UserId); //申请单原本已经有的用户
}
else //移除用户申请单
{
o.OrderDets.ToList().ForEach(d => dbContext.OrderDets.Remove(d)); //移出申请单详细
dbContext.Orders.Remove(o); //移出申请单
//o.Status = (int) OrderStatus.Canceled;
//o.NextAudit = 0;
//o.NextStep = 0;
}
});
#endregion
#region 添加新增用户申请
model.UserIds.ToList().ForEach(it =>
{
//validateOrder
if (!existedUser.Contains(it))
{
var newOrder = validateEntity.Copyto();
newOrder.UserId = it;
//如果是修改撤销单
if (validateEntity.RefOrderId.HasValue)
{
var refOrder = GetOrderDetail(dbContext, validateEntity.RefOrderId.Value, false);
if (refOrder != null)
{
newOrder.RefOrderId = _orderService.GetOrderIdByOrderNoAndUserId(dbContext,
refOrder.OrderNo, it);
}
}
dbContext.Orders.Add(newOrder);
}
});
#endregion
//发送工作交接通知
if (model.WorkTransfer.HasValue && model.WorkTransfer.Value && model.Recipient.HasValue && validateEntity.OrderType != (int)OrderType.Overtime)
{
_orderService.AddNotification(dbContext, validateEntity.ToModel());
}
dbContext.SaveChanges();
return(true);
}
else
{
Log.Error("已处于审批流程，不能更新。");
throw new InvalidOperationException("已处于审批流程，不能更新");
}
#endregion
}
}
