public async Task <AggregateValidationResult> CreateAsync(Order order, CatalogueItemId catalogueItemId, CreateOrderItemModel model)
{
var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, true);
var aggregateValidationResult = orderItemValidator.Validate(order, model, catalogueItemType);
if (!aggregateValidationResult.Success)
{
return(aggregateValidationResult);
}
var catalogueItem = await AddOrUpdateCatalogueItem(catalogueItemId, model, catalogueItemType);
var serviceRecipients = await AddOrUpdateServiceRecipients(model);
var pricingUnit = await AddOrUpdatePricingUnit(model);
var defaultDeliveryDate = order.DefaultDeliveryDates.SingleOrDefault(d => d.CatalogueItemId == catalogueItemId);
var provisioningType = Enum.Parse <ProvisioningType>(model.ProvisioningType, true);
var estimationPeriod = catalogueItemType.InferEstimationPeriod(
provisioningType,
OrderingEnums.ParseTimeUnit(model.EstimationPeriod));
var item = order.AddOrUpdateOrderItem(new OrderItem
{
CatalogueItem = catalogueItem,
CataloguePriceType = Enum.Parse <CataloguePriceType>(model.Type, true),
CurrencyCode = model.CurrencyCode,
DefaultDeliveryDate = defaultDeliveryDate?.DeliveryDate,
EstimationPeriod = estimationPeriod,
OrderId = order.Id,
PriceId = model.PriceId,
Price = model.Price,
PricingUnit = pricingUnit,
PriceTimeUnit = model.TimeUnit?.ToTimeUnit(),
ProvisioningType = Enum.Parse <ProvisioningType>(model.ProvisioningType, true),
});
item.SetRecipients(model.ServiceRecipients.Select(r => new OrderItemRecipient
{
DeliveryDate = r.DeliveryDate,
Quantity = r.Quantity.GetValueOrDefault(),
Recipient = serviceRecipients[r.OdsCode],
}));
if (defaultDeliveryDate is not null)
{
context.DefaultDeliveryDate.Remove(defaultDeliveryDate);
}
await context.SaveChangesAsync();
return(aggregateValidationResult);
}
public static async Task CreateAsync_SetsEstimationPeriod(
[Frozen] ApplicationDbContext context,
[Frozen] Mock <ICreateOrderItemValidator> orderItemValidator,
[Frozen] Mock <IServiceRecipientService> serviceRecipientService,
Order order,
CatalogueItemId catalogueItemId,
CreateOrderItemModel model,
CreateOrderItemService service)
{
context.Order.Add(order);
await context.SaveChangesAsync();
var aggregateValidationResult = new AggregateValidationResult();
aggregateValidationResult.AddValidationResult(new ValidationResult(), 0);
var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, true);
var provisioningType = Enum.Parse <ProvisioningType>(model.ProvisioningType, true);
var serviceRecipients = model.ServiceRecipients.Select(r => new ServiceRecipient(r.OdsCode, r.Name));
orderItemValidator.Setup(o => o.Validate(order, model, catalogueItemType)).Returns(aggregateValidationResult);
serviceRecipientService.Setup(r => r.AddOrUpdateServiceRecipients(It.IsAny <IEnumerable <ServiceRecipient> >()))
.ReturnsAsync(serviceRecipients.ToDictionary(r => r.OdsCode));
await service.CreateAsync(order, catalogueItemId, model);
var expectedEstimationPeriod = catalogueItemType.InferEstimationPeriod(
provisioningType,
OrderingEnums.ParseTimeUnit(model.EstimationPeriod));
var expectedOrderItem = context.Set <OrderItem>().First(o => o.OrderId.Equals(order.Id));
expectedOrderItem.EstimationPeriod.Should().Be(expectedEstimationPeriod);
}
internal TimeUnit?ToTimeUnit() => OrderingEnums.ParseTimeUnit(Name);
public static void ParseIgnoreCase_InvalidValue_ThrowsException()
{
Assert.Throws <ArgumentException>(() => OrderingEnums.ParseStrictIgnoreCase <CataloguePriceType>("InvalidPriceType"));
}
public static void ParseIgnoreCase_ReturnsExpectedEnumValue(string value, CataloguePriceType expected)
{
var actual = OrderingEnums.ParseStrictIgnoreCase <CataloguePriceType>(value);
actual.Should().Be(expected);
}
public static void Parse_Undefined_ReturnsNull()
{
var enumValue = OrderingEnums.Parse <ProvisioningType>("DoesNotExist");
enumValue.Should().BeNull();
}
public static void Parse_ReturnsExpectedEnumValue(ProvisioningType provisioningType)
{
var enumValue = OrderingEnums.Parse <ProvisioningType>(provisioningType.GetName());
enumValue.Should().Be(provisioningType);
}
public static void Parse_NullOrWhiteSpaceValue_ReturnsNull(string value)
{
var enumValue = OrderingEnums.ParseTimeUnit(value);
enumValue.Should().BeNull();
}
public static void ParseTimeUnit_ReturnsExpectedValue(string value, TimeUnit expectedResult)
{
var timeUnit = OrderingEnums.ParseTimeUnit(value);
timeUnit.Should().Be(expectedResult);
}
public static void ParseTimeUnit_Undefined_ReturnsZero()
{
var timeUnit = OrderingEnums.ParseTimeUnit("DoesNotExist");
timeUnit.Should().Be(OrderingEnums.UndefinedTimeUnit);
}
private static bool BeValidEstimationPeriod(string estimationPeriod)
{
return(OrderingEnums.ParseTimeUnit(estimationPeriod) != 0);
}
