public static PurchaseOrderMailerModel GetTemplateData(this Domain.PurchaseOrder purchaseOrder, string purchaseOrderId, string url)
{
var senderName = purchaseOrder.SenderInfo.Name;
var lines = purchaseOrder.Products.Select(o => new PurchaseOrderLineMailerModel
{
Line_Name = o.Name,
Line_Quantity = o.Quantity,
Line_Price = o.TotalOnSalePrice
}).ToList();
var address = purchaseOrder.ExpectedDelivery.Address;
return(new PurchaseOrderMailerModel
{
Id = purchaseOrderId,
Lines = lines,
SenderName = senderName,
Reference = purchaseOrder.Reference.AsPurchaseOrderIdentifier(),
VendorName = purchaseOrder.VendorInfo.Name,
CreatedOn = purchaseOrder.CreatedOn,
ExpectedDeliveryDate = purchaseOrder.ExpectedDelivery.ExpectedDeliveryDate,
TotalOnSalePrice = purchaseOrder.TotalOnSalePrice,
TotalWholeSalePrice = purchaseOrder.TotalWholeSalePrice,
TotalVatPrice = purchaseOrder.TotalVatPrice,
DeliveryFeesWholeSalePrice = purchaseOrder.ExpectedDelivery.DeliveryFeesWholeSalePrice,
DeliveryFeesVatPrice = purchaseOrder.ExpectedDelivery.DeliveryFeesVatPrice,
DeliveryFeesOnSalePrice = purchaseOrder.ExpectedDelivery.DeliveryFeesOnSalePrice,
PurchaseOrderUrl = url,
ExpectedFrom = purchaseOrder.ExpectedDelivery.From,
ExpectedTo = purchaseOrder.ExpectedDelivery.To,
Address = address != null ? $"{address.Line1} {address.Line2} {address.Zipcode} {address.City}" : null,
Reason = purchaseOrder.Reason,
ClientKind = purchaseOrder.SenderInfo.Kind
});
}
public async Task HandleAsync(CreatePurchaseOrderCommand command)
{
//Issue: Crossing the boundary context to cut shot the time.
//This should call the Basket Api and get the details. Not the repository directly.
var basketSpecification = new BasketWithItemsSpecification(command.BasketId);
var basket = await _basketAsyncRepository.GetSingleAsync(basketSpecification);
var items = new List <PurchaseOrderItem>();
foreach (var basketItem in basket.BasketItems)
{
var catalogItem = await _catalogItemAsyncRepository.GetByIdAsync(basketItem.CatalogItemId);
var itemOrdered = new CatalogItemOrdered(catalogItem.Id,
(CatalogItemType)catalogItem.CatalogType, catalogItem.Name, catalogItem.PictureUri);
var orderItem = new PurchaseOrderItem(itemOrdered, basketItem.UnitPrice, basketItem.Quantity);
items.Add(orderItem);
}
var purchaseOrderId = Guid.NewGuid();
var purchaseOrderIdNumberMapping = new PurchaseOrderIdNumberMapping {
PurchaseOrderId = purchaseOrderId
};
_purchaseOrderIdNumberMappingAsyncRepository.Add(purchaseOrderIdNumberMapping);
await _unitOfWork.SaveChangesAsync();
var purchaseOrder = new Domain.PurchaseOrder(purchaseOrderId, purchaseOrderIdNumberMapping.Id, basket.BuyerId, command.Address, items);
await _shopAggregateRepositoryService.SaveAsync(purchaseOrder);
}
public static object GetPurchaseNotifModel(this Domain.PurchaseOrder purchaseOrder, string purchaseOrderId)
{
return(new
{
PurchaseOrderId = purchaseOrderId,
Status = purchaseOrder.Status,
Reference = purchaseOrder.Reference,
VendorName = purchaseOrder.VendorInfo.Name,
SenderName = purchaseOrder.SenderInfo.Name,
CreatedOn = purchaseOrder.CreatedOn,
TotalOnSalePrice = purchaseOrder.TotalOnSalePrice,
TotalWholeSalePrice = purchaseOrder.TotalWholeSalePrice,
ExpectedDeliveryDate = purchaseOrder.ExpectedDelivery.ExpectedDeliveryDate
});
}
private async Task NotifyProducerAsync(Domain.PurchaseOrder purchaseOrder, CancellationToken token)
{
var purchaseOrderIdentifier = _idSerializer.Serialize("Query", nameof(PurchaseOrder), purchaseOrder.Id);
await _signalrService.SendNotificationToUserAsync(purchaseOrder.ProducerId, "PurchaseOrderWithdrawnEvent",
purchaseOrder.GetPurchaseNotifModelAsString(purchaseOrderIdentifier));
var url = $"{_configuration.GetValue<string>("Portal:url")}/#/purchase-orders/{purchaseOrderIdentifier}?refresh={Guid.NewGuid():N}";
await _emailService.SendTemplatedEmailAsync(
purchaseOrder.VendorInfo.Email,
purchaseOrder.VendorInfo.Name,
$"Votre commande a expirée",
nameof(PurchaseOrderExpiredEvent),
purchaseOrder.GetTemplateData(purchaseOrderIdentifier, url),
true,
token);
}
private static List <DeliveryProductMailerModel> GetProductsModel(Domain.PurchaseOrder purchaseOrder)
{
var products = new List <DeliveryProductMailerModel>();
if (purchaseOrder.PickingId.HasValue)
{
products = purchaseOrder.Picking.PreparedProducts
.Where(p => p.PurchaseOrderId == purchaseOrder.Id)
.Select(p => GetProductModel(p, ModificationKind.ToDeliver))
.ToList();
}
else
{
products = purchaseOrder.Products
.Select(p => GetProductModel(p, ModificationKind.ToDeliver))
.ToList();
}
return(products);
}
private static List <DeliveryReturnableMailerModel> GetReturnablesModel(Domain.PurchaseOrder purchaseOrder)
{
var returnables = new List <DeliveryReturnableMailerModel>();
if (purchaseOrder.PickingId.HasValue)
{
returnables = purchaseOrder.Picking.PreparedProducts
.Where(p => p.HasReturnable && p.PurchaseOrderId == purchaseOrder.Id && p.Quantity > 0)
.Select(p => GetReturnableModel(p, ModificationKind.ToDeliver))
.ToList();
}
else
{
returnables = purchaseOrder.Products
.Where(p => p.HasReturnable)
.Select(p => GetReturnableModel(p, ModificationKind.ToDeliver))
.ToList();
}
return(returnables);
}
public static string GetPurchaseNotifModelAsString(this Domain.PurchaseOrder purchaseOrder, string purchaseOrderId)
{
return(JsonConvert.SerializeObject(GetPurchaseNotifModel(purchaseOrder, purchaseOrderId)));
}
public async Task <Result <Guid> > Handle(CreatePurchaseOrderCommand request, CancellationToken token)
{
var producer = await _context.Producers.SingleAsync(e => e.Id == request.ProducerId, token);
var client = await _context.Users.SingleAsync(e => e.Id == request.ClientId, token);
var deliveryMode =
await _context.DeliveryModes.SingleAsync(
d => d.Id == request.DeliveryModeId && d.ProducerId == producer.Id, token);
if (client.Kind == ProfileKind.Consumer)
{
return(Failure <Guid>(
"Cette fonction ne peux être utilisée que pour créer des commandes pour les professionels."));
}
if (request.Products == null || !request.Products.Any())
{
return(Failure <Guid>(
"Vous devez ajouter des produits à votre commande."));
}
if (request.Products.Any(p => p.Quantity <= 0))
{
return(Failure <Guid>(
"Un ou plusieurs produits possèdent une quantité inférieure ou égale à 0."));
}
if (request.ExpectedDeliveryDate < DateTimeOffset.UtcNow)
{
return(Failure <Guid>(
"La date de livraison ne peut être inférieure à aujourd'hui."));
}
if (request.From > request.To)
{
return(Failure <Guid>(
"L'heure de début ne peut être supérieure à l'heure de fin."));
}
var productsQuantity = new List <KeyValuePair <Domain.Product, int> >();
var productIds = request.Products.Select(p => p.Id).Distinct();
var products = await _context.Products
.Where(p => productIds.Contains(p.Id) && p.ProducerId == producer.Id)
.ToListAsync(token);
Domain.Catalog catalog = null;
var agreement = await _context.Agreements.SingleAsync(
a => a.StoreId == client.Id && a.ProducerId == producer.Id && a.Status == AgreementStatus.Accepted,
token);
if (agreement != null)
{
catalog = agreement.Catalog;
}
catalog ??= await _context.Catalogs.SingleAsync(
c => c.ProducerId == producer.Id && c.Kind == CatalogKind.Stores && c.Available && c.IsDefault, token);
foreach (var product in products)
{
var quantity = request.Products.Where(p => p.Id == product.Id).Sum(p => p.Quantity);
productsQuantity.Add(new KeyValuePair <Domain.Product, int>(product, quantity ?? 0));
}
var resultIdentifier =
await _identifierService.GetNextPurchaseOrderReferenceAsync(request.ProducerId, token);
if (!resultIdentifier.Succeeded)
{
return(Failure <Guid>(resultIdentifier));
}
var purchaseOrder = new Domain.PurchaseOrder(Guid.NewGuid(), resultIdentifier.Data,
PurchaseOrderStatus.Accepted, request.ExpectedDeliveryDate, request.From, request.To, deliveryMode,
producer, client, productsQuantity, catalog, request.SkipNotification, request.Comment);
await _context.AddAsync(purchaseOrder, token);
await _context.SaveChangesAsync(token);
if (deliveryMode.MaxPurchaseOrdersPerTimeSlot.HasValue)
{
await _tableService.IncreaseProducerDeliveryCountAsync(producer.Id, deliveryMode.Id,
request.ExpectedDeliveryDate, request.From,
request.To, deliveryMode.MaxPurchaseOrdersPerTimeSlot.Value, token);
}
return(Success(purchaseOrder.Id));
}
