public bool Consume(OrderCompleted message)
{
Midget unused;
house.TryRemove(message.Order.CorrelationId, out unused);
return(true);
}
/// <summary>
/// Notifies the instance that an order was completed in order to keep the statistics up-to-date.
/// </summary>
/// <param name="oStation">The corresponding station.</param>
/// <param name="order">The order that was completed.</param>
internal void NotifyOrderCompleted(Order order, OutputStation oStation)
{
// Store the number of handled items
StatOverallOrdersHandled++;
// Check whether the order was completed too late
if (Controller.CurrentTime - order.DueTime > 0)
{
StatOverallOrdersLate++;
}
// Mark every item in the history with a timestamp
//_statOrderHandlingTimestamps.Add(
//new OrderHandledDatapoint(StatTime, oStation.ID, Controller.CurrentTime - order.TimeStamp, Controller.CurrentTime - order.TimeStampSubmit, Controller.CurrentTime - order.DueTime, Controller.CurrentTime - order.TimeStampSubmit, StatTime, StatTime, StatTime));
// Flush data points in case there are too many already
if (_statOrderHandlingTimestamps.Count > STAT_MAX_DATA_POINTS)
{
StatFlushOrdersHandled();
}
// Log turnover time
_statOrderTurnoverTimes.Add(Controller.CurrentTime - order.TimeStamp);
// Log throughput time
_statOrderThroughputTimes.Add(Controller.CurrentTime - order.TimeStampSubmit);
// Log lateness
_statOrderLatenessTimes.Add(Controller.CurrentTime - order.DueTime);
// log Time Queuing
_statOrderTimeQueueing.Add(Controller.CurrentTime - order.TimeStampSubmit);
_statOrderTotalTimeQueueing.Add(StatTime);
_statOrderTaskTimeRest.Add(StatTime);
// Raise the event
OrderCompleted?.Invoke(order, oStation);
}
public OrderCompletedRecord(OrderCompleted order)
{
OrderId = order.OrderId;
FundId = order.Fund.Id;
TradeType = order.TradeType.ToString();
Pair = order.Pair.Name;
}
private void On(OrderCompleted ev)
{
var order = PendingOrders[ev.OrderId];
Stock -= order.Quantity;
PendingOrders.Remove(ev.OrderId);
}
private void Handle(OrderCompleted @event)
{
var oldOrder = _state.Orders.Single(x => x.Id == @event.OrderId);
var order = new OrderReadModel(@event.OrderId, OrderStateReadModel.Finalized);
_state.Orders.Replace(oldOrder, order);
}
public void Handle(OrderCompleted message)
{
_bus.UnsubscribeFromCorrelationId(_correlationId, _orderCookedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, _orderPricedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, _orderPaidToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, _orderCompletedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, _reminderToken);
}
public Task Handle(OrderCompleted message, IMessageHandlerContext context)
{
Log.Info("Handle OrderCompleted");
Data.IsOrderCompleted = true;
return(ProcessOrder(context));
}
private void TestEventSourcing(IDocumentStore store)
{
var userId = Guid.NewGuid();
var streamId = Guid.NewGuid();
var catalogId1 = Guid.NewGuid();
var catalogId2 = Guid.NewGuid();
var orderId = Guid.NewGuid();
using var session = store.OpenSession();
var catalogAdded1 = new CatalogAdded
{
CatalogId = catalogId1,
Quantity = 5,
UserId = userId
};
var catalogAdded2 = new CatalogAdded
{
CatalogId = catalogId2,
Quantity = 3,
UserId = userId
};
// Assume user adds 2 catalog first
session.Events.StartStream(streamId, catalogAdded1, catalogAdded2);
session.SaveChanges();
var catalogRemoved = new CatalogRemoved
{
CatalogId = catalogId1,
Quantity = 2,
UserId = userId
};
var orderCreated = new OrderCreated
{
UserId = userId,
OrderId = orderId,
TotalMoney = 10000000
};
var orderChangeStatus = new OrderStatusChangeToPaid {
OrderId = orderId
};
var orderConfirmed = new OrderConfirmed {
OrderId = orderId
};
var orderShipped = new OrderShipped {
OrderId = orderId
};
var orderCompleted = new OrderCompleted {
OrderId = orderId
};
session.Events.Append(streamId, orderCreated, catalogRemoved, orderChangeStatus, orderConfirmed, orderShipped, orderCompleted);
session.SaveChanges();
}
public void Handle(OrderCompleted evnt)
{
if (!Carts.ContainsKey(evnt.CartId))
{
Carts.Add(evnt.CartId, new Cart {
CartId = evnt.CartId
});
}
Carts[evnt.CartId].Completed = true;
}
public async Task Timeout(CompleteOrder state, IMessageHandlerContext context)
{
log.Info($"Saga with OrderId {Data.OrderId} completed");
var orderCompleted = new OrderCompleted
{
OrderId = Data.OrderId
};
await context.Publish(orderCompleted)
.ConfigureAwait(false);
MarkAsComplete();
}
public async Task Handle(OrderCompleted msg, IMessageMetadata metadata = null)
{
using (var context = _contextFactory())
{
var order = await context.Orders.FindAsync(msg.SourceId);
order.Status = msg.Status;
order.LastModified = msg.CreatedTime;
await context.SaveChangesAsync();
}
}
public void Timeout(CompleteOrder state)
{
log.Info($"Saga with OrderId {Data.OrderId} completed");
var orderCompleted = new OrderCompleted
{
OrderId = Data.OrderId
};
Bus.Publish(orderCompleted);
MarkAsComplete();
}
public Task Timeout(CompleteOrder state, IMessageHandlerContext context)
{
log.Info($"Saga with OrderId {Data.OrderId} completed");
var orderCompleted = new OrderCompleted
{
OrderId = Data.OrderId
};
MarkAsComplete();
return(context.Publish(orderCompleted));
}
public void Complete()
{
if (Status != OrderStatus.Paid)
{
throw new InvalidOperationException($"Cannot complete a not paid order.");
}
var @event = OrderCompleted.Create(Id, DateTime.UtcNow);
Enqueue(@event);
Apply(@event);
}
private void Handle(OrderCompleted @event)
{
var oldOrder = _state.Orders.Single(x => x.Id == @event.OrderId);
var order = new ClientOrderReadModel(@event.OrderId,
@event.CustomerId,
oldOrder.CreateDateTime,
DateTime.Now,
oldOrder.ExpirationTimeout,
OrderStateReadModel.Finalized);
_state.Orders.Replace(oldOrder, order);
}
private async void Handle(OrderCompleted e)
{
Console.WriteLine($"Order #{e.OrderNumber} completed.");
using (var dbContext = new StoreDBContext())
{
var order = dbContext.Orders.FirstOrDefault(o => o.OrderNumber == e.OrderNumber);
if (order != null)
{
order.ShippingAddress = e.ShippingAddress;
await dbContext.SaveChangesAsync();
}
}
}
public async Task Evaluate(EvaluateInputDto input)
{
if (!AbpSession.UserId.HasValue)
{
throw new UserFriendlyException("用户未登录");
}
var order = await _evaluatingRepository.FirstOrDefaultAsync(input.OrderId);
if (order == null)
{
throw new UserFriendlyException("找不到此订单");
}
if (order.BuyerId != AbpSession.UserId.Value)
{
throw new UserFriendlyException("此订单不是你的订单");
}
// 更改订单状态
order.EvaluatedTime = DateTime.Now;
await _evaluatingRepository.UpdateAsync(order);
var completedOrder = new OrderCompleted
{
Id = order.Id,
Code = order.Code,
BuyerId = order.BuyerId,
SellerId = order.SellerId,
AddressId = order.AddressId,
DeliveryId = order.DeliveryId,
Amount = order.Amount,
ItemPriceAmount = order.ItemPriceAmount,
ExpressCostAmount = order.ExpressCostAmount,
ItemId = order.ItemId,
EvaluationLevel = input.EvaluationLevel,
EvaluationContent = input.EvaluationContent,
OrderTime = order.OrderTime,
PaidTime = order.PaidTime,
SentTime = order.SentTime,
ReceivedTime = order.ReceivedTime,
EvaluatedTime = DateTime.Now,
CompletedTime = DateTime.Now
};
await _completedRepository.InsertAsync(completedOrder);
await _evaluatingRepository.DeleteAsync(input.OrderId);
}
public Task Timeout(CompleteOrder state, IMessageHandlerContext context)
{
log.Info($"Saga with OrderId {Data.OrderId} completed");
var orderCompleted = new OrderCompleted
{
OrderId = Data.OrderId
};
MarkAsComplete();
return(Task.WhenAny(
context.Publish(orderCompleted),
context.SendLocal(new PrintInvoice {
OrderId = Data.OrderId
})));
}
public void Handle(OrderCooked message)
{
if (_isFoodCooked)
{
Console.WriteLine("Food was cooked twice for dodgy customer: {0}", message.Order.Id);
}
_isFoodCooked = true;
var orderCompleted = new OrderCompleted(message.Order)
{
MessageId = Guid.NewGuid(),
CorrelationId = message.CorrelationId,
CausationId = message.MessageId
};
_bus.Publish(orderCompleted);
}
public void Handle(OrderCompleted message)
{
if (_expectedNextCausationId == message.MessageId)
{
isCompleted = true;
_bus.UnsubscribeFromCorrelationId(_correlationId, OrderCookedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, OrderPricedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, OrderPaidToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, OrderCompletedToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, ReminderToken);
_bus.UnsubscribeFromCorrelationId(_correlationId, OrderScrewedReminder);
}
else
{
Console.WriteLine("Received Evil Message: Order Completed {0}", message.Order.Id);
}
}
public CommandHandlingResult Complete(string shippingAddress)
{
if (!Products.Any())
{
return(CommandHandlingResult.Fail("Error: the order does not contain any products."));
}
if (this.Status != OrderStatus.InProgress)
{
return(CommandHandlingResult.Fail("Error: only in progress orders can be completed."));
}
var e = new OrderCompleted(this.OrderNumber, shippingAddress);
Handle(e);
return(CommandHandlingResult.Success(e));
}
public void Handle(OrderCompleted message)
{
this.Data.CustomerId = message.CustomerId;
this.Data.OrderTotal += message.OrderTotal;
Console.WriteLine("Evaluating total orders for customer {0}", message.CustomerId);
if (this.Data.OrderTotal > 500)
{
Console.WriteLine("*********** Preferred Status achievement: UNLOCKED!!!! ******************");
this.MarkAsComplete();
}
else
{
Console.WriteLine("Order total is only {0}, keep ordering!!", this.Data.OrderTotal);
}
}
public void process_event_after_completion()
{
var orderId = Guid.NewGuid();
var orderCreated = new OrderCreated(orderId, 100, 0, 0);
var orderCompleted = new OrderCompleted(100, orderId, 0, 0);
var orderPaymentCreated = new OrderPaymentCreated(100, orderId, 0, 0);
var definition = new OrderProcessManager6();
var instance = new Instance <OrderProcessManagerData>(definition);
instance.ProcessEvent(orderCreated);
instance.ProcessEvent(orderCompleted);
instance.State.Should().Be(InstanceStates.Completed);
Action act = () => instance.ProcessEvent(orderPaymentCreated);
act.Should().Throw <Exception>();
}
public void Handle(OrderPaid message)
{
if (_expectedNextCausationId == message.CausationId)
{
var orderCompleted = new OrderCompleted(message.Order)
{
MessageId = Guid.NewGuid(),
CorrelationId = message.CorrelationId,
CausationId = message.MessageId
};
_expectedNextCausationId = orderCompleted.MessageId;
_bus.Publish(orderCompleted);
}
else
{
Console.WriteLine("Received Evil Message: Order Paid {0}", message.Order.Id);
}
}
async Task ContinueProcess(IMessageHandlerContext context)
{
if (Data.OrderPlaced && Data.OrderBilled)
{
log.Info("\tYes we should...");
var message = new OrderCompleted
{
OrderId = Data.OrderId
};
await context.Publish(message);
MarkAsComplete();
}
else
{
log.Info($"Requesting timeout, OrderId = {Data.OrderId}.");
await RequestTimeout <OrderExpiredTimeout>(context, TimeSpan.FromSeconds(5));
}
}
public void Handle(OrderCompleted msg)
{
var soldProducts = msg.SoldProducts
.GroupBy(k => k)
.Select(p => new
{
ProductId = p.Key,
Count = p.Count()
});
foreach (var soldProduct in soldProducts)
{
var existingProduct = Warehouse.Products.FirstOrDefault(x => x.Id == soldProduct.ProductId);
if (existingProduct == null)
{
Console.WriteLine($"WARN: Product id {soldProduct.ProductId} does not exist in Warehouse {Warehouse.Name}");
continue;
}
existingProduct.Quantity -= soldProduct.Count;
}
}
public ActionResult Post([FromBody] Order order)
{
var retrievedOrder = _documentSession.Query <Order>().FirstOrDefault(x => x.Id == order.Id);
if (retrievedOrder.IsComplete)
{
return(Ok());
}
retrievedOrder.IsComplete = true;
var orderCompleted = new OrderCompleted()
{
Id = retrievedOrder.Id
};
_bus.Publish(orderCompleted);
_documentSession.SaveChanges();
return(Ok());
}
public void Handle(PlaceOrder message)
{
// extract the info you need from the message, and do your 'work'
Console.WriteLine(@"Order for Product:{0} processing with id: {1}", message.Product, message.Id);
#region Exception
//throw new Exception("boom");
#endregion
#region Publish the OrderCompleted event
OrderCompleted order = new OrderCompleted
{
OrderId = message.Id,
OrderTotal = message.OrderTotal,
CustomerId = message.CustomerId
};
bus.Publish(order);
#endregion
}
public async Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
#region Demo 2 - Request/Response
Log.Info($"Received PlaceOrder, OrderId = {message.OrderId}, " +
$"OrderDate = {message.OrderDate}, ItemName = {message.ItemName}");
var order = new SubmittedOrder {
OrderDate = message.OrderDate, OrderId = message.OrderId
};
await _dbContext.SubmittedOrders.AddAsync(order);
await _dbContext.SaveChangesAsync();
var orderResponse = new PlaceOrderResponse
{
OrderId = message.OrderId,
StatusCompleted = true
};
await context.Reply(orderResponse);
#endregion
#region Demo 3 - Pub/Sub
var orderCompleted = new OrderCompleted
{
OrderId = message.OrderId
};
await context.Publish(orderCompleted);
#endregion
}
private void Handle(OrderCompleted e)
{
this.ShippingAddress = e.ShippingAddress;
this.Status = OrderStatus.Completed;
}
