public async Task <DeleteActiveDeliveryCommandResult> Handle(DeleteActiveDeliveryCommand request, CancellationToken cancellationToken)
{
var activeDelivery = await _activeDeliveryRepository.FindByIdAsync(request.DeliveryId);
if (activeDelivery is null)
{
return(new DeleteActiveDeliveryCommandResult(false,
new[] { $"Could not find Delivery with id {request.DeliveryId}" }));
}
if (activeDelivery.IsAnyDeliveryItemsScanned)
{
return(new DeleteActiveDeliveryCommandResult(false, new[] { "At least 1 delivery item is scanned" }));
}
var cancelledDelivery = new CancelledDelivery(activeDelivery, request.CancellationReason);
_activeDeliveryRepository.Remove(activeDelivery);
_cancelledDeliveryRepository.Add(cancelledDelivery);
if (await _activeDeliveryRepository.UnitOfWork.SaveChangesAsync(cancellationToken) < 1)
{
return(new DeleteActiveDeliveryCommandResult(false, new[] { "Something went wrong during saving Db" }));
}
return(new DeleteActiveDeliveryCommandResult(true));
}
public async Task <ActiveDeliveryWithItemsDto> Handle(GetActiveDeliveryQuery request, CancellationToken cancellationToken)
{
var activeDelivery = await _activeDeliveryRepository.FindByIdAsync(request.Id);
if (activeDelivery is null)
{
return(null);
}
var bookInfoResult = await _client.GetResponse <BooksInfoResult>(
new { BooksIds = activeDelivery.Items.Select(b => b.BookId).ToList() });
var activeDeliveryWithDesc = new ActiveDeliveryWithItemsDto()
{
ActiveDeliveryInfo = _mapper.Map <ActiveDeliveryDto>(activeDelivery),
Items = _mapper.Map <IEnumerable <ActiveDeliveryItemDto> >(activeDelivery.Items),
};
foreach (var item in activeDeliveryWithDesc.Items)
{
var a = bookInfoResult.Message.Results.FirstOrDefault(b => b.Ean13.Equals(item.BookEan));
if (a is not null)
{
item.ItemDescription = _mapper.Map <ActiveDeliveryItemDescDto>(a);
}
}
return(activeDeliveryWithDesc);
}
public async Task <RedeemDeliveryCommandResult> Handle(RedeemDeliveryCommand request, CancellationToken cancellationToken)
{
var deliveryToRedeem = await _activeDeliveryRepository.FindByIdAsync(request.Id);
if (deliveryToRedeem is null)
{
return(new RedeemDeliveryCommandResult(false,
new List <string> {
$"Active Delivery: {request.Id} not found"
}));
}
// if (deliveryToRedeem.RedeemDelivery(out string error))
// return new RedeemDeliveryCommandResult(false, new List<string> {error});
if (!_activeDeliveryRepository.RedeemDelivery(deliveryToRedeem, out string error))
{
return(new RedeemDeliveryCommandResult(false, new List <string> {
error
}));
}
var createdStocks = new List <BookStock>();
foreach (var item in deliveryToRedeem.Items)
{
for (var i = 0; i < item.ItemsCount; i++)
{
var stockToAdd = new BookStock(deliveryToRedeem, item);
_bookStockRepository.Add(stockToAdd);
createdStocks.Add(stockToAdd);
}
}
var completedDelivery = new CompletedDelivery(deliveryToRedeem, createdStocks);
if (_completedDeliveryRepository.Add(completedDelivery) is null)
{
return(new RedeemDeliveryCommandResult(false,
new List <string> {
"Something wend wrong during adding Completed Delivery"
}));
}
if (await _activeDeliveryRepository.UnitOfWork.SaveChangesAsync() < 1)
{
return(new RedeemDeliveryCommandResult(false, new List <string>()
{
"Error occured during saving to DB"
}));
}
return(new RedeemDeliveryCommandResult(true));
}
public async Task <ScanItemDeliveryCommandResult> Handle(ScanItemDeliveryCommand request, CancellationToken cancellationToken)
{
var deliveryToScan = await _activeDeliveryRepository.FindByIdAsync(request.Id);
if (deliveryToScan is null)
{
return(new ScanItemDeliveryCommandResult(false,
new[] { $"Delivery Item: {request.Id} not found." }));
}
if (!deliveryToScan.IsScanOperationAllowed(request.ScanMode, request.RequestedEan, out List <string> errors))
{
return(new ScanItemDeliveryCommandResult(false, errors));
}
if (request.ScanMode)
{
deliveryToScan.ScanItem(request.RequestedEan);
}
else
{
deliveryToScan.UnscanItem(request.RequestedEan);
}
if (await _activeDeliveryRepository.UnitOfWork.SaveChangesAsync(cancellationToken) < 1)
{
return(new ScanItemDeliveryCommandResult(false,
new[] { $"Delivery Item: {request.Id} not found." }));
}
var activeDeliveryWithDesc = new ActiveDeliveryScanInfoDto()
{
ActiveDeliveryInfo = _mapper.Map <ActiveDeliveryDto>(deliveryToScan),
Items = _mapper.Map <IEnumerable <ActiveDeliveryScanItemInfoDto> >(deliveryToScan.Items),
};
return(new ScanItemDeliveryCommandResult(true, request.ScanMode, activeDeliveryWithDesc));
}
public async Task <EditActiveDeliveryCommandResult> Handle(EditActiveDeliveryCommand request, CancellationToken cancellationToken)
{
var resultExistance = await _client.GetResponse <BooksExitanceResult>(
new { BooksIdsWithEans = request.Items
.ToDictionary(key => key.BookId, value => value.BookEan) });
if (!resultExistance.Message.IsAllExists)
{
return(new EditActiveDeliveryCommandResult(false,
new [] { "Some of requested books not exists or they Ids do not match with corresponding Eans" }));
}
var activeDelivery = await _activeDeliveryRepository.FindByIdAsync(request.Id);
if (activeDelivery.IsAnyDeliveryItemsScanned)
{
return(new EditActiveDeliveryCommandResult(false,
new[] { $"You cant edit Active Delivery ID:{activeDelivery.Id} if it has scanned items!" }));
}
foreach (var item in request.Items)
{
activeDelivery.AddDeliveryItem(item.BookId, item.BookEan, item.ItemsCount);
activeDelivery.EditDeliveryItemsCount(item.ItemId, item.ItemsCount);
}
activeDelivery.DeleteMissingDeliveryItems(request.Items.Select(i => i.ItemId));
if (await _activeDeliveryRepository.UnitOfWork.SaveChangesAsync(cancellationToken) < 1)
{
return(new EditActiveDeliveryCommandResult(false,
new[] { $"Something went wrong during saving Active Delivery ID:{activeDelivery.Id}" }));
}
return(new EditActiveDeliveryCommandResult(true));
}