public static string Validate(this Order order, FinalizeOrder finalizeOrder)
{
var errors = string.Empty;
// if (finalizeOrder.DishesAndQuantity == null || finalizeOrder.DishesAndQuantity.Count == 0)
// errors += "Order is empty!";
if (string.IsNullOrWhiteSpace(order.Street))
{
errors += "Address can't be empty!";
}
if (string.IsNullOrWhiteSpace(order.FirstName))
{
errors += "Name can't be empty!";
}
if (string.IsNullOrWhiteSpace(order.LastName))
{
errors += "Surname can't be empty!";
}
return(errors);
}
private async Task HandleFinalizeOrderAsync(BasicDeliverEventArgs args, FinalizeOrder finalizeOrder)
{
using var scope = ServiceProvider.CreateScope();
var command = scope.ServiceProvider.GetRequiredService <FinalizeOrderCommand>();
command.Dishes = finalizeOrder.Dishes;
command.Order = finalizeOrder.Order;
var errors = command.Validate();
Message finalMessage;
if (errors.Count == 0)
{
var registrationMessage = new RegisterOrder
{
OrderId = finalizeOrder.Order.Id,
};
var registrationMessageProps =
CreateProperties(args.BasicProperties.CorrelationId, MessageType.RegisterOrder);
Channel.BasicPublish(string.Empty, args.BasicProperties.ReplyTo, registrationMessageProps,
registrationMessage.GetSerialized());
try
{
await command.HandleAsync();
}
catch
{
PublishErrorMessage(finalizeOrder.Order.Id, args);
return;
}
finalMessage = new FinalizingSuccess
{
OrderId = finalizeOrder.Order.Id,
DeliveryDateTime = DateTime.Now.AddMinutes(new Random().Next(30, 120)),
};
}
else
{
finalMessage = new FinalizingError
{
OrderId = finalizeOrder.Order.Id,
ErrorMessage = errors.Values.ToList().First(),
};
}
var replyProps = CreateProperties(args.BasicProperties.CorrelationId, finalMessage.MessageType);
Channel.BasicPublish(string.Empty,
args.BasicProperties.ReplyTo,
replyProps,
finalMessage.GetSerialized());
}
/// <inheritdoc/>
public IOrder EnrollCertificate(int accountId, int orderId, FinalizeOrder @params)
{
#region Check arguments
if (@params is null)
{
throw new ArgumentNullException(nameof(@params));
}
#endregion
var order = GetById(accountId, orderId);
// Check status ready
if (order.Status != OrderStatus.Ready)
{
throw new AcmeException(ErrorType.OrderNotReady);
}
var certificateEnrollParams = new CertificateEnrollParams()
{
Order = order,
Params = @params,
};
try
{
OnEnrollCertificateBefore(certificateEnrollParams);
}
catch (Exception ex)
{
// return invalid order
CreateOrderError(ex, certificateEnrollParams.Order);
return(certificateEnrollParams.Order);
}
order.Status = OrderStatus.Processing;
OrderRepository.Update(order);
Logger.Info("Order {id} status updated to {status}", order.Id, order.Status);
// check cancel
if (!certificateEnrollParams.Cancel)
{
Task
.Run(async() =>
{
var requestRaw = Base64Url.Decode(@params.Csr);
var request = new Pkcs10CertificateRequest(requestRaw);
var certificate = await CertificateEnrollmentService.Enroll(order, request); // todo ? using certEnrollParams
order.Certificate = OrderRepository.CreateCertificate(certificate);
OrderRepository.Update(order);
OnEnrollCertificateTask(certificateEnrollParams);
})
.ContinueWith(t =>
{
if (t.IsFaulted)
{
// TODO Optimize Error assignment
CreateOrderError(t.Exception.InnerException, order);
}
if (t.IsCompleted)
{
if (order.Status == OrderStatus.Processing)
{
order.Status = OrderStatus.Valid;
OrderRepository.Update(order);
Logger.Info("Certificate {thumbprint} for Order {id} issued successfully", order.Certificate.Thumbprint, order.Id);
}
}
Logger.Info("Order {id} status updated to {status}", order.Id, order.Status);
});
}
return(order);
}
