public void Handle(OrderCancelled message) { // grab the order only if within the timeout length var order = Data.Orders.FirstOrDefault(o => o.Id == message.OrderId && message.DateOccurred.Subtract(o.Date) <= TimeSpan.FromMinutes(MinutesToWaitForCancel)); // if no order found throw away cancellation (or talk to the business and see what they want to do with it) if (order == null) { Console.WriteLine("------------------"); Console.WriteLine("Order already completed, can't be cancelled: " + message.OrderId); Console.WriteLine("------------------"); return; } // deposit the amount back to the balance Data.Balance += order.Amount; // remove the order Data.Orders.Remove(order); Console.WriteLine("------------------"); Console.WriteLine("Order Cancelled: " + message.OrderId); PrintBalance(); Console.WriteLine("------------------"); }
private void OnOrderCancelled(OrderCancelled evt) { var order = GetOrder(evt); order.State = "Cancelled"; order.LastEventNumber = evt.Metadata.EventNumber; _ctx.SaveChanges(); }
public void Handle(OrderCancelled message) { Data.OrderId = message.OrderId; Data.OrderCancelled = true; LogManager.GetLogger(typeof(ShippingSaga)) .Info("Shipping cancelled. " + message.OrderId); CheckIfComplete(); }
public Task Handle(OrderCancelled @event, CancellationToken cancellationToken) { if ([email protected]) { return(Task.CompletedTask); } return(commandBus.Send(DiscardPayment.Create(@event.PaymentId.Value))); }
public void When(OrderCancelled e) { writer.Update <OrdersView>(e.Id, v => { v.Version = e.Version; v.UpdatedOn = e.CreatedOn; v.Status = OrderStatus.Cancelled; }); }
public string createJson(string orderId, string sellerId, string cancellationOrigin, string cancellationReason) { var obj = new OrderCancelled(); obj.OrderId = orderId; obj.SellerId = sellerId; obj.CancellationOrigin = cancellationOrigin; obj.CancellationReason = cancellationReason; return(JsonSerializer.Serialize(obj)); }
private void OnMessage(OrderCancelled @event) { this.EventCount++; this.Logger.LogInformation(LogId.Trading, $"{Received}{Event} {@event}."); this.ProcessOrderEvent(@event); this.ClearModifyBuffer(@event.OrderId); this.CancelExpiryBackup(@event.OrderId); this.SendToEventPublisher(@event); }
public Task Handle(CancelOrder message, IMessageHandlerContext context) { log.Info($"Received the CancelOrder command for {message.OrderId}. Cancelling the order."); MarkAsComplete(); var orderCancelled = new OrderCancelled { OrderId = message.OrderId }; return(context.Publish(orderCancelled)); }
public async Task Handle(CancelOrder message, IMessageHandlerContext context) { log.Info($"Order #{message.OrderId} was cancelled."); //TODO: Possibly publish an OrderCancelled event? var orderCancelled = new OrderCancelled { OrderId = message.OrderId }; await context.Publish(orderCancelled); MarkAsComplete(); }
public void Handle(OrderCancelled @event) { using (var context = _contextFactory.Invoke()) { var orderReport = context.Find <OrderReportDetail>(@event.SourceId); if (orderReport != null) { orderReport.OrderStatus.OrderIsCancelled = true; } context.Save(orderReport); } }
public void Cancel(OrderCancellationReason cancellationReason) { if (OrderStatus.Closed.HasFlag(Status)) { throw new InvalidOperationException($"Cannot cancel a closed order."); } var @event = OrderCancelled.Create(Id, PaymentId, cancellationReason, DateTime.UtcNow); Enqueue(@event); Apply(@event); }
private void Apply(OrderCancelled obj) { _state = OrderAggregate.OrderState.Cancelled; var reservedOrders = _orderLines.Values.Where(ol => _reservations.Any(r => r.Key == ol.ProductId && r.Value)); foreach (var ol in reservedOrders) { DispatchCommand <ProductAggregate>(new CancelProductReservation(ol.ProductId, ol.Quantity)); } DispatchCommand <DummyNotifier>(new NotifyCustomer(AggregateRepository.CreateGuid())); }
public Task Handle(CancelOrder message, IMessageHandlerContext context) { logger.Info($"Received CancelOrder, OrderId = {message.OrderId}"); // This is normally where some business logic would occur var orderCancelled = new OrderCancelled { OrderId = message.OrderId }; return(context.Publish(orderCancelled)); }
public CommandHandlingResult Cancel() { if (this.Status != OrderStatus.InProgress && this.Status != OrderStatus.Completed) { return(CommandHandlingResult.Fail("Error: only in progress and completed orders can be cancelled.")); } var e = new OrderCancelled(this.OrderNumber); Handle(e); return(CommandHandlingResult.Success(e)); }
public void ProcessEvent() { OrderCancelled orderCancelled = JsonSerializer.Deserialize <OrderCancelled>(JsonString); var db = mongo.GetDatabase("SellersDatabase"); var collection = db.GetCollection <Object>("SellersOrders"); var findSellerFilter = Builders <Object> .Filter.Eq("SellerId", orderCancelled.SellerId); var sellerDocument = (Seller)collection.Find <Object>(findSellerFilter).FirstOrDefault(); if (sellerDocument == null) { Seller seller = new Seller(); seller.SellerId = orderCancelled.SellerId; collection.InsertOne(seller); sellerDocument = (Seller)collection.Find <Object>(findSellerFilter).FirstOrDefault(); } var findOrderFilter = Builders <Object> .Filter.Eq("OrderId", orderCancelled.OrderId); var orderDocument = (Order)collection.Find <Object>(findOrderFilter).FirstOrDefault(); if (orderDocument == null) { try { // adding a new order Order order = new Order(); order.OrderId = orderCancelled.OrderId; order.CancellationOrigin = orderCancelled.CancellationOrigin; order.CancellationReason = orderCancelled.CancellationReason; order.SellerId = sellerDocument.Id.ToString(); // insert collection.InsertOne(order); } catch (Exception e) { Console.WriteLine(e.Message); } } else { // update information in the order var updmanyresult = collection.UpdateMany( Builders <Object> .Filter.Eq("OrderId", orderCancelled.OrderId), Builders <Object> .Update .Set("CancellationOrigin", orderCancelled.CancellationOrigin) .Set("CancellationReason", orderCancelled.CancellationReason)); } }
public Task Handle(CancelOrder message, IMessageHandlerContext context) { MarkAsComplete(); log.Info($"Order #{message.OrderNumber} was cancelled."); var orderCancelled = new OrderCancelled { OrderNumber = message.OrderNumber, ClientId = message.ClientId }; return(context.Publish(orderCancelled)); }
private async void Handle(OrderCancelled e) { Console.WriteLine($"Order #{e.OrderNumber} cancelled."); using (var dbContext = new StoreDBContext()) { var order = dbContext.Orders.FirstOrDefault(o => o.OrderNumber == e.OrderNumber); if (order != null) { dbContext.Orders.Remove(order); await dbContext.SaveChangesAsync(); } } }
public void Cancel(string reason) { if (this.isCancelled) { throw new InvalidOperationException("Order already cancelled"); } var @event = new OrderCancelled { CustomerId = this.customerId.Value, OrderId = this.orderNumber.Value, Reason = reason }; this.Apply(@event); }
public Task Handle(CancelOrder message, IMessageHandlerContext context) { if (DebugFlagMutator.Debug) { Debugger.Break(); } log.Info($"Order #{message.OrderNumber} was cancelled."); MarkAsComplete(); var orderCancelled = new OrderCancelled { OrderNumber = message.OrderNumber, ClientId = message.ClientId }; return(context.Publish(orderCancelled)); }
internal void CanSerializeAndDeserialize_OrderCancelledEvents() { // Arrange var order = new StubOrderBuilder().BuildStopLimitOrder(); var cancelled = new OrderCancelled( AccountId.FromString("FXCM-02851908-DEMO"), order.Id, StubZonedDateTime.UnixEpoch(), Guid.NewGuid(), StubZonedDateTime.UnixEpoch()); // Act var packed = this.serializer.Serialize(cancelled); var unpacked = (OrderCancelled)this.serializer.Deserialize(packed); // Assert Assert.Equal(cancelled, unpacked); this.Output.WriteLine(Convert.ToBase64String(packed)); }
public void Handle(CancelOrder message) { if (DebugFlagMutator.Debug) { Debugger.Break(); } MarkAsComplete(); var orderCancelled = new OrderCancelled { OrderNumber = message.OrderNumber, ClientId = message.ClientId }; Bus.Publish(orderCancelled); log.Info($"Order #{message.OrderNumber} was cancelled."); }
public async Task Handle(CancelOrder message, IMessageHandlerContext context) { if (DebugFlagMutator.Debug) { Debugger.Break(); } MarkAsComplete(); var orderCancelled = new OrderCancelled { OrderNumber = message.OrderNumber, ClientId = message.ClientId }; await context.Publish(orderCancelled) .ConfigureAwait(false); log.Info($"Order #{message.OrderNumber} was cancelled."); }
public void When_CancelOrder_OrderCancelled() { Given(InitialEvents.Take(2).ToArray()); var command = new CancelOrder(id); command.Metadata.CausationId = command.Metadata.CommandId; command.Metadata.CorrelationId = causationAndCorrelationId; When(command); var expectedEvent = new OrderCancelled(id); expectedEvent.Metadata.CausationId = command.Metadata.CommandId; expectedEvent.Metadata.CorrelationId = causationAndCorrelationId; expectedEvent.Metadata.ProcessId = command.Metadata.ProcessId; Then(expectedEvent); }
public async Task Handle(CancelOrder message, IMessageHandlerContext context) { logger.Info($"Received CancelOrder, OrderId = {message.OrderId} ClientId = {message.ClientId}"); // This is normally where some business logic would occur var orderCancelled = new OrderCancelled { OrderId = message.OrderId, ClientId = message.ClientId }; var publishOptions = new PublishOptions(); publishOptions.SetHeader("insider", GetInsiderProgramValue(message)); publishOptions.SetHeader("membership", GetMembership(message)); await context.Publish(orderCancelled, publishOptions); }
public Task Handle(CancelOrder message, IMessageHandlerContext context) { logger.Info($"Received CancelOrder, OrderId = {message.OrderId}"); // This is normally where some business logic would occur // SqlException is: Must declare the scalar variable - this will happen everytime // but the policy related to thse messages is a Transient By Default // and OrderNotFoundException are treated as persistent // so these messages will be retried up to the limit SqlExceptionCreator.NewSqlException(137); var orderCancelled = new OrderCancelled { OrderId = message.OrderId }; return(context.Publish(orderCancelled)); }
public void When_OrderCancelled_CancelProductReservation_And_NotifyCustomer() { var notificationId = Guid.NewGuid(); AggregateRepository.CreateGuid = () => notificationId; SetupPreviousEvents(); orderId = AddProcessedEvent <BasketAggregate>(new BasketCheckedOut(basketId, OrderLines, shippingAddress)); AddProcessedEvent <OrderAggregate>(new OrderCreated(orderId, basketId, shippingAddress), orderId); AddProcessedEvent <ProductAggregate>(new ProductReserved(productOneId, 10), orderId); AddProcessedEvent <ProductAggregate>(new ProductReserved(productTwoId, 20), orderId); AddProcessedEvent <OrderAggregate>(new OrderLineAdded(orderId, OrderLines[0]), orderId); AddProcessedEvent <OrderAggregate>(new OrderLineAdded(orderId, OrderLines[1]), orderId); var evt = new OrderCancelled(orderId); AddPreviousEvent <OrderAggregate>(evt); SetInitalMetadata(); Given(_initialEvents.ToArray()); WhenProcessed(evt); var expectedCommands = new List <ICommand> { new CancelProductReservation(productOneId, 10), new CancelProductReservation(productTwoId, 20), new NotifyCustomer(notificationId) }; var expectedEvents = new List <IEvent> { new EventProcessed(orderId, evt) }; SetMetadata(evt, expectedCommands, expectedEvents); Then(expectedCommands.ToArray()); Then(expectedEvents.ToArray()); }
public void Handle(OrderCancelled @event) { using (var context = _contextFactory.Invoke()) { var order = context.Find <OrderDetail>(@event.SourceId); if (order != null) { order.Status = (int)OrderStatus.Canceled; context.Save(order); } var details = context.Find <OrderStatusDetail>(@event.SourceId); if (details != null) { details.Status = OrderStatus.Canceled; details.IBSStatusId = VehicleStatuses.Common.CancelledDone; details.IBSStatusDescription = _resources.Get("OrderStatus_wosCANCELLED", order != null ? order.ClientLanguageCode : "en"); context.Save(details); } RemoveTemporaryPaymentInfo(context, @event.SourceId); } }
public void Handle(OrderCancelled @event) { var orderDetail = _orderDao.FindOrderStatusById(@event.SourceId); if (orderDetail.IsPrepaid) { var response = _paymentService.RefundPayment(orderDetail.CompanyKey, @event.SourceId); if (response.IsSuccessful) { _commandBus.Send(new UpdateRefundedOrder { OrderId = @event.SourceId, IsSuccessful = response.IsSuccessful, Message = response.Message }); } } else { var feeCharged = _feeService.ChargeCancellationFeeIfNecessary(orderDetail); if (orderDetail.CompanyKey != null) { // Company not-null will never (so far) perceive no show fees, so we need to void its preauth _paymentService.VoidPreAuthorization(orderDetail.CompanyKey, orderDetail.OrderId); } else { if (!feeCharged.HasValue) { // No fees were charged on company null, void the preauthorization to prevent misuse fees _paymentService.VoidPreAuthorization(orderDetail.CompanyKey, @event.SourceId); } } } }
private void Handle(OrderCancelled e) { this.Status = OrderStatus.Cancelled; }
internal void OnOrderCancelSucceeded(string smartOrderId) { OrderCancelled.SafeInvoke(smartOrderId); }
private void Apply(OrderCancelled obj) { _orderState = OrderState.Cancelled; }