public async Task <Bill> CreateDomainBill(BillInfoAM billInfo, BasketAM basket)
{
var bill = await CalculateBill(billInfo, basket);
var domainBasket = await DomainBasketService.Create(
basket.KmValue,
basket.LoadingValue,
basket.LockedSteeringValue,
basket.LockedWheelsValue,
basket.OverturnedValue,
basket.DitchValue);
var domainBill = await DomainBillService.Create(
billInfo.PriceId,
domainBasket.Id,
billInfo.CommissionPercentage,
billInfo.DegreeOfDifficulty);
foreach (var item in bill.Items)
{
await CreateDomainBillItem(domainBill.Id, item);
}
// обновим счет, т.к. только после добавления элеметов счета у него появится итоговая стоимость
domainBill = await DomainBillService.Get(domainBill.Id);
if (domainBill.TotalCost != bill.TotalCost)
{
throw new ArgumentException(
$"TotalCost:{domainBill.TotalCost} of domain bill isn't equal TotalCost:{bill.TotalCost} of calculated bill",
"TotalCost");
}
return(domainBill);
}
public async Task <BillAM> CalculateBill(BillInfoAM billInfo, BasketAM basket)
{
var domainPrice = await PricelistService.GetDomainPrice(billInfo.PriceId);
if (domainPrice == null)
{
throw new EntityNotFoundException($"PriceId:{billInfo.PriceId} doesn't exist", "Price");
}
var result = new BillAM
{
Info = billInfo
};
if (basket.KmValue > 0)
{
var billItem = await CalculateBillItem(BillItem.KmBillKey, basket.KmValue, domainPrice.PerKm, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
if (basket.LoadingValue > 0)
{
var billItem = await CalculateBillItem(BillItem.LoadingBillKey, basket.LoadingValue, domainPrice.Loading, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
if (basket.LockedSteeringValue > 0)
{
var billItem = await CalculateBillItem(BillItem.LockedSteeringKey, basket.LockedSteeringValue, domainPrice.LockedSteering, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
if (basket.LockedWheelsValue > 0)
{
var billItem = await CalculateBillItem(BillItem.LockedWheelsKey, basket.LockedWheelsValue, domainPrice.LockedWheel, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
if (basket.OverturnedValue > 0)
{
var billItem = await CalculateBillItem(BillItem.OverturnedKey, basket.OverturnedValue, domainPrice.Overturned, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
if (basket.DitchValue > 0)
{
var billItem = await CalculateBillItem(BillItem.DitchKey, basket.DitchValue, domainPrice.Ditch, billInfo.DegreeOfDifficulty);
result.Items.Add(billItem);
}
result.TotalCost = result.Items.Select(i => i.Cost).Sum();
return(result);
}
public async Task CalculateBillWhenPriceDoesNotExist()
{
var domainPriceId = 1;
var billInfo = new BillInfoAM
{
PriceId = domainPriceId
};
var basket = new BasketAM();
Suite.PricelistServiceMock
.Setup(m => m.GetDomainPrice(billInfo.PriceId))
.Returns(Task.FromResult <Price>(null));
await Assert.ThrowsAsync <EntityNotFoundException>("Price", () => Suite.BillService.CalculateBill(billInfo, basket));
}
public async Task CalculateBillWhenInBasketOnlyKmAndLoading()
{
var domainPrice = new Price
{
Id = 123,
PerKm = 40m,
Loading = 900m,
LockedSteering = 400m,
LockedWheel = 300m,
Overturned = 1500m,
Ditch = 1000m
};
var billInfo = new BillInfoAM
{
PriceId = domainPrice.Id,
CommissionPercentage = 10,
DegreeOfDifficulty = 1.2f
};
var basket = new BasketAM
{
LockedWheelsValue = 0,
KmValue = 200,
LoadingValue = 1,
DitchValue = 0,
OverturnedValue = 0,
LockedSteeringValue = 0
};
Suite.PricelistServiceMock
.Setup(m => m.GetDomainPrice(billInfo.PriceId))
.ReturnsAsync(domainPrice);
var result = await Suite.BillService.CalculateBill(billInfo, basket);
Assert.Equal(billInfo, result.Info);
Assert.Equal(2, result.Items.Count);
}
public async Task CreateDomainBill()
{
var commonId = 1;
var billInfo = new BillInfoAM
{
PriceId = 123,
CommissionPercentage = 10,
DegreeOfDifficulty = 1
};
var basket = new BasketAM
{
LockedWheelsValue = 1,
KmValue = 200,
DitchValue = 1,
LoadingValue = 1,
OverturnedValue = 1,
LockedSteeringValue = 1
};
var domainBasket = new Basket {
Id = commonId++
};
var domainBill = new Bill
{
Id = commonId++,
PriceId = billInfo.PriceId,
CommissionPercentage = billInfo.CommissionPercentage,
DegreeOfDifficulty = billInfo.DegreeOfDifficulty
};
var domainPrice = new Price
{
Id = billInfo.PriceId,
PerKm = 40,
Loading = 900,
LockedSteering = 300,
LockedWheel = 400,
Ditch = 1000,
Overturned = 1200
};
Suite.DomainBasketServiceMock
.Setup(m => m.Create(
basket.KmValue,
basket.LoadingValue,
basket.LockedSteeringValue,
basket.LockedWheelsValue,
basket.OverturnedValue,
basket.DitchValue))
.ReturnsAsync(domainBasket);
Suite.PricelistServiceMock
.Setup(m => m.GetDomainPrice(billInfo.PriceId))
.ReturnsAsync(domainPrice);
Suite.DomainBillServiceMock
.Setup(m => m.Create(
billInfo.PriceId,
domainBasket.Id,
billInfo.CommissionPercentage,
billInfo.DegreeOfDifficulty))
.ReturnsAsync(domainBill);
Suite.DomainBillServiceMock
.Setup(m => m.Get(domainBill.Id))
.Returns(() => { domainBill.TotalCost = 11800; return(Task.FromResult(domainBill)); });
var result = await Suite.BillService.CreateDomainBill(billInfo, basket);
var perKmPrice = domainPrice.PerKm * (decimal)billInfo.DegreeOfDifficulty;
var kmCost = basket.KmValue * perKmPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.KmBillKey,
basket.KmValue,
perKmPrice,
kmCost));
var loadingPrice = domainPrice.Loading * (decimal)billInfo.DegreeOfDifficulty;
var loadingCost = basket.LoadingValue * loadingPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.LoadingBillKey,
basket.LoadingValue,
loadingPrice,
loadingCost));
var lockedSteeringPrice = domainPrice.LockedSteering * (decimal)billInfo.DegreeOfDifficulty;
var lockedSteeringCost = basket.LockedSteeringValue * lockedSteeringPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.LockedSteeringKey,
basket.LockedSteeringValue,
lockedSteeringPrice,
lockedSteeringCost));
var lockedWheelPrice = domainPrice.LockedWheel * (decimal)billInfo.DegreeOfDifficulty;
var lockedWheelsCost = basket.LockedWheelsValue * lockedWheelPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.LockedWheelsKey,
basket.LockedWheelsValue,
lockedWheelPrice,
lockedWheelsCost));
var overturnedPrice = domainPrice.Overturned * (decimal)billInfo.DegreeOfDifficulty;
var overturnedCost = basket.OverturnedValue * overturnedPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.OverturnedKey,
basket.OverturnedValue,
overturnedPrice,
overturnedCost));
var ditchPrice = domainPrice.Ditch * (decimal)billInfo.DegreeOfDifficulty;
var ditchCost = basket.DitchValue * ditchPrice;
Suite.DomainBillItemServiceMock
.Verify(m => m.Create(
domainBill.Id,
BillItem.DitchKey,
basket.DitchValue,
ditchPrice,
ditchCost));
// Надо получить счет заного, чтобы в нем была итоговая сумма
Suite.DomainBillServiceMock
.Verify(m => m.Get(domainBill.Id));
}
public async Task CalculateBill()
{
var domainPrice = new Price
{
Id = 123,
PerKm = 40m,
Loading = 900m,
LockedSteering = 400m,
LockedWheel = 300m,
Overturned = 1500m,
Ditch = 1000m
};
var billInfo = new BillInfoAM
{
PriceId = domainPrice.Id,
CommissionPercentage = 10,
DegreeOfDifficulty = 1.2f
};
var basket = new BasketAM
{
LockedWheelsValue = 1,
KmValue = 200,
DitchValue = 1,
LoadingValue = 1,
OverturnedValue = 1,
LockedSteeringValue = 1
};
Suite.PricelistServiceMock
.Setup(m => m.GetDomainPrice(billInfo.PriceId))
.ReturnsAsync(domainPrice);
var result = await Suite.BillService.CalculateBill(billInfo, basket);
Assert.Equal(billInfo, result.Info);
Assert.Equal(6, result.Items.Count);
var kmBillItem = result.Items[0];
var perKmPrice = domainPrice.PerKm * (decimal)billInfo.DegreeOfDifficulty;
var kmCost = basket.KmValue * perKmPrice;
Assert.Equal(BillItem.KmBillKey, kmBillItem.Key);
Assert.Equal(basket.KmValue, kmBillItem.Value);
Assert.Equal(perKmPrice, kmBillItem.Price);
Assert.Equal(kmCost, kmBillItem.Cost);
var loadingBillItem = result.Items[1];
var loadingPrice = domainPrice.Loading * (decimal)billInfo.DegreeOfDifficulty;
var loadingCost = basket.LoadingValue * loadingPrice;
Assert.Equal(BillItem.LoadingBillKey, loadingBillItem.Key);
Assert.Equal(basket.LoadingValue, loadingBillItem.Value);
Assert.Equal(loadingPrice, loadingBillItem.Price);
Assert.Equal(loadingCost, loadingBillItem.Cost);
var lockedSteeringBillItem = result.Items[2];
var lockedSteeringPrice = domainPrice.LockedSteering * (decimal)billInfo.DegreeOfDifficulty;
var lockedSteeringCost = basket.LockedSteeringValue * lockedSteeringPrice;
Assert.Equal(BillItem.LockedSteeringKey, lockedSteeringBillItem.Key);
Assert.Equal(basket.LockedSteeringValue, lockedSteeringBillItem.Value);
Assert.Equal(lockedSteeringPrice, lockedSteeringBillItem.Price);
Assert.Equal(lockedSteeringCost, lockedSteeringBillItem.Cost);
var lockedWheelBillItem = result.Items[3];
var lockedWheelPrice = domainPrice.LockedWheel * (decimal)billInfo.DegreeOfDifficulty;
var lockedWheelsCost = basket.LockedWheelsValue * lockedWheelPrice;
Assert.Equal(BillItem.LockedWheelsKey, lockedWheelBillItem.Key);
Assert.Equal(basket.LockedWheelsValue, lockedWheelBillItem.Value);
Assert.Equal(lockedWheelPrice, lockedWheelBillItem.Price);
Assert.Equal(lockedWheelsCost, lockedWheelBillItem.Cost);
var overturnedBillItem = result.Items[4];
var overturnedPrice = domainPrice.Overturned * (decimal)billInfo.DegreeOfDifficulty;
var overturnedCost = basket.OverturnedValue * overturnedPrice;
Assert.Equal(BillItem.OverturnedKey, overturnedBillItem.Key);
Assert.Equal(basket.OverturnedValue, overturnedBillItem.Value);
Assert.Equal(overturnedPrice, overturnedBillItem.Price);
Assert.Equal(overturnedCost, overturnedBillItem.Cost);
var ditchBillItem = result.Items[5];
var ditchPrice = domainPrice.Ditch * (decimal)billInfo.DegreeOfDifficulty;
var ditchCost = basket.DitchValue * ditchPrice;
Assert.Equal(BillItem.DitchKey, ditchBillItem.Key);
Assert.Equal(basket.DitchValue, ditchBillItem.Value);
Assert.Equal(ditchPrice, ditchBillItem.Price);
Assert.Equal(ditchCost, ditchBillItem.Cost);
var totalCost = kmCost + loadingCost + lockedSteeringCost + lockedWheelsCost + overturnedCost + ditchCost;
Assert.Equal(totalCost, result.TotalCost);
}
public async Task CalculateBookingRoute()
{
var commonId = 1;
var rootAddress = new AddressAM
{
Locality = "Ярославль",
Latitude = 11.1111,
Longitude = 22.2222
};
var billInfo = new BillInfoAM
{
PriceId = commonId++,
CommissionPercentage = 10,
DegreeOfDifficulty = 1
};
var basket = new BasketAM
{
KmValue = 0,
LoadingValue = 1,
LockedSteeringValue = 0,
LockedWheelsValue = 3,
OverturnedValue = 0,
DitchValue = 1
};
var cargo = new CargoAM
{
BrandCatalogItemId = commonId++,
KindCatalogItemId = commonId++,
RegistrationNumber = "e111ey777",
WeightCatalogItemId = commonId++
};
var route = new RouteAM
{
Legs =
{
new RouteLegAM {
Kind = RouteLegKind.Feed, Distance = 3000, Duration = 1200
},
new RouteLegAM {
Kind = RouteLegKind.Transportation, Distance = 100000, Duration = 7200
},
new RouteLegAM {
Kind = RouteLegKind.WayBack, Distance = 103000, Duration = 8400
}
}
};
var feedDistance = route.Legs[0].Distance;
var feedDuration = route.Legs[0].Duration;
var totalDistance = route.Legs.Select(l => l.Distance).Sum();
var bill = new BillAM {
TotalCost = 100
};
var title = $"{rootAddress.Locality} - {bill.TotalCost}₽";
Suite.RouteServiceMock
.Setup(m => m.GetRootAddress(route))
.Returns(rootAddress);
Suite.RouteServiceMock
.Setup(m => m.GetFeedDistance(route))
.Returns(feedDistance);
Suite.RouteServiceMock
.Setup(m => m.GetFeedDuration(route))
.Returns(feedDuration);
Suite.RouteServiceMock
.Setup(m => m.GetTotalDistance(route))
.Returns(totalDistance);
Suite.BillServiceMock
.Setup(m => m.GetBillInfo(
It.Is <Coordinate>(c => c.Latitude.Equals(rootAddress.Latitude) && c.Longitude.Equals(rootAddress.Longitude)),
cargo.WeightCatalogItemId))
.ReturnsAsync(billInfo);
Suite.BillServiceMock
.Setup(m => m.CalculateBill(
billInfo,
It.Is <BasketAM>(b => (b != basket) && b.KmValue.Equals(totalDistance))))
.ReturnsAsync(bill);
var result = await Suite.BookingService.CalculateBookingRoute(route, cargo, basket);
Assert.Equal(rootAddress, result.RootAddress);
Assert.Equal(feedDistance, result.FeedDistance);
Assert.Equal(feedDuration, result.FeedDuration);
Assert.Equal(totalDistance, result.TotalDistance);
Assert.Equal(bill, result.Bill);
Assert.Equal(title, result.Title);
}
