public void SerializeMessageWithDateTime()
{
var serializerService = this.serializationFixture.SerializerService;
//use date format first
var customerCreatedMessage = new CustomerCreatedMessage
{
CreatedAt = DateTime.Parse("2021-09-09")
};
var customerJson = serializerService.Serialize(customerCreatedMessage);
Assert.NotNull(customerJson);
// use datetime format
var message = new OrderCreatedMessage
{
CreatedAt = DateTime.Parse("2021-09-09T09:50:25")
};
var orderJson = serializerService.Serialize(message);
Assert.NotNull(orderJson);
Assert.Equal(
"{\"sequenceNumber\":0,\"resourceVersion\":0," +
"\"type\":\"OrderCreated\",\"version\":0," +
"\"createdAt\":\"2021-09-09T09:50:25\"," +
"\"lastModifiedAt\":\"0001-01-01\"}", orderJson);
}
public void Handle(OrderCreatedMessage message)
{
Process(message, m =>
{
if (IsCancelled)
{
return;
}
LineItems = m.LineItems.Select(li => new LineItem
{
ProductId = li.ProductId,
AmountRequested = li.Quantity
})
.ToList();
foreach (var lineItem in LineItems)
{
Send(new StockRequestMessage
{
Id = Guid.NewGuid(),
ProductId = lineItem.ProductId,
AmountRequested = lineItem.AmountRequested,
OrderFulfillmentId = Id
});
}
});
}
private OrderViewModel CreateOrderViewModel(OrderCreatedMessage order)
{
return(new OrderViewModel
{
UserName = order.UserName,
Products = order.Products.Select(p => CreateProductViewModel(p)).ToList()
});
}
public void PublishOrderCreatedMessage(int?customerId, int orderId, IList <OrderLine> orderLines)
{
var message = new OrderCreatedMessage
{
CustomerId = customerId,
OrderId = orderId,
OrderLines = orderLines
};
bus.PubSub.Publish(message);
}
public async Task <Result <int> > CreateAsync(CreateOrderInputModel input, string userId)
{
try
{
var orderLines = input.OrderLines
.Select(x => new OrderLine
{
ProductId = x.ProductId,
Quantity = x.Quantity
})
.ToList();
var order = new Order
{
UserId = userId,
OrderLines = orderLines,
PhoneNumber = input.PhoneNumber,
Address = input.Address,
Status = OrderStatus.New
};
var messageData = new OrderCreatedMessage
{
Products = orderLines.Select(ol => new OrderCreatedProduct
{
ProductId = ol.ProductId,
Quantity = ol.Quantity
}).ToList()
};
var message = new Message(messageData);
await this.SaveAsync(order, message);
await this.publisher.Publish(messageData);
await this.MarkMessageAsPublished(message.Id);
return(Result <int> .SuccessWith(order.Id));
}
catch (Exception e)
{
var errorMessage = "Failed to save order";
this.logger.LogError(e, errorMessage);
return(Result <int> .Failure(new [] { errorMessage }));
}
}
public async Task UpdateQuantityAsync(OrderCreatedMessage message)
{
var productIds = message.Products.Select(x => x.ProductId);
var products = await this.db.Products
.Where(product => productIds.Contains(product.Id))
.ToListAsync();
foreach (var product in products)
{
var orderCreatedProduct = message.Products.FirstOrDefault(x => x.ProductId == product.Id);
if (orderCreatedProduct != null)
{
product.Quantity -= product.Quantity;
}
}
await this.db.SaveChangesAsync();
}
public async Task OrderCreatedAsync(OrderCreatedMessage ocMessage)
{
using var scope = _provider.CreateScope();
{
var services = scope.ServiceProvider;
var cusRepo = services.GetService <IRepository <Customer> >();
var msgPublisher = services.GetService <IMessagePublisher>();
var customerExists = await cusRepo.GetById(ocMessage.OrderDTO.CustomerID) is null ? false : true;
CustomerValidatedMessage customerValidatedMessage = new CustomerValidatedMessage()
{
OrderID = ocMessage.OrderDTO.ID,
CustomerExists = customerExists,
ProductIDs = customerExists ? ocMessage.OrderDTO.Products.Select(x => x.ProductID).ToList() : new List <int>()
};
await msgPublisher.PublishCustomerValidatedMessage(customerValidatedMessage);
}
}
private void HandleOrderCreated(OrderCreatedMessage message)
{
// A service scope is created to get an instance of the product repository.
// When the service scope is disposed, the product repository instance will
// also be disposed.
using (var scope = provider.CreateScope())
{
var services = scope.ServiceProvider;
var productRepos = services.GetService <IRepository <Product> >();
if (ProductItemsAvailable(message.OrderLines, productRepos))
{
// Reserve items and publish an OrderAcceptedMessage
foreach (var orderLine in message.OrderLines)
{
var product = productRepos.Get(orderLine.ProductId);
product.ItemsReserved += orderLine.Quantity;
productRepos.Edit(product);
}
var replyMessage = new OrderAcceptedMessage
{
OrderId = message.OrderId
};
bus.PubSub.Publish(replyMessage);
}
else
{
// Publish an OrderRejectedMessage
var replyMessage = new OrderRejectedMessage
{
OrderId = message.OrderId
};
bus.PubSub.Publish(replyMessage);
}
}
}
public IHttpActionResult SaveOrder([FromBody] Order order)
{
var connectionId = Request.GetConnectionId();
if (string.IsNullOrEmpty(connectionId))
{
return(Unauthorized(Request.Headers.Authorization));
}
var user = AuthenticationCache.GetUser(connectionId);
if (user == null || order.UserId != user.Id)
{
return(Unauthorized(AuthenticationHeaderValue.Parse(connectionId)));
}
if (order.Id == 0)
{
_orderRepository.Add(order);
}
else
{
_orderRepository.Save(order);
}
order.Table = _dbContext.FirstOrDefault <Table>(t => t.Id == order.TableId);
var message = new OrderCreatedMessage(connectionId)
{
Order = order
};
_hub.SendAll(message);
return(Ok(order));
}
private void OnOrderCreated(OrderCreatedMessage model)
{
this.RunOnUiThread(() => SetOrderToTable(model.Order));
}
public OrderCreatedMessageEventArgs(OrderCreatedMessage newOrder)
{
Order = newOrder;
}
