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