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); }