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); }