public async Task <IActionResult> Put([FromRoute] int id, [FromBody] OrderUpdateModel orderUpdateModel)
{
if (id != orderUpdateModel.Id)
{
return(BadRequest(new DataResult <int>
{
ResponseMessageType = ResponseMessageType.Error
}));
}
ValidationResult validationResult = _orderCreationalModelValidator.Validate(orderUpdateModel);
if (!validationResult.IsValid)
{
return(BadRequest(new DataResult <int>
{
ResponseMessageType = ResponseMessageType.Error
}));
}
DataResult <int> dataResult = await _orderService.UpdateOrder(orderUpdateModel);
if (dataResult.ResponseMessageType == ResponseMessageType.Error)
{
return(BadRequest(dataResult));
}
return(Ok(dataResult));
}
public async Task UpdateAsync_OrderValidationFailed_ThrowsError()
{
// Arrange
var fixture = new Fixture();
var order = new OrderUpdateModel();
var expected = fixture.Create <string>();
var bookGetService = new Mock <IBookGetService>();
bookGetService
.Setup(x => x.ValidateAsync(order))
.Throws(new InvalidOperationException(expected));
var clientGetService = new Mock <IClientGetService>();
clientGetService.Setup(x => x.ValidateAsync(order)).Throws(new InvalidOperationException(expected));
var orderDataAccess = new Mock <IOrderDataAccess>();
var orderGetService = new OrderUpdateService(orderDataAccess.Object, bookGetService.Object, clientGetService.Object);
// Act
var action = new Func <Task>(() => orderGetService.UpdateAsync(order));
// Assert
await action.Should().ThrowAsync <InvalidOperationException>().WithMessage(expected);
orderDataAccess.Verify(x => x.UpdateAsync(order), Times.Never);
}
public async Task UpdateAsync_OrderValidationSucceed_CreatesOrder()
{
// Arrange
var order = new OrderUpdateModel();
var expected = new Order();
var bookGetService = new Mock <IBookGetService>();
bookGetService.Setup(x => x.ValidateAsync(order));
var clientGetService = new Mock <IClientGetService>();
clientGetService.Setup(x => x.ValidateAsync(order));
var orderDataAccess = new Mock <IOrderDataAccess>();
orderDataAccess.Setup(x => x.UpdateAsync(order)).ReturnsAsync(expected);
var orderGetService = new OrderUpdateService(orderDataAccess.Object, bookGetService.Object, clientGetService.Object);
// Act
var result = await orderGetService.UpdateAsync(order);
// Assert
result.Should().Be(expected);
}
public HttpResponseMessage Update(OrderUpdateModel orderUpdateModel)
{
OrderDto orderDto = this.mapper.Map <OrderDto>(orderUpdateModel);
this.orderAppService.UpdateExistingOrder(orderDto);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task UpdateOrder(int number, OrderUpdateModel data)
{
var orderEntity = context.Orders.FirstOrDefaultAsync(order => order.OrderNumber == number).Result;
orderEntity.Status = data.Status;
orderEntity.CloseTime = data.CloseTime;
await context.SaveChangesAsync();
}
public async Task <Order> UpdateAsync(OrderUpdateModel order)
{
await BookGetService.ValidateAsync(order);
await CustomerGetService.ValidateAsync(order);
return(await OrderDataAccess.UpdateAsync(order));
}
public async Task <Order> InsertAsync(OrderUpdateModel order)
{
var result = await context.Orders.AddAsync(mapper.Map <Entities.Order>(order));
await context.SaveChangesAsync();
return(mapper.Map <Order>(result.Entity));
}
public async Task <OrderDTO> Edit([FromRoute] int?id, [FromBody] OrderUpdateModel updateModel)
{
if (id.HasValue && id != updateModel.Id)
{
throw new InvalidDataException(nameof(id));
}
return(Mapper.Map <OrderDTO>(await OrderUpdateService.UpdateAsync(Mapper.Map <OrderUpdateModel>(updateModel))));
}
public async Task <Order> CreateAsync(OrderUpdateModel order)
{
await ClientGetService.ValidateAsync(order);
await BookGetService.ValidateAsync(order);
return(await OrderDataAccess.InsertAsync(order));
}
public async Task <Order> InsertAsync(OrderUpdateModel order)
{
var result = await this.Context.AddAsync(this.Mapper.Map <DataAccess.Entities.Order>(order));
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Order>(result.Entity));
}
public void UpdateOrderStatus(OrderUpdateModel model)
{
Order order = _unitOfWork.Orders.Get(model.Id);
order.Status = model.Status;
order.ShipmentDate = model.ShipmentDate;
_unitOfWork.Orders.Update(order);
}
public async Task <IActionResult> Put([FromBody] OrderUpdateModel data)
{
var food = await _foodData.GetFood();
data.Total = data.Quantity * food.Where(x => x.Id == data.FoodId).First().Price;
await _orderData.UpdateOrder(data.Id, data.OrderName, data.FoodId, data.Quantity, data.Total);
return(Ok());
}
public async Task <IActionResult> Update([FromBody] OrderUpdateModel model)
{
_logger.LogInformation($"Update new videoGame : {HttpContext.Request.Query} ");
if (await _service.UpdateAsync(_mapper.Map <OrderDTO>(model)))
{
return(Ok());
}
return(BadRequest());
}
public Order MapBack(OrderUpdateModel model, Order existing)
{
existing.Id = model.Id;
existing.CustomerId = model.CustomerId;
existing.Comment = model.Comment;
existing.OrderStatus = model.OrderStatus;
return(existing);
}
public async Task <Order> CreateAsync(OrderUpdateModel order)
{
await BookGetService.ValidateAsync(order);
await CustomerGetService.ValidateAsync(order);
order.Date = DateTime.Now;
order.Arrived = false;
return(await OrderDataAccess.InsertAsync(order));
}
public async Task <Order> UpdateAsync(OrderUpdateModel order)
{
var existing = await this.Get(order);
var result = this.Mapper.Map(order, existing);
this.Context.Update(result);
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Order>(result));
}
public async Task <Order> UpdateAsync(OrderUpdateModel order)
{
var entity = await Get(order);
var result = mapper.Map(order, entity);
context.Update(result);
await context.SaveChangesAsync();
return(mapper.Map <Order>(result));
}
public async Task <OrderEntity> UpdateAsync(string orderNumber, OrderUpdateModel orderUpdateModel)
{
var order = this.parkingLotContext.Orders.FirstOrDefault(o => o.OrderNumber == orderNumber);
if (order != null && order.IsOpen == true)
{
order.IsOpen = orderUpdateModel.IsOpen;
order.CloseTime = DateTime.Now;
}
await this.parkingLotContext.SaveChangesAsync();
return(order);
}
public void UpdateOrder(string deviceToken, OrderUpdateModel model, Action success, Action <string> error)
{
var response =
RequestFactory.ExecuteRequest <MResponse <IList <object> > >(RestCalls.Instance.PostUpdateOrder(model));
response.OnResponse(() =>
{
GetOrder(deviceToken, (obj) =>
{
success?.Invoke();
}, (obj) => { });
},
exception => error?.Invoke(exception.Message));
}
public async Task Story1_AC5_Should_update_parkingLot_capacity()
{
// given
var parkingLot = new ParkingLot("Lot1", 10, "location1");
var closeTime = DateTime.Now;
var updateModel = new OrderUpdateModel(closeTime, Status.Close);
var order = new OrderRequest("Lot1", "JA00001");
// when
await parkingLotService.AddParkingLot(parkingLot);
await orderService.AddOrder(order);
await orderService.UpdateOrder(context.Orders.FirstOrDefaultAsync().Result.OrderNumber, updateModel);
// then
Assert.Equal(updateModel.Status, context.Orders.FirstOrDefaultAsync().Result.Status);
Assert.Equal(closeTime, context.Orders.FirstOrDefaultAsync().Result.CloseTime);
}
public async Task <IActionResult> Patch(int number, OrderUpdateModel data)
{
var orderFound = await orderService.GetOrderByNumber(number);
if (orderFound == null)
{
return(NotFound("unrecognized order number"));
}
var orderEntity = await orderService.GetOrderEntityByNumber(number);
if (orderEntity.Status == Status.Close)
{
return(BadRequest("car has leaved"));
}
await orderService.UpdateOrder(number, data);
return(NoContent());
}
public HttpResponseMessage Put(OrderUpdateModel order)
{
var updateOrder = Mapper.Map <Order>(order);
try
{
_orderService.UpdateOrder(updateOrder);
}
catch (StaffingPurchaseException ex)
{
_logger.Info(ex.Message);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
catch (Exception ex)
{
_logger.Error("Error when updating order", ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, _resourceManager.GetString(ExceptionResources.GeneralException)));
}
return(Request.CreateResponse());
}
public async Task Should_close_order_when_patch_order_with_close()
{
var client = GetClient();
var parkingLotDto = new ParkingLotDTO()
{
Name = "myLot1",
Capacity = 1,
Location = " ",
};
var httpContent = JsonConvert.SerializeObject(parkingLotDto);
StringContent content = new StringContent(httpContent, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PostAsync($"/parkinglots", content);
var orderDto = new OrderDTO()
{
ParkingLotName = "myLot1",
PlateNumber = "234",
};
var httpContent2 = JsonConvert.SerializeObject(orderDto);
StringContent content2 = new StringContent(httpContent2, Encoding.UTF8, MediaTypeNames.Application.Json);
var postResponse = await client.PostAsync($"/orders", content2);
var id = postResponse.Headers.Location.AbsoluteUri.Split("/")[4];
var orderUpdateModel = new OrderUpdateModel()
{
IsOpen = false,
};
var httpContent3 = JsonConvert.SerializeObject(orderUpdateModel);
StringContent content3 = new StringContent(httpContent3, Encoding.UTF8, MediaTypeNames.Application.Json);
await client.PatchAsync($"/orders/{id}", content3);
var scope = Factory.Services.CreateScope();
var scopedServices = scope.ServiceProvider;
var context = scopedServices.GetRequiredService <ParkingLotContext>();
var firstOrder = await context.Orders.FirstOrDefaultAsync();
Assert.False(firstOrder.IsOpen);
}
public async Task Story2_AC2_Should_update_order()
{
// given
var parkingLot = new ParkingLot("Lot1", 10, "location1");
var order = new OrderRequest("Lot1", "JA00001");
var closeTime = DateTime.Now;
var updateModel = new OrderUpdateModel(closeTime, Status.Close);
// when
await client.PostAsync("/parkinglots", content.GetRequestContent(parkingLot));
var responseAddOrder = await client.PostAsync("/orders", content.GetRequestContent(order));
var response = await client.PatchAsync(responseAddOrder.Headers.Location, content.GetRequestContent(updateModel));
var responseNotFound = await client.PatchAsync("error uri", content.GetRequestContent(updateModel));
// then
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
Assert.Equal(updateModel.Status, context.Orders.FirstOrDefaultAsync().Result.Status);
Assert.Equal(closeTime, context.Orders.FirstOrDefaultAsync().Result.CloseTime);
Assert.Equal(HttpStatusCode.NotFound, responseNotFound.StatusCode);
}
public async Task <IHttpActionResult> PutUpdateTasks(UpdateTaskModel utm)
{
try
{
var task = odb.Tasks.Find(utm.Id);
if (task == null)
{
return(NotFound());
}
var order = odb.Orders.FirstOrDefault(o => o.OrderCode == task.OrderCode);
if (order == null)
{
return(NotFound());
}
task.State = utm.State;
if (task.State == TaskState.Take)
{
task.TakeDate = DateTime.Now;
task.TakePerson = User.Identity.GetUserId();
if (order.OrderStatus != OrderStatus.Partion && order.OrderStatus != OrderStatus.Processing)
{
order.OrderStatus = OrderStatus.Processing;
}
order.Remark += DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + ":处理订单中\r\n";
}
if (task.State == TaskState.Finish)
{
var tasks = odb.Tasks.Where(o => o.OrderCode == task.OrderCode).ToList();
var d = tasks.Where(t => t.State == TaskState.Create || t.State == TaskState.Take).Count();
task.CompleteDate = DateTime.Now;
if (d == 0)
{
if (tasks.FindAll(ta => ta.State == TaskState.OrderErr).Count > 0)
{
order.OrderStatus = OrderStatus.DoneWithErr;
}
else
{
order.OrderStatus = OrderStatus.Done;
}
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + ":完成订单[" + utm.Remark + "]";
}
if (d > 0)
{
order.OrderStatus = OrderStatus.Partion;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + "出货成功[" + utm.Remark + "]";
}
}
if (task.State == TaskState.OrderErr)
{
var tasks = odb.Tasks.Where(o => o.OrderCode == task.OrderCode).ToList();
var d = tasks.Where(t => t.State == TaskState.Create || t.State == TaskState.Take).Count();
task.CompleteDate = DateTime.Now;
if (d == 0)
{
order.OrderStatus = OrderStatus.DoneWithErr;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + ":下单失败[" + utm.Remark + "]";
}
if (d > 0)
{
order.OrderStatus = OrderStatus.Partion;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + "出货失败[" + utm.Remark + "]";
}
}
if (task.State == TaskState.TakeCanceling)
{
task.TakeDate = DateTime.Now;
task.TakePerson = User.Identity.GetUserId();
var tasks = odb.Tasks.Where(o => o.OrderCode == task.OrderCode).ToList();
order.OrderStatus = OrderStatus.Canceling;
order.Remark += "\r\n" + task.ProductName + "处理取消";
}
if (task.State == TaskState.Canceled)
{
var tasks = odb.Tasks.Where(o => o.OrderCode == task.OrderCode).ToList();
var d = tasks.Where(t => t.State == TaskState.CreateCancel || t.State == TaskState.TakeCanceling).Count();
task.CompleteDate = DateTime.Now;
if (d == 0)
{
if (tasks.FindAll(ta => ta.State == TaskState.CancelFaild).Count > 0)
{
order.OrderStatus = OrderStatus.CancelFailed;
}
else
{
order.OrderStatus = OrderStatus.Canceled;
}
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + ":退单完成[" + utm.Remark + "]";
}
if (d > 0)
{
order.OrderStatus = OrderStatus.Canceling;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + "退货完成[" + utm.Remark + "]";
}
}
if (task.State == TaskState.CancelFaild)
{
var tasks = odb.Tasks.Where(o => o.OrderCode == task.OrderCode).ToList();
var d = tasks.Where(t => t.State == TaskState.CreateCancel || t.State == TaskState.TakeCanceling).Count();
task.CompleteDate = DateTime.Now;
if (d == 0)
{
order.OrderStatus = OrderStatus.CancelFailed;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + ":退单失败[" + utm.Remark + "]";
}
if (d > 0)
{
order.OrderStatus = OrderStatus.Canceling;
order.Remark += "\r\n" + DateTime.Now.ToString("yy-MM-dd hh:mm:ss") + task.ProductName + "退单失败[" + utm.Remark + "]";
}
}
task.TaskRemark = utm.Remark;
await odb.SaveChangesAsync();
OrderUpdateModel oum = new OrderUpdateModel();
oum.Id = order.Id;
oum.State = order.OrderStatus;
oum.Remark = order.Remark;
_changeState.SendUpdateTaskState(task);
_changeState.SendUpdateOrderState(oum);
return(Ok());
}
catch (Exception)
{
return(InternalServerError());
}
}
public async Task <IActionResult> Put([FromBody] OrderUpdateModel data)
{
await _orderData.UpdateOrderName(data.Id, data.OrderName);
return(Ok());
}
public async Task <IHttpActionResult> PutOrderStatus(Guid id)
{
string err = string.Empty;
try
{
var order = db.Orders.Include("OrderItems").FirstOrDefault(o => o.Id == id);
if (order.OrderStatus != OrderStatus.Partion)
{
///取消还未下单的订单
var tasks = db.Tasks.Include(t => t.Personinfos).Where(t => t.OrderCode == order.OrderCode).ToList();
if (tasks.Count > 0)
{
bool isCancelOrder = true;
foreach (var item in tasks)
{
if (item.State == TaskState.Create || item.State == TaskState.Take || item.State == TaskState.Change)
{
item.State = TaskState.Canceled;
await db.SaveChangesAsync();
_changeState.SendUpdateTaskState(item);
}
if (item.State == TaskState.Finish)
{
isCancelOrder = false;
TaskOrderModel tom = new TaskOrderModel();
tom.OrderCode = item.OrderCode;
tom.OrderItemId = item.OrderItemId;
tom.ProductCode = item.ProductCode;
tom.ProductFrom = item.ProductFrom;
tom.ProductName = item.ProductName;
tom.ProductType = item.ProductType;
tom.Quantity = item.Quantity;
tom.Remark = item.Remark;
tom.UsedEndDate = item.UsedEndDate;
tom.UsedStartDate = item.UsedStartDate;
foreach (var it in item.Personinfos)
{
tom.Personinfos.Add(it);
}
tom.State = TaskState.CreateCancel;
db.Tasks.Add(tom);
await db.SaveChangesAsync();
_changeState.SendUpdateTaskState(tom, true);
}
}
if (isCancelOrder)
{
order.OrderStatus = OrderStatus.Canceled;
order.Remark = order.Remark + "订单取消完成";
}
else
{
order.OrderStatus = OrderStatus.Cancel;
}
}
else
{
order.OrderStatus = OrderStatus.Canceled;
}
await db.SaveChangesAsync();
OrderUpdateModel oum = new OrderUpdateModel();
oum.Id = order.Id;
oum.State = order.OrderStatus;
oum.Remark = order.Remark;
_changeState.SendUpdateOrderState(oum);
}
}
catch (Exception)
{
return(InternalServerError());
}
return(Ok());
}
public ActionResult UpdateOrderStatus(int id, [FromBody] OrderUpdateModel status)
{
return(Ok(_orderService.UpdateOrder(id, status.Status)));
}
public void Put([FromBody] OrderUpdateModel model)
{
_orderServieces.UpdateOrderStatus(model);
}
public async Task <IHttpActionResult> PostOrderItemDetail(ChangeOrderItemModel coim)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var order = db.Orders.Where(o => o.Id == coim.OrderId).FirstOrDefault();
if (order == null)
{
return(NotFound());
}
if (order.OrderStatus == OrderStatus.Partion)
{
return(BadRequest());
}
try
{
OrderItem oi = new OrderItem();
oi.Id = Guid.NewGuid();
oi.ProductId = coim.OrderItem.ProductId;
oi.ProductType = coim.OrderItem.ProductType;
oi.CertificateDate = coim.OrderItem.CertificateDate;
oi.CertificateNum = coim.OrderItem.CertificateNum;
oi.CustomerPrice = 0;
oi.Describe = coim.OrderItem.Describe;
oi.EndDate = coim.OrderItem.EndDate;
oi.StartDate = coim.OrderItem.StartDate;
oi.TotalPrice = coim.OrderItem.TotalPrice;
oi.OrderId = coim.OrderId;
oi.Remark = coim.OrderItem.Remark;
oi.Quantity = coim.OrderItem.Quantity;
oi.Persons = new List <PersonInfo>();
foreach (var item in coim.OrderItem.Persons)
{
PersonInfo pi = item;
oi.Persons.Add(pi);
}
order.OrderItems.Add(oi);
order.OrderItems.First(o => o.Id == coim.OrderItem.Id).State = 1;
order.OrderStatus = OrderStatus.Partion;
order.Remark += "修改订单信息，重新下单";
db.SaveChanges();
string err = string.Empty;
TaskAdapter ta = new TaskAdapter();
var tasks = ta.OrderItem2Task(oi, order.OrderCode, db, ref err);
if (string.IsNullOrEmpty(err))
{
ta.SendTask2Group(tasks, _changeState.Group);
OrderUpdateModel oum = new OrderUpdateModel();
oum.Id = order.Id;
oum.State = order.OrderStatus;
oum.Remark = order.Remark;
_changeState.SendUpdateOrderState(oum);
}
else
{
throw new Exception(err);
}
}
catch (Exception)
{
return(InternalServerError());
}
return(Ok());
}
