public async void PublisherNewOrder()
{
if (_lastTask != null && !_lastTask.IsCompleted)
{
return;
}
var config = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
var topicClient = new TopicClient(config.ConnectionString, Topic);
var order = new OrderChangedMessage
{
OrderId = Guid.NewGuid(),
StoreId = Guid.Parse(StoreId),
State = (GeekBurger.Orders.Contract.Enums.OrderState) new Random().Next(1, 3)
};
_lastTask = SendMessagesAsync(topicClient, GetMessage(order));
_orderChanged.PublisherStartNewOrder(order);
await _lastTask;
var closeTask = topicClient.CloseAsync();
await closeTask;
HandleException(closeTask);
}
public void RemoveToMessageList(OrderChangedMessage order)
{
if (!_orders.Exists(x => x.Equals(order.OrderId.ToString())))
{
_orders.Remove(order.StoreId.ToString());
}
}
public void AddToMessageList(OrderChangedMessage order)
{
if (!_orders.Exists(x => x.Equals(order.OrderId)))
{
_orders.Add(order.OrderId.ToString());
}
}
public Message GetMessage(OrderChangedMessage orderChanged)
{
var orderFinishedSerialized = JsonConvert.SerializeObject(orderChanged);
var orderFinishedByteArray = Encoding.UTF8.GetBytes(orderFinishedSerialized);
return(new Message
{
Body = orderFinishedByteArray,
MessageId = Guid.NewGuid().ToString(),
Label = orderChanged.OrderId.ToString()
});
}
public async Task SaveSale(OrderChangedMessage order)
{
if (order.State == Orders.Contract.Enums.OrderState.Paid)
{
var sales = new Sales
{
Date = DateTime.Now,
Price = order.Value,
SaleId = order.OrderId,
StoreId = order.StoreId
};
await _salesRepository.Add(sales);
}
}
protected override Message GetMessage(Order order)
{
decimal.TryParse(order.Total, out decimal valor);
var productChanged = new OrderChangedMessage
{
OrderId = order.OrderId,
State = (OrderState)order.State,
StoreId = order.StoreId,
Value = valor
};
var productChangedSerialized = JsonConvert.SerializeObject(productChanged);
var productChangedByteArray = Encoding.UTF8.GetBytes(productChangedSerialized);
return(new Message
{
Body = productChangedByteArray,
MessageId = Guid.NewGuid().ToString(),
Label = productChanged.OrderId.ToString()
});
}
private Task Handle(Message message, CancellationToken arg2)
{
var messageString = "";
if (message.Body != null)
{
messageString = Encoding.UTF8.GetString(message.Body);
}
//TODO: be more generic
OrderChangedMessage orderChanged = null;
if (message.Label == "orderchanged")
{
orderChanged = JsonConvert.DeserializeObject <List <OrderChangedMessage> >(messageString);
}
//if (message.Label == "userwithlessoffer")
// orderChanged = JsonConvert.DeserializeObject<List<GeekBurger.Orders.Contract.Messages.>>(messageString);
_salesService.SaveSale(orderChanged);
return(Task.CompletedTask);
}
private static Task Handle(Message message, CancellationToken arg2)
{
var newOrderString = Encoding.UTF8.GetString(message.Body);
var newOrder = JsonConvert.DeserializeObject <OrderChangedMessage>(newOrderString);
OrderChangedMessage orderReadyMessage = new OrderChangedMessage
{
OrderId = new Guid(message.Label),
State = (OrderState)ProductionState.Ready,
Value = newOrder.Value,
StoreId = newOrder.StoreId
};
Random readyTime = new Random();
int seconds = readyTime.Next(5 * 1000, 21 * 1000);
Thread.Sleep(seconds);
// TODO: persisitir a informação de READY para validação após o pagamento do pedido
return(Task.CompletedTask);
}
public async void PublisherStartNewOrder(OrderChangedMessage order)
{
if (_lastTask != null && !_lastTask.IsCompleted)
{
return;
}
var config = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
var topicClient = new TopicClient(config.ConnectionString, Topic);
_lastTask = SendMessagesAsync(topicClient, GetMessage(order));
await _lastTask;
var closeTask = topicClient.CloseAsync();
await closeTask;
if (HandleException(closeTask))
{
AddToMessageList(order);
}
}
private static Task Handle(Message message, CancellationToken arg2)
{
var orderChangedString = Encoding.UTF8.GetString(message.Body);
var orderChanged = JsonConvert.DeserializeObject <OrderChangedMessage>(orderChangedString);
if (orderChanged.State == OrderState.Paid)
{
OrderChangedMessage orderFinishedMessage = new OrderChangedMessage
{
OrderId = new Guid(message.Label),
State = (OrderState)ProductionState.Finished,
Value = orderChanged.Value,
StoreId = orderChanged.StoreId
};
// TODO: atribuir como status concluído apenas se o status de produção for READY
_orderChangedService.AddToMessageList(orderFinishedMessage);
_orderChangedService.SendMessagesAsync();
}
return(Task.CompletedTask);
}
public async void PublisherFinishedOrder(OrderChangedMessage order)
{
if (_lastTask != null && !_lastTask.IsCompleted)
{
return;
}
var config = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
var topicClient = new TopicClient(config.ConnectionString, Topic);
order.State = GeekBurger.Orders.Contract.Enums.OrderState.Finished;
_lastTask = SendMessagesAsync(topicClient, GetMessage(order));
await _lastTask;
var closeTask = topicClient.CloseAsync();
await closeTask;
if (HandleException(closeTask))
{
RemoveToMessageList(order);
}
}
public void AddToMessageList(OrderChangedMessage orderChanged)
{
_messages.Add(this.GetMessage(orderChanged));
}
public IActionResult PublisherFinishedOrder([FromBody] OrderChangedMessage order)
{
_orderChanged.PublisherFinishedOrder(order);
return(Ok());
}
public IActionResult PublisherTopicStartNewOrders([FromBody] OrderChangedMessage order)
{
_orderChanged.PublisherStartNewOrder(order);
return(Ok());
}
