public async Task <Order> GetOrder(CallOffId callOffId, CatalogueItemId catalogueItemId) { return(await context.Order .Where(o => o.Id == callOffId.Id) .Include(o => o.DefaultDeliveryDates.Where(d => d.CatalogueItemId == catalogueItemId)) .SingleOrDefaultAsync()); }
public static async Task AddOrUpdateAsync_Add_ReturnsExpectedStatusCode( [Frozen] Mock <IDefaultDeliveryDateService> service, [Frozen] CallOffId callOffId, [Frozen] CatalogueItemId catalogueItemId, Order order, DefaultDeliveryDateModel defaultDeliveryDate, [Frozen] Mock <IDefaultDeliveryDateValidator> validator, DefaultDeliveryDateController controller) { service.Setup(o => o.GetOrder(callOffId, catalogueItemId)).ReturnsAsync(order); service.Setup(o => o.SetDefaultDeliveryDate(callOffId, catalogueItemId, defaultDeliveryDate.DeliveryDate.Value)).Callback(() => { order.SetDefaultDeliveryDate(catalogueItemId, defaultDeliveryDate.DeliveryDate !.Value); }); validator.Setup(v => v.Validate(defaultDeliveryDate, order.CommencementDate)).Returns((true, null)); var response = await controller.AddOrUpdateAsync(callOffId, catalogueItemId, defaultDeliveryDate); service.Verify(o => o.GetOrder(callOffId, catalogueItemId)); service.Verify(o => o.SetDefaultDeliveryDate(callOffId, catalogueItemId, defaultDeliveryDate.DeliveryDate.Value)); response.Should().BeOfType <CreatedAtActionResult>(); response.As <CreatedAtActionResult>().Should().BeEquivalentTo(new { ActionName = "Get", RouteValues = new RouteValueDictionary { { nameof(callOffId), callOffId.ToString() }, { nameof(catalogueItemId), catalogueItemId.ToString() }, }, }); }
public static async Task <OrderItem> GetOrderItemWithId(Order order, string solutionId, string connectionString, OrderingDbContext context) { var newPricingUnit = await GetPricingUnitAsync(ProvisioningType.Declarative, connectionString); var pricingUnit = await context.FindAsync <PricingUnit>(newPricingUnit.Name) ?? newPricingUnit; var selectedItem = (await SupplierInfo.GetPublishedCatalogueItemsNoTieredAsync(connectionString, order.Supplier.Id, CatalogueItemType.Solution)) .Single(s => s.CatalogueItemId.ToString().Equals(solutionId)); var catalogueItem = await context.FindAsync <CatalogueItem>(CatalogueItemId.ParseExact(solutionId)) ?? selectedItem.ToDomain(); var orderItem = new OrderItemBuilder(order.Id) .WithCatalogueItem(catalogueItem) .WithCataloguePriceType(CataloguePriceType.Flat) .WithCurrencyCode() .WithDefaultDeliveryDate(DateTime.Today) .WithPrice(0.01M) .WithPricingTimeUnit(TimeUnit.PerYear) .WithProvisioningType(ProvisioningType.Declarative) .WithPricingUnit(pricingUnit) .WithEstimationPeriod(TimeUnit.PerMonth); return(orderItem.Build()); }
public async Task <IActionResult> AddOrUpdateAsync( CallOffId callOffId, CatalogueItemId catalogueItemId, DefaultDeliveryDateModel model) { if (model is null) { throw new ArgumentNullException(nameof(model)); } Order order = await defaultDeliveryDateService.GetOrder(callOffId, catalogueItemId); if (order is null) { return(NotFound()); } (bool isValid, ErrorsModel errors) = validator.Validate(model, order.CommencementDate); if (!isValid) { return(BadRequest(errors)); } // ReSharper disable once PossibleInvalidOperationException (covered by model validation) DeliveryDateResult addedOrUpdated = await defaultDeliveryDateService.SetDefaultDeliveryDate(callOffId, catalogueItemId, model.DeliveryDate.Value); return(addedOrUpdated == DeliveryDateResult.Added ? CreatedAtAction(nameof(GetAsync).TrimAsync(), new { callOffId = callOffId.ToString(), catalogueItemId = catalogueItemId.ToString() }, null) : Ok()); }
public async Task <IActionResult> CreateOrderItemAsync( CallOffId callOffId, CatalogueItemId catalogueItemId, CreateOrderItemModel model) { if (model is null) { throw new ArgumentNullException(nameof(model)); } var order = await orderItemService.GetOrder(callOffId); if (order is null) { return(NotFound()); } var validationResult = await createOrderItemService.CreateAsync(order, catalogueItemId, model); if (validationResult.Success) { return(CreatedAtAction( nameof(GetAsync).TrimAsync(), new { callOffId = callOffId.ToString(), catalogueItemId = catalogueItemId.ToString() }, null)); } foreach ((string key, string errorMessage) in validationResult.ToModelErrors()) { ModelState.AddModelError(key, errorMessage); } return(ValidationProblem(ModelState)); }
public static async Task CreateAsync_RemovesDefaultDeliveryDate( [Frozen] ApplicationDbContext context, [Frozen] Mock <ICreateOrderItemValidator> orderItemValidator, [Frozen] Mock <IServiceRecipientService> serviceRecipientService, Order order, CatalogueItemId catalogueItemId, CreateOrderItemModel model, CreateOrderItemService service) { order.SetDefaultDeliveryDate(catalogueItemId, DateTime.Now.AddDays(10)); context.Order.Add(order); await context.SaveChangesAsync(); order.DefaultDeliveryDates.Should().NotBeEmpty(); var aggregateValidationResult = new AggregateValidationResult(); aggregateValidationResult.AddValidationResult(new ValidationResult(), 0); var catalogueItemType = Enum.Parse <CatalogueItemType>(model.CatalogueItemType, 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 defaultDeliveryDateResult = context.Set <DefaultDeliveryDate>().FirstOrDefault(d => d.OrderId.Equals(order.Id)); defaultDeliveryDateResult.Should().BeNull(); }
public async Task GivenACatalogueSolutionHasBeenAddedToTheOrder() { var order = (Order)Context[ContextKeys.CreatedOrder]; var solutions = await SupplierInfo.GetPublishedCatalogueItemsNoTieredAsync(Test.BapiConnectionString, order.Supplier.Id, CatalogueItemType.Solution); var selectedItem = solutions.First(); var catalogueItem = await DbContext.FindAsync <CatalogueItem>(CatalogueItemId.ParseExact(selectedItem.CatalogueItemId)) ?? selectedItem.ToDomain(); var pricingUnitName = "per banana"; var pricingUnit = await DbContext.FindAsync <PricingUnit>(pricingUnitName) ?? new PricingUnit { Name = pricingUnitName, }; var orderItem = new OrderItemBuilder(order.Id) .WithCatalogueItem(catalogueItem) .WithCataloguePriceType(CataloguePriceType.Flat) .WithCurrencyCode() .WithDefaultDeliveryDate(DateTime.Today) .WithPrice(0.01M) .WithPricingTimeUnit(TimeUnit.PerMonth) .WithProvisioningType(ProvisioningType.Declarative) .WithPricingUnit(pricingUnit) .Build(); order.AddOrUpdateOrderItem(orderItem); await DbContext.SaveChangesAsync(); }
public void Configure(EntityTypeBuilder <CatalogueItem> builder) { builder.ToTable("CatalogueItem"); builder.HasKey(i => i.Id); builder.Property(i => i.Id) .IsRequired() .HasMaxLength(14) .HasConversion(id => id.ToString(), id => CatalogueItemId.ParseExact(id)); builder.Property(i => i.Name) .IsRequired() .HasMaxLength(256); const string catalogueItemTypeId = "CatalogueItemTypeId"; builder .Property(i => i.CatalogueItemType) .HasConversion <int>() .HasColumnName(catalogueItemTypeId); builder.HasOne <CatalogueItem>() .WithMany() .HasForeignKey(i => i.ParentCatalogueItemId) .HasConstraintName("FK_CatalogueItem_ParentCatalogueItem"); }
public static void AddOrUpdateAsync_NullDefaultDeliveryDateModel_ThrowsArgumentNullException( CallOffId callOffId, CatalogueItemId catalogueItemId, DefaultDeliveryDateController controller) { Assert.ThrowsAsync <ArgumentNullException>(() => controller.AddOrUpdateAsync(callOffId, catalogueItemId, null)); }
public static async Task AddOrUpdateAsync_AddsDefaultDeliveryDate( [Frozen] Mock <IDefaultDeliveryDateService> service, [Frozen] CallOffId callOffId, [Frozen] CatalogueItemId catalogueItemId, Order order, DefaultDeliveryDateModel defaultDeliveryDate, [Frozen] Mock <IDefaultDeliveryDateValidator> validator, DefaultDeliveryDateController controller) { service.Setup(o => o.GetOrder(callOffId, catalogueItemId)).ReturnsAsync(order); service.Setup(o => o.SetDefaultDeliveryDate(callOffId, catalogueItemId, defaultDeliveryDate.DeliveryDate.Value)).Callback(() => { order.SetDefaultDeliveryDate(catalogueItemId, defaultDeliveryDate.DeliveryDate !.Value); }); validator.Setup(v => v.Validate(defaultDeliveryDate, order.CommencementDate)).Returns((true, null)); order.DefaultDeliveryDates.Should().BeEmpty(); await controller.AddOrUpdateAsync(callOffId, catalogueItemId, defaultDeliveryDate); service.Verify(o => o.GetOrder(callOffId, catalogueItemId)); service.Verify(o => o.SetDefaultDeliveryDate(callOffId, catalogueItemId, defaultDeliveryDate.DeliveryDate.Value)); var expectedDeliveryDate = new DefaultDeliveryDate { OrderId = callOffId.Id, CatalogueItemId = catalogueItemId, DeliveryDate = defaultDeliveryDate.DeliveryDate.GetValueOrDefault(), }; order.DefaultDeliveryDates.Should().HaveCount(1); order.DefaultDeliveryDates.Should().Contain(expectedDeliveryDate); }
public static void DeleteOrderItemAndUpdateProgress_CataloguesSolutionsNotDeleted_AdditionalServicesViewedNotChanged( CatalogueItemId catalogueItemId, Order order) { var orderItem1 = OrderItemBuilder.Create() .WithCatalogueItem(new CatalogueItem { Id = catalogueItemId, CatalogueItemType = CatalogueItemType.Solution, }).Build(); var orderItem2 = OrderItemBuilder.Create() .WithCatalogueItem(new CatalogueItem { CatalogueItemType = CatalogueItemType.Solution, }).Build(); var childOrderItem = OrderItemBuilder.Create() .WithCatalogueItem( new CatalogueItem { CatalogueItemType = CatalogueItemType.AdditionalService, ParentCatalogueItemId = catalogueItemId, }).Build(); order.AddOrUpdateOrderItem(orderItem1); order.AddOrUpdateOrderItem(orderItem2); order.AddOrUpdateOrderItem(childOrderItem); order.Progress.AdditionalServicesViewed = true; order.DeleteOrderItemAndUpdateProgress(orderItem1.CatalogueItem.Id); order.Progress.AdditionalServicesViewed.Should().BeTrue(); }
public static async Task CreateOrderItemsAsync_ValidationFailure_ReturnsExpectedResponse( ErrorDetails errorDetails, AggregateValidationResult aggregateValidationResult, [Frozen] Mock <ICreateOrderItemService> createOrderItemService, [Frozen] Mock <IOrderItemService> orderItemService, [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, Order order, CreateOrderItemModel model, OrderItemsController controller) { controller.ProblemDetailsFactory = new TestProblemDetailsFactory(); aggregateValidationResult.AddValidationResult(new ValidationResult(errorDetails), 0); Expression <Func <ICreateOrderItemService, Task <AggregateValidationResult> > > createAsync = s => s.CreateAsync( It.Is <Order>(o => o.Equals(order)), It.Is <CatalogueItemId>(i => i == catalogueItemId), It.Is <CreateOrderItemModel>(m => m == model)); orderItemService.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order); createOrderItemService.Setup(createAsync).ReturnsAsync(aggregateValidationResult); var response = await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); response.Should().BeOfType <BadRequestObjectResult>(); response.As <BadRequestObjectResult>().Value.Should().BeOfType <ValidationProblemDetails>(); }
public static async Task CreateAsync_CatalogueItemSavedToDb( [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 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 expectedOrderItem = context.Set <OrderItem>().First(o => o.CatalogueItem.Id.Equals(catalogueItemId)); expectedOrderItem.CatalogueItem.Name.Should().Be(model.CatalogueItemName); }
public static async Task CreateOrderItemAsync_ValidationFailure_AddsModelErrors( [Frozen] IReadOnlyList <ErrorDetails> errorDetails, AggregateValidationResult aggregateValidationResult, [Frozen] Mock <ICreateOrderItemService> createOrderItemService, [Frozen] Mock <IOrderItemService> orderItemService, [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, Order order, CreateOrderItemModel model, OrderItemsController controller) { controller.ProblemDetailsFactory = new TestProblemDetailsFactory(); aggregateValidationResult.AddValidationResult(new ValidationResult(errorDetails), 0); Expression <Func <ICreateOrderItemService, Task <AggregateValidationResult> > > createAsync = s => s.CreateAsync( It.Is <Order>(o => o.Equals(order)), It.Is <CatalogueItemId>(i => i == catalogueItemId), It.Is <CreateOrderItemModel>(m => m == model)); orderItemService.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order); createOrderItemService.Setup(createAsync).ReturnsAsync(aggregateValidationResult); await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); var modelState = controller.ModelState; modelState.ErrorCount.Should().Be(errorDetails.Count); modelState.Keys.Should().BeEquivalentTo(errorDetails.Select(e => e.ParentName + "[0]." + e.Field)); var modelStateErrors = modelState.Values.Select(v => v.Errors[0].ErrorMessage); modelStateErrors.Should().BeEquivalentTo(errorDetails.Select(e => e.Id)); }
public static async Task CreateOrderItemAsync_OrderExists_ReturnsCreatedAtActionResult( [Frozen] Mock <ICreateOrderItemService> createOrderItemService, [Frozen] Mock <IOrderItemService> orderItemService, [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, Order order, CreateOrderItemModel model, OrderItemsController controller) { Expression <Func <ICreateOrderItemService, Task <AggregateValidationResult> > > createAsync = s => s.CreateAsync( It.Is <Order>(o => o.Equals(order)), It.Is <CatalogueItemId>(i => i == catalogueItemId), It.Is <CreateOrderItemModel>(m => m == model)); orderItemService.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order); createOrderItemService.Setup(createAsync).ReturnsAsync(new AggregateValidationResult()); var result = await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); result.Should().BeOfType <CreatedAtActionResult>(); result.As <CreatedAtActionResult>().Should().BeEquivalentTo(new { ActionName = "Get", RouteValues = new RouteValueDictionary { { nameof(callOffId), callOffId.ToString() }, { nameof(catalogueItemId), catalogueItemId.ToString() }, }, }); }
public void Configure(EntityTypeBuilder <OrderItemRecipient> builder) { const string catalogueItemId = "CatalogueItemId"; const string odsCode = "OdsCode"; const string orderId = "OrderId"; builder.ToTable("OrderItemRecipients"); builder.Property <int>(orderId).IsRequired(); builder.Property <CatalogueItemId>(catalogueItemId) .HasMaxLength(14) .HasConversion(id => id.ToString(), id => CatalogueItemId.ParseExact(id)); builder.Property <string>(odsCode).HasMaxLength(8); builder.HasKey(orderId, catalogueItemId, odsCode); builder.Property(r => r.DeliveryDate).HasColumnType("date"); builder.HasOne(r => r.Recipient) .WithMany() .HasForeignKey(odsCode) .OnDelete(DeleteBehavior.ClientSetNull) .HasConstraintName("FK_OrderItemRecipients_OdsCode"); builder.HasOne <OrderItem>() .WithMany(i => i.OrderItemRecipients) .HasForeignKey(orderId, catalogueItemId) .HasConstraintName("FK_OrderItemRecipients_OrderItem"); }
public static void Parse_ValidId_ReturnsExpectedResult() { (bool success, CatalogueItemId id) = CatalogueItemId.Parse("999999-ItemId"); success.Should().BeTrue(); id.Should().Be(new CatalogueItemId(999999, "ItemId")); }
public static void DeleteOrderItemAndUpdateProgress_AllCataloguesSolutionsDeleted_SetsAdditionalServicesViewedToFalse( CatalogueItemId catalogueItemId, Order order) { var parentOrderItem = OrderItemBuilder.Create() .WithCatalogueItem(new CatalogueItem { Id = catalogueItemId, CatalogueItemType = CatalogueItemType.Solution, }).Build(); var childOrderItem = OrderItemBuilder.Create() .WithCatalogueItem( new CatalogueItem { CatalogueItemType = CatalogueItemType.AdditionalService, ParentCatalogueItemId = catalogueItemId, }).Build(); order.Progress.AdditionalServicesViewed = true; order.AddOrUpdateOrderItem(parentOrderItem); order.AddOrUpdateOrderItem(childOrderItem); order.DeleteOrderItemAndUpdateProgress(catalogueItemId); order.Progress.AdditionalServicesViewed.Should().BeFalse(); }
public static void ToString_ReturnsExpectedResult() { var id = new CatalogueItemId(1, "1"); var idAsString = id.ToString(); idAsString.Should().Be("1-1"); }
public static void CreateOrderItemAsync_NullModel_ThrowsException( CallOffId callOffId, CatalogueItemId catalogueItemId, OrderItemsController controller) { Assert.ThrowsAsync <ArgumentNullException>( async() => await controller.CreateOrderItemAsync(callOffId, catalogueItemId, null)); }
public void Configure(EntityTypeBuilder <OrderItem> builder) { const string catalogueItemId = "CatalogueItemId"; builder.ToTable("OrderItem"); builder.Property <CatalogueItemId>(catalogueItemId) .HasMaxLength(14) .HasConversion(id => id.ToString(), id => CatalogueItemId.ParseExact(id)); builder.Property(o => o.OrderId).IsRequired(); builder.HasKey(nameof(OrderItem.OrderId), catalogueItemId); builder.Property(i => i.Created).HasDefaultValueSql("(GetUtcDate())"); builder.Property(i => i.CurrencyCode) .IsRequired() .HasMaxLength(3); builder.Property(i => i.DefaultDeliveryDate).HasColumnType("date"); builder.Property(i => i.LastUpdated).HasDefaultValueSql("(GetUtcDate())"); builder.Property(i => i.Price).HasColumnType("decimal(18, 4)"); builder.HasOne(i => i.CatalogueItem) .WithMany() .HasForeignKey(catalogueItemId) .OnDelete(DeleteBehavior.ClientSetNull) .HasConstraintName("FK_OrderItem_CatalogueItem"); builder .Property(i => i.CataloguePriceType) .HasConversion <int>() .HasColumnName("CataloguePriceTypeId"); builder .Property(i => i.EstimationPeriod) .HasConversion <int>() .HasColumnName("EstimationPeriodId"); builder.HasOne <Order>() .WithMany(o => o.OrderItems) .HasForeignKey(o => o.OrderId) .HasConstraintName("FK_OrderItem_Order"); builder.HasOne(i => i.PricingUnit) .WithMany() .HasForeignKey("PricingUnitName") .OnDelete(DeleteBehavior.ClientSetNull) .HasConstraintName("FK_OrderItem_PricingUnit"); builder .Property(i => i.ProvisioningType) .HasConversion <int>() .HasColumnName("ProvisioningTypeId"); builder .Property(i => i.PriceTimeUnit) .HasConversion <int>() .HasColumnName("TimeUnitId"); }
public static async Task GetAsync_OrderItemDoesNotExist_ReturnsNotFound( CallOffId callOffId, CatalogueItemId catalogueItemId, OrderItemsController controller) { var response = await controller.GetAsync(callOffId, catalogueItemId); response.Result.Should().BeOfType <NotFoundResult>(); }
public static void Equals_Object_DifferentType_ReturnsFalse() { var catalogueItemId = new CatalogueItemId(1, "1"); var obj = new { SupplierId = 1, ItemId = 1 }; var result = catalogueItemId.Equals(obj); result.Should().BeFalse(); }
public static async Task GetDefaultDeliveryDate_ReturnsNull( CallOffId callOffId, CatalogueItemId catalogueItemId, DefaultDeliveryDateService service) { var result = await service.GetDefaultDeliveryDate(callOffId, catalogueItemId); result.Should().BeNull(); }
public static async Task AddOrUpdateAsync_BadCatalogueItemId_ReturnsNotFound( [Frozen] CallOffId callOffId, CatalogueItemId catalogueItemId, DefaultDeliveryDateModel model, DefaultDeliveryDateController controller) { var response = await controller.AddOrUpdateAsync(callOffId, catalogueItemId, model); response.Should().BeOfType <NotFoundResult>(); }
public static async Task CreateOrderItemAsync_OrderDoesNotExist_ReturnsNotFound( CallOffId callOffId, CatalogueItemId catalogueItemId, CreateOrderItemModel model, OrderItemsController controller) { var result = await controller.CreateOrderItemAsync(callOffId, catalogueItemId, model); result.Should().BeOfType <NotFoundResult>(); }
public static void GetHashCode_ReturnsExpectedResult(CatalogueItemId id) { var item = new CatalogueItem { Id = id }; var hash = item.GetHashCode(); hash.Should().Be(item.Id.GetHashCode()); }
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 void Equals_Object_OtherIsDifferentType_ReturnsFalse(CatalogueItemId id) { var item1 = new CatalogueItem { Id = id }; var item2 = new { Id = id }; var result = item1.Equals(item2); result.Should().BeFalse(); }
public static CatalogueItem ToDomain(this CatalogueItemModel model) { return(model is null ? null : new CatalogueItem { Id = CatalogueItemId.ParseExact(model.CatalogueItemId), Name = model.Name, CatalogueItemType = model.CatalogueItemType, ParentCatalogueItemId = model.ParentCatalogueItemId, }); }