public async Task <IActionResult> PutOrder(int id, OrderUpdateRequest model)
{
if (id != model.Id)
{
return(BadRequest());
}
var order = await _orderRepository.GetOrderByIdAsync(id);
if (order == null)
{
return(NotFound());
}
order.Total = model.Total;
order.Placed = model.Placed;
order.Completed = model.Completed;
var updated = await _orderRepository.UpdateOrderAsync(order);
if (!updated)
{
return(NoContent());
}
var orderResponse = _mapper.Map <OrderResponse>(order);
return(Ok(orderResponse));
}
public async Task <IWrappedResponse <Order> > Update(int id, OrderUpdateRequest request)
{
#region security
// TODO add security
#endregion
//ToDo: Nach dem Matching dürfen die Aufträge nicht bearbeitet werden.
var order = _olmaOrderRepo.FindByCondition(i => i.Id == id)
.Include(i => i.DplNotes)
.SingleOrDefault();
if (order == null)
{
return(NotFound <Order>(id));
}
// apply value from update
Mapper.Map(request, order);
if (IsDplEmployee)
{
var dplNote = Mapper.Map <Olma.EmployeeNote>(request.DplNote);
order.DplNotes.Add(dplNote);
}
var response = _olmaOrderRepo.Update <Olma.Order, OrderUpdateRequest, Order>(id, request);
return(response);
}
/// <summary>
/// 修改订单
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static OrderUpdateResponse UpdateOrder(OrderUpdateBody body)
{
var request = new OrderUpdateRequest
{
Head = new HeadRequest
{
InvokeTime = DateTime.Now.ToString("yyyy-MM-dd"),
InvokeUser = key,
ProtocolVersion = "V1"
},
Body = body
};
string url = apiUrl + "order/update";
var result = dooPost(request, url).Result;
if (!string.IsNullOrEmpty(result.Data))
{
return(Base64Helper.Base64EncodeToObject <OrderUpdateResponse>(result.Data));
}
return(new OrderUpdateResponse {
Head = new HeadResponse {
Describe = "数据格式不正确"
}
});
}
public OrderUpdateResponse Update(OrderUpdateRequest request)
{
var response = new OrderUpdateResponse();
_facade.Update(request.Order);
return(response);
}
/// <summary>
/// 编辑方法
/// </summary>
/// <param name="info"></param>
/// <param name="id"></param>
/// <returns></returns>
public OrderUpdateResponse UpdateOrderInfo(OrderUpdateRequest request)
{
OrderUpdateResponse response = new OrderUpdateResponse();
OrderInfo orderInfo = new OrderInfo()
{
BoughtTime = request.BoughtTime,
OrderName = request.OrderName,
CommodityImg = request.CommodityImg,
OrderSize = request.OrderSize,
OrderCount = request.OrderCount,
YhId = request.YhId,
OrderPrice = request.OrderPrice,
OrderTypeId = request.OrderTypeId,
Consignee = request.Consignee,
ConsigneeTel = request.ConsigneeTel,
Staus = request.Staus,
CreateId = request.CreateId,
UpdateId = request.UpdateId,
CreateTime = request.CreateTime,
UpdateTime = request.UpdateTime
};
var res = dal.UpdateOrderInfo(orderInfo);
if (res > 0)
{
response.IsUpdateSuccess = 1;
response.Message = "添加成功";
}
else
{
response.IsUpdateSuccess = 0;
response.Message = "注册失败";
}
return(response);
}
private async Task SendData(OrderUpdateRequest data)
{
var serialized = data.Serialize();
var encoded = Encoding.UTF8.GetBytes(serialized);
var buffer = new ArraySegment <byte>(encoded, 0, encoded.Length);
await ClientWebSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
public Task<ActionResult<Order>> Patch(int id, [FromBody] OrderUpdateRequest request)
{
if (request != null && request.DplNote != null && _authData.GetUserRole() == UserRole.DplEmployee)
{
request.DplNote.UserId = _authData.GetUserId();
}
return this._ordersService.Update(id, request).Convert(this);
}
public IHttpActionResult OrderUpdate([FromBody] OrderUpdateRequest request)
{
string requestModel = JsonConvert.SerializeObject(request);
fileWriter("OrderUpdate", requestModel);
//string documentContents = getDocumentContents(Request.InputStream);
//fileWriter("TransactionCreationFromStream", documentContents);
return(Ok());
}
private PageResult UpdateOrder(OrderUpdateRequest request, Tbl_OTABusiness business)
{
string orderId = request.Body.OrderInfo.OrderId;
OrderUpdateResponse result = new OrderUpdateResponse
{
Head = HeadResult.V1,
};
var validResult = _orderService.ValidDataForOrderUpdateRequest(request);
if (!validResult.Status)
{
result.Head.Code = validResult.Code;
result.Head.Describe = validResult.Message;
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
var tbl_Order = _orderService.Get(orderId);
if (tbl_Order == null)
{
result.Head.Code = "116011";
result.Head.Describe = "修改订单异常，订单不存在";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
if (!tbl_Order.CanModify)
{
result.Head.Code = "116012";
result.Head.Describe = "修改订单异常，订单不能修改";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
if (tbl_Order.CanModify && tbl_Order.CanModifyTime < request.Body.OrderInfo.VisitDate.ToDataTime())
{
result.Head.Code = "116013";
result.Head.Describe = "修改订单异常，填写的游玩时间超过产品最后修改时间";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
try
{
_orderService.BeginTran();
_orderService.UpdateOrder(tbl_Order, request);
_orderDetailService.UpdateOrderDetail(request);
_orderService.CommitTran();
result.Body = new OrderUpdateResponseBody()
{
OrderId = tbl_Order.OrderNo
};
}
catch (Exception ex)
{
_orderService.RollbackTran();
result.Head.Code = "116014";
result.Head.Describe = "修改订单异常，订单修改失败";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
result.Head.Code = "000000";
result.Head.Describe = "成功";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
/// <summary>
/// 修改订单
/// </summary>
/// <param name="tbl_Order"></param>
/// <param name="request"></param>
public void UpdateOrder(Tbl_Order tbl_Order, OrderUpdateRequest request)
{
var person = request.Body.OrderInfo.ContactPerson;
tbl_Order.IDType = GetIdCardType(person.CardType);
tbl_Order.IDCard = person.CardNo;
tbl_Order.Mobile = person.Mobile;
tbl_Order.Linkman = person.Name;
tbl_Order.ValidityDateStart = request.Body.OrderInfo.VisitDate.ToDataTime();
tbl_Order.ValidityDateEnd = request.Body.OrderInfo.VisitDate.ToDataTime();
_orderRepository.Update(tbl_Order);
}
public OrderResponse Any(OrderUpdateRequest request)
{
if (Validator != null)
{
Validator.ValidateAndThrow(request, ApplyTo.Put);
}
OnBeforeOrderUpdateRequest(request);
var output = Repository.Update(request);
OnAfterOrderUpdateRequest(request, output);
return(output);
}
public async Task <IActionResult> Update(OrderUpdateRequest request, int orderId)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var result = await _orderService.Update(request);
if (result.IsSuccessed == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> Update([FromBody] OrderUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var Result = await _orderService.UpdateOrder(request);
if (Result == 0)
{
return(BadRequest());
}
return(Ok(Result));
}
/// <summary>
/// 更新订单详情
/// </summary>
/// <param name="request"></param>
public void UpdateOrderDetail(OrderUpdateRequest request)
{
var person = request.Body.OrderInfo.ContactPerson;
var orderDetails = GetList(request.Body.OrderInfo.OrderId);
foreach (var row in orderDetails)
{
row.IDCard = person.CardNo;
row.Mobile = person.Mobile;
row.Linkman = person.Name;
row.ValidityDateStart = request.Body.OrderInfo.VisitDate.ToDataTime();
row.ValidityDateEnd = request.Body.OrderInfo.VisitDate.ToDataTime();
_orderDetailRepository.Update(row);
}
}
public async Task <IActionResult> Update([FromRoute] int orderId, [FromForm] OrderUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
request.Id = orderId;
var affectedResult = await _OrderService.Update(request);
if (affectedResult == 0)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Edit(int id)
{
var result = await _orderApiClient.GetById(id);
var Request = new OrderUpdateRequest()
{
Id = id,
Address = result.Address,
mail = result.mail,
name = result.name,
Phone = result.Phone,
Status = result.Status
};
return(View(Request));
}
public async Task <IActionResult> Edit(OrderUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(View());
}
var result = await _orderApiClient.UpdateOrder(request);
if (result == 1)
{
TempData["result"] = "Cập đơn hàng thành công";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Cập nhật đơn hàng công");
return(View(request));
}
public async Task <IActionResult> Edit([FromForm] OrderUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
var result = await _orderService.UpdateOrder(request);
if (result)
{
//TempData["result"] = "Cập nhập sản phẩm thành công";
_notyf.Success("Cập nhập đơn hàng thành công");
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Cập nhập đơn hàng thất bại");
return(View(request));
}
public async Task <IActionResult> Edit(int id)
{
var order = await _orderService.GetById(id);
//load data
var editVm = new OrderUpdateRequest()
{
Id = order.Id,
OrderDate = DateTime.Now,
ShipAddress = order.ShipAddress,
ShipEmail = order.ShipEmail,
ShipName = order.ShipName,
Status = order.Status,
ShipPhoneNumber = order.ShipPhoneNumber
};
return(View(editVm));
}
public async Task <int> UpdateOrder(OrderUpdateRequest request)
{
var order = await _context.Orders.FindAsync(request.Id);
if (order == null)
{
throw new ShopException($" Khong tim thay don hang co Id: {request.Id}");
}
order.name = request.name;
order.mail = request.mail;
order.Address = request.Address;
order.Phone = request.Phone;
order.Status = request.Status;
var result = await _context.SaveChangesAsync();
return(result);
}
public OrderResponse Update(OrderUpdateRequest request)
{
using (var adapter = DataAccessAdapterFactory.NewDataAccessAdapter())
{
OnBeforeOrderUpdateRequest(adapter, request);
var entity = request.FromDto();
entity.IsNew = false;
entity.IsDirty = true;
if (adapter.SaveEntity(entity, true))
{
OnAfterOrderUpdateRequest(adapter, request);
return(new OrderResponse(entity.ToDto()));
}
}
throw new InvalidOperationException();
}
public override Task ReceiveAsync(WebSocket socket, WebSocketReceiveResult result, byte[] buffer)
{
var str = Encoding.Default.GetString(buffer, 0, result.Count);
OrderUpdateRequest orderRequest = str.Deserialze();
if (orderRequest?.OrderUpdateRequests != null)
{
var socketId = WebSocketConnectionManager.GetId(socket);
if (!OrderUpdateRequests.ContainsKey(socketId))
{
OrderUpdateRequests.TryAdd(socketId, orderRequest);
}
else
{
OrderUpdateRequests[socketId] = orderRequest;
}
}
return(Task.CompletedTask);
}
public async Task CanUpdateExistingOrder()
{
// If: we create a new order
OrderRequest orderRequest = this.CreateOrderRequestWithOnlyRequiredFields();
OrderResponse createdOrder = await this._orderClient.CreateOrderAsync(orderRequest);
// When: We attempt to update the order
OrderUpdateRequest orderUpdateRequest = new OrderUpdateRequest()
{
OrderNumber = "1337",
BillingAddress = createdOrder.BillingAddress
};
orderUpdateRequest.BillingAddress.City = "Den Haag";
OrderResponse updatedOrder = await this._orderClient.UpdateOrderAsync(createdOrder.Id, orderUpdateRequest);
// Then: Make sure the order is updated
Assert.AreEqual(orderUpdateRequest.OrderNumber, updatedOrder.OrderNumber);
Assert.AreEqual(orderUpdateRequest.BillingAddress.City, updatedOrder.BillingAddress.City);
}
public object Post(OrderUpdateRequest request)
{
var order = _orderDao.FindById(request.OrderId);
if (order == null || !order.IBSOrderId.HasValue)
{
throw new HttpError(HttpStatusCode.BadRequest, ErrorCode.OrderNotInIbs.ToString());
}
var success = _ibsServiceProvider.Booking(order.CompanyKey).UpdateDropOffInTrip(order.IBSOrderId.Value, order.Id, request.DropOffAddress);
if (success)
{
_commandBus.Send(new UpdateOrderInTrip {
OrderId = request.OrderId, DropOffAddress = request.DropOffAddress
});
}
return(success);
}
public ActionResult <ItemResponse <int> > Update(OrderUpdateRequest model)
{
int code = 200;
BaseResponse response = null;
try
{
int userId = _authService.GetCurrentUserId();
_service.Update(model, userId);
response = new SuccessResponse();
}
catch (Exception ex)
{
code = 500;
response = new ErrorResponse(ex.Message);
}
return(StatusCode(code, response));
}
public async Task <IActionResult> Update([FromBody] OrderUpdateRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingOrder = await _context.Order.SingleOrDefaultAsync(x => x.OrderId == model.OrderId);
if (existingOrder == null)
{
return(NotFound());
}
var order = _mapper.Map <Order>(model);
_context.Entry(existingOrder).CurrentValues.SetValues(order);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <int> UpdateOrder(OrderUpdateRequest request)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var sessions = _httpContextAccessor.HttpContext.Session.GetString("Token");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions);
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PutAsync($"/api/orders", httpContent);
if (response.IsSuccessStatusCode)
{
return(1);
}
return(0);
}
public async Task <int> Update(OrderUpdateRequest request)
{
var order = await _context.Orders.FindAsync(request.Id);
//var orderDetails = await (from o in _context.Orders
// join od in _context.OrderDetails on o.Id equals od.OrderId
// where od.OrderId == request.Id
// select od).ToListAsync();
if (order == null)
{
throw new EShopException($"Không thể tìm thấy một đơn hàng có id : {request.Id}");
}
//Update order
order.ShipName = request.ShipName;
order.OrderDate = DateTime.Now;
order.ShipAddress = request.ShipAddress;
order.ShipEmail = request.ShipEmail;
order.ShipPhoneNumber = request.ShipPhoneNumber;
order.Status = (OrderStatus)request.Status;
////Update OrderDetail <Feature>
//if (orderDetails.Count > 0)
//{
// //2 Save the order detail into Order Detail table
// foreach (var item in orderDetails)
// {
// foreach (var res in request.OrderDetails)
// {
// item.Price = res.Price;
// item.ProductId = res.ProductId;
// item.Quantity = res.Quantity;
// }
// }
//}
return(await _context.SaveChangesAsync());
}
/// <summary>
/// 修改订单
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public OrderUpdateResponse UpdateOrder(OrderUpdateBody body)
{
var request = new OrderUpdateRequest
{
Head = RequestHead(),
Body = body
};
string url = _website + "order/update";
var result = PostService(request, url);
if (!string.IsNullOrEmpty(result.Data))
{
return(Base64Helper.Base64EncodeToObject <OrderUpdateResponse>(result.Data));
}
return(new OrderUpdateResponse
{
Head = new HeadResponse
{
Code = "900001",
Describe = "数据格式不正确"
}
});
}
public async Task <bool> UpdateOrder(OrderUpdateRequest orderUpdate)
{
//1.Khởi tạo
var sessions = _httpContextAccessor.HttpContext.Session.GetString(SystemConstants.AppSettings.Token);
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration[SystemConstants.AppSettings.BaseAddress]);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions); //lấy token
var requestContent = new MultipartFormDataContent
{
{ new StringContent(orderUpdate.OrderDate.ToString()), "OrderDate" },
{ new StringContent(orderUpdate.ShipName.ToString()), "ShipName" },
{ new StringContent(orderUpdate.ShipAddress.ToString()), "ShipAddress" },
{ new StringContent(orderUpdate.ShipEmail.ToString()), "ShipEmail" },
{ new StringContent(orderUpdate.ShipPhoneNumber.ToString()), "ShipPhoneNumber" },
{ new StringContent(orderUpdate.Status.ToString()), "Status" }
};
var response = await client.PutAsync($"/api/Orders/" + orderUpdate.Id, requestContent);
return(response.IsSuccessStatusCode);
}
