public void UpdateOrderRequestShouldWork()
{
// Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
// Creates a limit order
var security = _algorithm.Securities[Ticker];
var price = 1.12m;
security.SetMarketPrice(new Tick(DateTime.Now, security.Symbol, price, price, price));
var orderRequest = new SubmitOrderRequest(OrderType.Limit, security.Type, security.Symbol, 1000, 0, 1.11m, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Submit and process a limit order
var orderTicket = transactionHandler.Process(orderRequest);
transactionHandler.HandleOrderRequest(orderRequest);
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
var updateRequest = new UpdateOrderRequest(DateTime.Now, orderTicket.OrderId, new UpdateOrderFields());
transactionHandler.Process(updateRequest);
Assert.AreEqual(updateRequest.Status, OrderRequestStatus.Processing);
Assert.IsTrue(updateRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
transactionHandler.HandleOrderRequest(updateRequest);
Assert.IsTrue(updateRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
Assert.AreEqual(_algorithm.OrderEvents.Count, 2);
Assert.IsTrue(_algorithm.OrderEvents.TrueForAll(orderEvent => orderEvent.Status == OrderStatus.Submitted));
}
public async Task <Order> Add(UpdateOrderRequest createRequest)
{
var dbOrders = await _context.Orders.Where(h => h.Name == createRequest.Name).ToArrayAsync();
if (dbOrders.Length > 0)
{
throw new RequestedResourceHasConflictException("code");
}
var dbOrder = Mapper.Map <UpdateOrderRequest, DbOrder>(createRequest);
dbOrder.DateAccommodation = DateTime.UtcNow;
dbOrder.DateDestination = DateTime.UtcNow;
dbOrder.DateExecution = DateTime.UtcNow;
_context.Orders.Add(dbOrder);
await _context.SaveChangesAsync();
return(Mapper.Map <Order>(dbOrder));
}
/// <summary>
/// Updates the multi details.
/// </summary>
/// <param name="multidetailId">The multidetail identifier.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <APIResponse> UpdateOrders(int orderId, UpdateOrderRequest request)
{
try
{
var client = httpClientFactory.CreateClient(ECommerceServiceOperation.serviceName);
var param = JsonConvert.SerializeObject(request);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
var response = await client.PutAsync(servicesConfig.ECommerce + ECommerceServiceOperation.UpdateOrder(orderId), contentPost);
return(new APIResponse(response.StatusCode));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'UpdateBranch()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Handles a request to update order properties
/// </summary>
private OrderResponse HandleUpdateOrderRequest(UpdateOrderRequest request)
{
Order order;
OrderTicket ticket;
if (!_orders.TryGetValue(request.OrderId, out order) || !_orderTickets.TryGetValue(request.OrderId, out ticket))
{
Log.Error("BrokerageTransactionHandler.HandleUpdateOrderRequest(): Unable to update order with ID " + request.OrderId);
return(OrderResponse.UnableToFindOrder(request));
}
if (!CanUpdateOrder(order))
{
return(OrderResponse.InvalidStatus(request, order));
}
// modify the values of the order object
order.ApplyUpdateOrderRequest(request);
ticket.SetOrder(order);
bool orderUpdated;
try
{
orderUpdated = _brokerage.UpdateOrder(order);
}
catch (Exception err)
{
Log.Error(err);
orderUpdated = false;
}
if (!orderUpdated)
{
// we failed to update the order for some reason
order.Status = OrderStatus.Invalid;
return(OrderResponse.Error(request, OrderResponseErrorCode.BrokerageFailedToUpdateOrder, "Brokerage failed to update order with id " + request.OrderId));
}
return(OrderResponse.Success(request));
}
public async Task UpdateOrder_NotExistRequest_ThrowsNotFoundRequestException()
{
var id = Guid.NewGuid();
var orderItemId = Guid.NewGuid();
var updateRequest = new UpdateOrderRequest
{
Id = id,
OrderItems = new List <UpdateOrderItemRequest>
{
new UpdateOrderItemRequest
{
Id = orderItemId,
ProductId = _productRecords[0].Id,
Quantity = 40,
},
},
};
await Assert.ThrowsAsync <NotFoundRequestException>(() => Fixture.Orders.UpdateOrderAsync(updateRequest));
}
public void TestInvalidUpdateOrderId()
{
var updateFields = new UpdateOrderFields {
Quantity = 99, Tag = "Pepe", StopPrice = 77, LimitPrice = 55
};
var updateRequest = new UpdateOrderRequest(DateTime.Now, 11, updateFields);
var ticket = OrderTicket.InvalidUpdateOrderId(null, updateRequest);
Assert.AreEqual(ticket.OrderId, 11);
Assert.AreEqual(ticket.Quantity, 0);
Assert.AreEqual(ticket.Tag, "Pepe");
Assert.AreEqual(ticket.Status, OrderStatus.Invalid);
Assert.AreEqual(ticket.UpdateRequests.Count, 1);
Assert.AreEqual(ticket.UpdateRequests[0].Status, OrderRequestStatus.Error);
Assert.AreEqual(ticket.UpdateRequests[0].Response.ErrorCode, OrderResponseErrorCode.UnableToFindOrder);
Assert.AreEqual(ticket.UpdateRequests[0].OrderId, 11);
Assert.AreEqual(ticket.UpdateRequests[0].Quantity, 99);
Assert.AreEqual(ticket.UpdateRequests[0].Tag, "Pepe");
Assert.AreEqual(ticket.UpdateRequests[0].StopPrice, 77);
Assert.AreEqual(ticket.UpdateRequests[0].LimitPrice, 55);
}
public async Task <WebCallResult <Order> > UpdateOrderAsync(UpdateOrderRequest updateOrderRequest, CancellationToken ct = default)
{
if (!String.IsNullOrEmpty(updateOrderRequest.ClOrdId) && String.IsNullOrEmpty(updateOrderRequest.OrigClOrdId))
{
string clOrderId = updateOrderRequest.ClOrdId;
updateOrderRequest.OrigClOrdId = clOrderId;
updateOrderRequest.ClOrdId = null;
}
if (String.IsNullOrEmpty(updateOrderRequest.OrigClOrdId))
{
updateOrderRequest.Id.ValidateNotNull(nameof(updateOrderRequest.Id) + " (you have to send order id, parameter Id, received from Bitmex or your own identifier, parameter OrigClOrdId, sent on order posting)");
}
if (String.IsNullOrEmpty(updateOrderRequest.ClOrdId) && String.IsNullOrEmpty(updateOrderRequest.OrigClOrdId) && updateOrderRequest.ClOrdId == updateOrderRequest.OrigClOrdId)
{
updateOrderRequest.ClOrdId = null;
}
var parameters = updateOrderRequest.AsDictionary();
parameters.ValidateNotNull(nameof(updateOrderRequest));
return(await SendRequestAsync <Order>(GetUrl(OrderEndpoint), HttpMethod.Put, ct, parameters, true, false).ConfigureAwait(false));
}
public async Task <OrderModel> UpdateAsync(Guid id, UpdateOrderRequest request, CancellationToken token)
{
var model = await _repository.GetAsync(id, token);
model.ModificationDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
model.Status = request.Status;
model.Address = request.Address;
model.ClientName = request.ClientName;
model.Phone = request.Phone;
model.OrderDate = request.OrderDate;
model.OrderNumber = request.OrderNumber;
model.PaymentType = request.PaymentType;
model.IsCredit = request.IsCredit;
model.CreditMonthCount = request.CreditMonthCount;
model.FinalSum = request.FinalSum;
model.Comment = request.Comment;
await _repository.UpdateAsync(model, token);
return(model.ConvertTo <OrderModel>());
}
public async Task <IActionResult> UpdateOrder(string id, UpdateOrderRequest updateOrderRequest)
{
ObjectResult response;
try
{
var responseTask = await _orderService.UpdateOrder(updateOrderRequest);
response = new ObjectResult(responseTask)
{
StatusCode = (int)HttpStatusCode.OK
};
}
catch (HttpStatusCodeException e)
{
response = new ObjectResult(e.Error)
{
StatusCode = (int)e.StatusCode
};
}
return(response);
}
public async Task <IActionResult> Update([FromRoute] Guid orderId, [FromBody] UpdateOrderRequest request)
{
var userOwnsOrder = await _orderService.UserOwnsOrderAsync(orderId, HttpContext.GetUserId());
if (!userOwnsOrder)
{
return(BadRequest(new { error = "You do not own this order" }));
}
var order = await _orderService.GetOrderByIdAsync(orderId);
order.Amount = request.Amount;
var updated = await _orderService.UpdateOrderAsync(order);
if (updated)
{
return(Ok(order));
}
return(NotFound());
}
public async Task UpdateOrder_NotExistRequest_ThrowsNotFoundRequestException()
{
var id = Guid.NewGuid();
var orderItemId = Guid.NewGuid();
var updateRequest = new UpdateOrderRequest
{
Id = id,
OrderItems = new List <UpdateOrderItemRequest>
{
new UpdateOrderItemRequest
{
Id = orderItemId,
ProductId = _productRecords[0].Id,
Quantity = 40,
},
},
};
var updateApiResponse = await Fixture.Api.Orders.UpdateOrderAsync(updateRequest);
Assert.Equal(HttpStatusCode.NotFound, updateApiResponse.StatusCode);
}
public async Task <Order> Update(UpdateOrderRequest updateRequest)
{
var dbOrders = await _context.Orders.Where(o => o.Name == updateRequest.Name).ToArrayAsync();
if (dbOrders.Length > 0)
{
throw new RequestedResourceHasConflictException("code");
}
dbOrders = await _context.Orders.Where(o => o.OrderId == updateRequest.OrderId).ToArrayAsync();
var dbOrder = dbOrders.FirstOrDefault();
if (dbOrders == null)
{
throw new RequestedResourceNotFoundException();
}
Mapper.Map(updateRequest, dbOrder);
await _context.SaveChangesAsync();
return(Mapper.Map <Order>(dbOrder));
}
public Response <Order> UpdateOrder(UpdateOrderRequest request)
{
var orderQuery = _context.Order.Where(w => w.Id == request.Id);
if (orderQuery.FirstOrDefault() == null)
{
return(new Response <Order>()
{
Status = System.Net.HttpStatusCode.NoContent,
Message = "Id Not found"
});
}
;
var order = orderQuery.FirstOrDefault();
order.OrderName = request.OrderName;
order.Total = _getTotal(request);
order.OrderDate = request.OrderDate;
_context.Entry(order).State = EntityState.Modified;
_context.SaveChanges();
return(new Response <Order>());
}
/// <summary>
/// Returns true if the brokerage would allow updating the order as specified by the request
/// </summary>
/// <param name="security">The security of the order</param>
/// <param name="order">The order to be updated</param>
/// <param name="request">The requested update to be made to the order</param>
/// <param name="message">If this function returns false, a brokerage message detailing why the order may not be updated</param>
/// <returns>True if the brokerage would allow updating the order, false otherwise</returns>
public override bool CanUpdateOrder(Security security, Order order, UpdateOrderRequest request, out BrokerageMessageEvent message)
{
message = null;
// validate order quantity
if (request.Quantity != null && request.Quantity % security.SymbolProperties.LotSize != 0)
{
message = new BrokerageMessageEvent(BrokerageMessageType.Warning, "NotSupported",
Invariant($"The order quantity must be a multiple of LotSize: [{security.SymbolProperties.LotSize}].")
);
return(false);
}
// determine direction via the new, updated quantity
var newQuantity = request.Quantity ?? order.Quantity;
var direction = newQuantity > 0 ? OrderDirection.Buy : OrderDirection.Sell;
// use security.Price if null, allows to pass checks
var stopPrice = request.StopPrice ?? security.Price;
var limitPrice = request.LimitPrice ?? security.Price;
return(IsValidOrderPrices(security, order.Type, direction, stopPrice, limitPrice, ref message));
}
/// <summary>
/// Handles a request to update order properties
/// </summary>
private OrderResponse HandleUpdateOrderRequest(UpdateOrderRequest request)
{
Order order;
OrderTicket ticket;
if (!_orders.TryGetValue(request.OrderId, out order) || !_orderTickets.TryGetValue(request.OrderId, out ticket))
{
Log.Error("BrokerageTransactionHandler.HandleUpdateOrderRequest(): Unable to update order with ID " + request.OrderId);
return(OrderResponse.UnableToFindOrder(request));
}
if (!CanUpdateOrder(order))
{
return(OrderResponse.InvalidStatus(request, order));
}
// rounds off the order towards 0 to the nearest multiple of lot size
var security = _algorithm.Securities[order.Symbol];
order.Quantity = RoundOffOrder(order, security);
// verify that our current brokerage can actually update the order
BrokerageMessageEvent message;
if (!_algorithm.LiveMode && !_algorithm.BrokerageModel.CanUpdateOrder(_algorithm.Securities[order.Symbol], order, request, out message))
{
// if we couldn't actually process the order, mark it as invalid and bail
order.Status = OrderStatus.Invalid;
if (message == null)
{
message = new BrokerageMessageEvent(BrokerageMessageType.Warning, "InvalidOrder", "BrokerageModel declared unable to update order: " + order.Id);
}
var response = OrderResponse.Error(request, OrderResponseErrorCode.BrokerageModelRefusedToUpdateOrder, "OrderID: " + order.Id + " " + message);
_algorithm.Error(response.ErrorMessage);
HandleOrderEvent(new OrderEvent(order, _algorithm.UtcTime, 0m, "BrokerageModel declared unable to update order"));
return(response);
}
// modify the values of the order object
order.ApplyUpdateOrderRequest(request);
// rounds the order prices
RoundOrderPrices(order, security);
ticket.SetOrder(order);
bool orderUpdated;
try
{
orderUpdated = _brokerage.UpdateOrder(order);
}
catch (Exception err)
{
Log.Error(err);
orderUpdated = false;
}
if (!orderUpdated)
{
// we failed to update the order for some reason
var errorMessage = "Brokerage failed to update order with id " + request.OrderId;
_algorithm.Error(errorMessage);
HandleOrderEvent(new OrderEvent(order, _algorithm.UtcTime, 0m, "Brokerage failed to update order"));
return(OrderResponse.Error(request, OrderResponseErrorCode.BrokerageFailedToUpdateOrder, errorMessage));
}
return(OrderResponse.Success(request));
}
public Task <BaseResponse> UpdateOrder(UpdateOrderRequest request, int UserID)
{
throw new NotImplementedException();
}
public void Update_order_address()
{
PwintyApi api = new PwintyApi();
var result = CreateEmptyOrderWithValidAddress(api);
var updateRequest = new UpdateOrderRequest()
{
address1 = "new address 1",
id = result.id,
address2 = "new address 2",
addressTownOrCity = "newtown",
postalOrZipCode = "NN1 1NN",
recipientName = "mr new",
stateOrCounty = "NEWARK"
};
var updatedOrder = api.Order.Update(updateRequest);
Assert.AreEqual(updateRequest.address1,updatedOrder.address1);
Assert.AreEqual(updateRequest.address2,updatedOrder.address2);
Assert.AreEqual(updateRequest.addressTownOrCity,updatedOrder.addressTownOrCity);
Assert.AreEqual(updateRequest.postalOrZipCode,updatedOrder.postalOrZipCode);
Assert.AreEqual(updateRequest.recipientName,updatedOrder.recipientName);
Assert.AreEqual(updateRequest.stateOrCounty,updatedOrder.stateOrCounty);
}
public async Task <ActionResult> UpdateOrder([FromBody] UpdateOrderRequest request)
{
await _mediator.Send(request);
return(NoContent());
}
public override Task <UpdateOrderReply> UpdateOrder(UpdateOrderRequest request, ServerCallContext context)
{
repository.UpdateOrder(request.OrderId, request.Status);
return(Task.FromResult(new UpdateOrderReply()));
}
public async Task <IActionResult> UpdatePhotoOrder([FromRoute] long id, [FromBody] UpdateOrderRequest request)
{
await _photoService.ChangePhotoOrder(id, request.Order);
return(NoContent());
}
public override bool CanUpdateOrder(Security security, Order order, UpdateOrderRequest request, out BrokerageMessageEvent message)
{
message = new BrokerageMessageEvent(0, 0, "");
return(false);
}
public async Task UpdateOrder_ValidRequest_ReturnsResponse()
{
var product1Record = _productRecords[2];
var product2Record = _productRecords[3];
var orderRecord = _orderRecords[1];
var orderStatusId = orderRecord.OrderStatusId;
var updateRequest = new UpdateOrderRequest
{
Id = orderRecord.Id,
OrderItems = new List <UpdateOrderItemRequest>
{
new UpdateOrderItemRequest
{
Id = orderRecord.OrderItems.ElementAt(0).Id,
ProductId = product1Record.Id,
Quantity = 72,
},
new UpdateOrderItemRequest
{
Id = null,
ProductId = product2Record.Id,
Quantity = 84,
}
},
};
var updateResponse = await Fixture.Orders.UpdateOrderAsync(updateRequest);
Assert.Equal(updateRequest.Id, updateResponse.Id);
Assert.Equal(orderRecord.CustomerId, updateResponse.CustomerId);
Assert.Equal((OrderStatus)orderStatusId, updateResponse.Status);
Assert.NotNull(updateResponse.OrderItems);
Assert.Equal(updateRequest.OrderItems.Count, updateResponse.OrderItems.Count);
for (int i = 0; i < updateRequest.OrderItems.Count; i++)
{
var updateRequestOrderDetail = updateRequest.OrderItems[i];
var updateResponseOrderDetail = updateResponse.OrderItems[i];
if (updateRequestOrderDetail.Id != null)
{
Assert.Equal(updateRequestOrderDetail.Id, updateResponseOrderDetail.Id);
}
else
{
AssertUtilities.NotEmpty(updateResponseOrderDetail.Id);
}
Assert.Equal(updateRequestOrderDetail.ProductId, updateResponseOrderDetail.ProductId);
Assert.Equal(updateRequestOrderDetail.Quantity, updateResponseOrderDetail.Quantity);
Assert.Equal(OrderItemStatus.Allocated, updateResponseOrderDetail.Status);
}
var findRequest = new FindOrderRequest {
Id = updateResponse.Id
};
var findResponse = await Fixture.Orders.FindOrderAsync(findRequest);
Assert.Equal(updateResponse.Id, findResponse.Id);
Assert.Equal(updateResponse.CustomerId, updateResponse.CustomerId);
Assert.Equal(updateResponse.Status, updateResponse.Status);
Assert.NotNull(findResponse.OrderItems);
Assert.Equal(updateResponse.OrderItems.Count, findResponse.OrderItems.Count);
// TODO: VC: Do this later when use sequential guids
/*
* for (int i = 0; i < updateResponse.OrderItems.Count; i++)
* {
* var updateResponseOrderDetail = updateResponse.OrderItems[i];
* var findResponseOrderDetail = findResponse.OrderItems[i];
*
* Assert.Equal(updateResponseOrderDetail.Id, findResponseOrderDetail.Id);
* Assert.Equal(updateResponseOrderDetail.ProductId, findResponseOrderDetail.ProductId);
* Assert.Equal(updateResponseOrderDetail.Quantity, findResponseOrderDetail.Quantity);
* Assert.Equal(updateResponseOrderDetail.StatusId, findResponseOrderDetail.StatusId);
* }
*/
}
public Task <OrderInformation> UpdateOrder(UpdateOrderRequest updateOrderRequest)
{
throw new System.NotImplementedException();
}
public Task <OrderDto> Update(Guid id, [FromBody] UpdateOrderRequest __request)
{
__request.Id = id;
return(_service.Update(__request));
}
public WebCallResult <Order> UpdateOrder(UpdateOrderRequest updateOrderRequest) => UpdateOrderAsync(updateOrderRequest).Result;
/// <remarks/>
public void UpdateOrderAsync(UpdateOrderRequest UpdateOrderRequest, object userState) {
if ((this.UpdateOrderOperationCompleted == null)) {
this.UpdateOrderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateOrderOperationCompleted);
}
this.InvokeAsync("UpdateOrder", new object[] {
UpdateOrderRequest}, this.UpdateOrderOperationCompleted, userState);
}
public bool UpdateOrderStatus(int id, UpdateOrderRequest request)
{
return(PutRequest <bool>(_baseUrl + string.Format(ApiRoutes.Order.UpdateOrder, id), _token, GetHttpContent(request)));
}
/// <summary>
/// Returns true if the brokerage would allow updating the order as specified by the request
/// </summary>
/// <param name="security">The security of the order</param>
/// <param name="order">The order to be updated</param>
/// <param name="request">The requested update to be made to the order</param>
/// <param name="message">
/// If this function returns false, a brokerage message detailing why the order may not be updated
/// </param>
/// <returns>True if the brokerage would allow updating the order, false otherwise</returns>
public override bool CanUpdateOrder(Security security, Order order, UpdateOrderRequest request, out BrokerageMessageEvent message)
{
message = null;
return(true);
}
public async Task <Response <OrderResponse> > UpdateOrder(UpdateOrderRequest request)
{
var order = await _uow.Orders.FindAsync(new Guid(request.OrderId));
if (order == null)
{
return(new Response <OrderResponse>(ResponseStatus.NotFound, null, ResponseMessagesConstans.NotFound));
}
if (request.CalculateOrder != null)
{
var calculatedData = await CalculateOrder(request.CalculateOrder.Products, request.CalculateOrder?.TransportId, request.CalculateOrder?.PaymentId);
// if some servise date was changed - send email to user
var changedServices = new List <CalculatedOrderProduct>();
request.CalculateOrder.Products.ForEach(productRequest =>
{
if (productRequest.ServiceDate?.Date != null)
{
return;
}
var product = order.CalculatedData.Products.FirstOrDefault(p => p.Service?.Date != null && p.Product.Id.ToString() == productRequest.ProductId);
if (product?.Service?.Date != null && product.Service.Date.Value.Date != productRequest.ServiceDate.Value.Date)
{
changedServices.Add(product);
}
});
if (changedServices.Count() > 0)
{
var user = await _uow.Users.GetUser(request.RequestIdentity.UserEmail);
await _mailingLibrary.SendChangeServiceDay(order, changedServices, user);
}
order.CalculatedData = calculatedData;
}
if (request.Customer != null)
{
order.Customer.Personal = new UserPersonal
{
Address = request.Customer.Personal.Address,
Contact = request.Customer.Personal.Contact,
Firstname = request.Customer.Personal.Firstname,
Lastname = request.Customer.Personal.Lastname,
};
order.Customer.Company = request.Customer.Company != null ? new UserCompany
{
Address = request.Customer.Company.Address != null ? request.Customer.Company.Address : request.Customer.Personal.Address,
CompanyId = request.Customer.Company.CompanyId,
CompanyName = request.Customer.Company.CompanyName,
CompanyVat = request.Customer.Company.CompanyVat
} : null;
}
await _uow.Orders.FindAndReplaceAsync(order.Id, order);
var response = _mapService.MapOrder(order);
return(new Response <OrderResponse>(ResponseStatus.Ok, response));
}
/// <summary>
/// Update an order yet to be filled such as stop or limit orders.
/// </summary>
/// <param name="request">Request detailing how the order should be updated</param>
/// <remarks>Does not apply if the order is already fully filled</remarks>
public OrderTicket UpdateOrder(UpdateOrderRequest request)
{
return(ProcessRequest(request));
}
public async Task <IActionResult> UpdateOrders(int orderId, [FromBody] UpdateOrderRequest request)
{
var result = await orderService.UpdateOrders(orderId, request);
return(StatusCode((int)result.Code, result.Value));
}
public async Task <IActionResult> ModifyAsync(Guid id, [FromBody] UpdateOrderRequest request,
CancellationToken token)
{
return(Ok(await _orderService.UpdateAsync(id, request, token)));
}
/// <remarks/>
public void UpdateOrderAsync(UpdateOrderRequest UpdateOrderRequest) {
this.UpdateOrderAsync(UpdateOrderRequest, null);
}
