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