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