public async Task Handle(OrderPaymentFailedIntegrationEvent @event) { _logger.LogInformation(" [x] OrderPaymentFailedIntegrationEvent: Creating new CancelOrderCommand."); var command = new CancelOrderCommand(orderId: @event.OrderId, reason: "Payment failed"); await _mediator.Send(command); }
public async Task <IActionResult> CancelOrderAsync([FromBody] CancelOrderCommand command, [FromHeader(Name = "x-requestid")] string requestId) { bool commandResult = false; if (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) { var requestCancelOrder = new IdentifiedCommand <CancelOrderCommand, bool>(command, guid); _logger.LogInformation( "----- Sending command: {CommandName} - {IdProperty}: {CommandId} ({@Command})", requestCancelOrder.GetGenericTypeName(), nameof(requestCancelOrder.Command.OrderNumber), requestCancelOrder.Command.OrderNumber, requestCancelOrder); commandResult = await _mediator.Send(requestCancelOrder); } if (!commandResult) { return(BadRequest()); } return(Ok()); }
public async Task CalcelOrderAsync(string id) { validator.VerifyId(id); var command = new CancelOrderCommand(Guid.Parse(id)); await commandBus.SendAsync(command); }
public void Handle_OrderNull_ThrowException() { var command = new CancelOrderCommand(); command.Order = null; Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await _handler.Handle(command, default)); }
public bool ValidateCancelOrderCommand(CancelOrderCommand orderCommand) { var order = _orderRepository.GetOrderById(orderCommand.OrderId.Id.ToString()); if (order != null) { if (order.TraderId.Equals(orderCommand.TraderId.Id.ToString(), StringComparison.InvariantCultureIgnoreCase)) { //check if order is already cancelled if (order.Status.Equals(OrderState.Cancelled.ToString())) { throw new InvalidOperationException("Order is already cancelled"); } //check if order is already filled if (order.Status.Equals(OrderState.Complete.ToString())) { throw new InvalidOperationException("Order is filled, cannot be cancelled"); } //this means command is valid return(true); } throw new InvalidOperationException("Order id doest not belong to the trader id."); } throw new ArgumentException("Invalid order id"); }
public void DispatchShouldExecuteHandler() { // Arrange. var command = new CancelOrderCommand(); var executed = false; var handler = A.Fake <ICommandHandler <CancelOrderCommand> >(); A.CallTo(() => handler.Handle(command)).Invokes(c => { executed = true; }).Returns(Task.FromResult(0)); var map = new MessageHandlerMap(); map.Add(typeof(CancelOrderCommand), handler.GetType()); var container = A.Fake <IContainer>(); A.CallTo(() => container.Resolve(handler.GetType())).Returns(handler); var dispatcher = new MessageDispatcher(container, map); // Act. dispatcher.Dispatch("CreateOrder", new Envelope <CancelOrderCommand>(command)).Wait(); // Assert. A.CallTo(() => handler.Handle(command)).MustHaveHappened(Repeated.Exactly.Once); Assert.True(executed); }
public async Task <IActionResult> CancelOrderAsync( [FromBody] CancelOrderCommand command, CancellationToken cancellationToken = default) { var commandResult = await _commandDispatcher.SendAsync <CancelOrderCommand, CancelOrderCommandResult>(command, cancellationToken); return(Ok(commandResult)); }
public async Task <ActionResult <CancelOrderCommandResponse> > CancelOrderAsync(Guid id) { var request = new CancelOrderCommand { Id = id }; var response = await _messageBus.SendAsync(request); return(Ok(response)); }
public async Task <ActionResult> CancelOrder([FromQuery] Guid id) { var command = new CancelOrderCommand(id); // Send the command await _endpointInstance.Send("Assignment.Orders", command); // Return the order return(Ok(id)); }
public void ShouldThrowOrderNotFoundException() { // Cancel Order Command var cancelOrderCommand = new CancelOrderCommand { OrderId = Guid.NewGuid().ToString() }; FluentActions.Invoking(() => SendAsync(cancelOrderCommand)).Should().Throw <OrderNotFoundException>(); }
public void ShouldRequireMinimumFields() { var command = new CancelOrderCommand(); FluentActions.Invoking(() => SendAsync(command)) .Should() .Throw <BaseValidationException>(); }
/// <summary> /// Cancels the order. /// </summary> /// <param name="cancelOrder">The cancel order.</param> /// <returns></returns> /// <exception cref="ArgumentNullException">cancelOrder</exception> public static void CancelOrder(OsEngine.Entity.Order order) { List<string> transactions = new List<string>(); transactions.Add(order.NumberMarket); CancelOrderCommand canselOrder = new CancelOrderCommand(_token.Token, transactions); clientTwo.CancelOrder(canselOrder); }
public async Task <IActionResult> Cancel([FromBody] CancelOrderCommand cmd) { Order order = await this._repository.Get(cmd.OrderId); order.Cancel(); await this._repository.SaveChanges(order); return(new OkResult()); }
public override async Task HandleAsync(CancelOrderIntegrationEvent @event) { var command = new CancelOrderCommand { OrderId = @event.OrderId }; await _bus.SendAsync(command); }
public void Handle_AlreadyCancelled_ThrowException() { var command = new CancelOrderCommand(); command.Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Cancelled }; Assert.ThrowsExceptionAsync <Exception>(async() => await _handler.Handle(command, default)); }
public async Task <IActionResult> CancelOrderAsync(Guid orderId) { var command = new CancelOrderCommand { OrderId = orderId }; await SendCommandAsync(command); return(Ok()); }
/// <summary> /// Cancels the order. /// </summary> /// <param name="cancelOrder">The cancel order.</param> /// <returns></returns> /// <exception cref="ArgumentNullException">cancelOrder</exception> public Task CancelOrder(CancelOrderCommand cancelOrder) { if (cancelOrder == null) { logger.LogError("No cancelOrder command provided"); throw new ArgumentNullException(nameof(cancelOrder)); } return(CancelOrderInternal(cancelOrder)); }
public async Task <IActionResult> Cancel(string id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var command = new CancelOrderCommand(id); return(await QueueCommandAsync(command)); }
public async Task Handle(CancelOrderCommand message, IMessageHandlerContext context) { var @event = mapper.Map <CancelOrderEvent>(message); var result = await eventContext.AddAsync($"Order {message.OrderId}", @event); @event.LogPosition = result.LogPosition; @event.NextExpectedVersion = result.NextExpectedVersion; await context.Publish(@event); }
public async Task <IActionResult> CancelOrderAsync([FromBody] CancelOrderCommand command, [FromHeader(Name = "x-requestid")] string requestId) { var commandResult = await _commandSender.SendCommand(command); if (!commandResult) { return(BadRequest()); } return(Ok()); }
public async Task <IActionResult> CancelOrder([FromBody] CancelOrderCommand command, [FromHeader(Name = "x-requestid")] string requestId) { bool commandResult = false; if (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) { var requestCancelOrder = new IdentifiedCommand <CancelOrderCommand, bool>(command, guid); commandResult = await _mediator.Send(requestCancelOrder); } return(commandResult ? (IActionResult)Ok() : (IActionResult)BadRequest()); }
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsNotCompleteOrCancelled_CommandWillBeValidated() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order); _persistanceRepository.SaveOrUpdate(model); CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId); ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository); Assert.True(validation.ValidateCancelOrderCommand(command)); }
public async Task <IActionResult> CancelOrder([FromBody] CancelOrderCommand command, [FromHeader(Name = "x-requestid")] string requestId) { IExecutionResult result = ExecutionResult.Failed(); if (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) { var order = await _queryProcessor.ProcessAsync(new GetOrderByOrderNumberQuery(command.OrderNumber), CancellationToken.None).ConfigureAwait(false); await _commandBus.PublishAsync(new CancelOrderCommand(new OrderId(order.OrderId), order.OrderNumber), CancellationToken.None); } return(result.IsSuccess ? (IActionResult)Ok() : (IActionResult)BadRequest()); }
public async Task <ActionResult <Result> > CancelOrderAsync([FromBody] CancelOrderDTO cancelOrderDTO) { var command = new CancelOrderCommand(cancelOrderDTO.OrderNumber); var commandResult = await _mediator.Send(command); if (commandResult.IsFailure) { return(BadRequest()); } return(Ok()); }
public async Task HandleAsync(CancelOrderCommand command) { var order = await _eventRepository.GetByIdAsync <Order>(command.OrderId); if (order == null) { throw new StocqresException("Order does not exist"); } order.CancelOrder(command.CancelReason); await _eventRepository.SaveAsync(order); }
public void Serialize_CancelOrderCommand() { var cancelOrder = new CancelOrderCommand("0000000000000000000000000000000000000000", new[] { "ID1" }) { RequestId = 123, }; var cancelOrderJson = instance.Serialize(cancelOrder); Assert.Contains(@"""event"":""cancelOrder""", cancelOrderJson); Assert.Contains(@"""token"":""0000000000000000000000000000000000000000""", cancelOrderJson); Assert.Contains(@"""reqid"":123", cancelOrderJson); Assert.Contains(@"""txid"":[""ID1""]", cancelOrderJson); }
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsCancelled_InvalidOperationException() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); order.OrderState = OrderState.Cancelled; OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order); _persistanceRepository.SaveOrUpdate(model); CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId); ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository); validation.ValidateCancelOrderCommand(command); }
private void RaiseCanExecuteChanged() { // order commands CancelOrderCommand.RaiseCanExecuteChanged(); HoldOrderCommand.RaiseCanExecuteChanged(); ReleaseHoldCommand.RaiseCanExecuteChanged(); CreateRmaRequestCommand.RaiseCanExecuteChanged(); CreateExchangeCommand.RaiseCanExecuteChanged(); CreateRefundCommand.RaiseCanExecuteChanged(); OnPropertyChanged("IconSource"); // shipment and RmaRequest commands OrderShipmentViewModels.ToList().ForEach(x => x.RaiseCanExecuteChanged()); // InnerItem.RmaRequests.ToList().ForEach(x => x.RaiseCanExecuteChanged()); }
public async Task <IActionResult> CancelOrderAsync([FromBody] CancelOrderCommand command, [FromHeader(Name = "x-requestid")] string requestId) { bool commandResult = false; if (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) { commandResult = await _mediator.Send(command); } if (!commandResult) { return(BadRequest()); } return(Ok()); }
public async Task Handle_InvokeExpectedMethods() { var command = new CancelOrderCommand(); command.Order = new Order() { Id = "id" }; _shipmentServiceMock.Setup(c => c.GetShipmentsByOrder("id")).ReturnsAsync(new List <Shipment>()); await _handler.Handle(command, default); _productReservationMock.Verify(c => c.CancelReservationsByOrderId("id"), Times.Once); _auctionMock.Verify(c => c.CancelBidByOrder("id"), Times.Once); _discountServiceMock.Verify(c => c.CancelDiscount("id"), Times.Once); _mediatorMock.Verify(c => c.Publish <OrderCancelledEvent>(It.IsAny <OrderCancelledEvent>(), default)); }