public static void Constructor_InitializesType(
[Frozen] CataloguePriceType priceType,
OrderItem orderItem)
{
var model = new GetOrderItemModel(orderItem);
model.Type.Should().Be(priceType.ToString());
}
public void List_ReturnsExpectedList()
{
var actual = CataloguePriceType.List();
var expected = new List <CataloguePriceType>
{
CataloguePriceType.Flat,
CataloguePriceType.Tiered,
};
actual.Should().BeEquivalentTo(expected);
}
private CreateCatalogueSolutionOrderItemRequestPayloadBuilder()
{
_odsCode = "ODS1";
_catalogueSolutionId = "100001-001";
_catalogueSolutionName = Guid.NewGuid().ToString();
_deliveryDate = DateTime.UtcNow.Date;
_quantity = 5;
_estimationPeriod = TimeUnit.Month;
_provisioningType = ProvisioningType.OnDemand;
_cataloguePriceType = CataloguePriceType.Flat;
_currencyCode = "GBP";
_itemUnitName = "consultation";
_itemUnitNameDescription = "per consultation";
_price = 1.5m;
}
private OrderItemBuilder()
{
_odsCode = "ODS1";
_catalogueItemId = "1000-001";
_catalogueItemType = CatalogueItemType.Solution;
_catalogueItemName = Guid.NewGuid().ToString();
_provisioningType = ProvisioningType.Patient;
_cataloguePriceType = CataloguePriceType.Flat;
_cataloguePriceUnit = CataloguePriceUnit.Create("patients", "per patient");
_priceTimeUnit = null;
_currencyCode = "GBP";
_quantity = 10;
_estimationPeriod = TimeUnit.PerYear;
_deliveryDate = DateTime.UtcNow;
_price = 2.000m;
}
public async Task <Result <int> > CreateAsync(CreateOrderItemRequest request)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var provisioningType = ProvisioningType.FromName(request.ProvisioningTypeName);
var cataloguePriceType = CataloguePriceType.FromName(request.CataloguePriceTypeName);
var cataloguePriceUnit = CataloguePriceUnit.Create(request.CataloguePriceUnitTierName, request.CataloguePriceUnitDescription);
var priceTimeUnit = TimeUnit.FromName(request.PriceTimeUnitName);
var estimationPeriod = TimeUnit.FromName(request.EstimationPeriodName);
var orderItem = new OrderItem(
request.OdsCode,
request.CatalogueItemId,
request.CatalogueItemType,
request.CatalogueItemName,
provisioningType,
cataloguePriceType,
cataloguePriceUnit,
priceTimeUnit,
request.CurrencyCode,
request.Quantity,
estimationPeriod,
request.DeliveryDate,
request.Price);
Order order = request.Order;
order.AddOrderItem(orderItem,
_identityService.GetUserIdentity(),
_identityService.GetUserName());
await _orderRepository.UpdateOrderAsync(order);
return(Result.Success(orderItem.OrderItemId));
}
public static async Task <OrderItem> CreateOrderItem(
Order order,
CatalogueItemType catalogueItemType,
CataloguePriceType cataloguePriceType,
ProvisioningType provisioningType,
OrderingDbContext context,
string connectionString,
TimeUnit timeUnit = TimeUnit.PerYear)
{
var solution = await SupplierInfo.GetPublishedCatalogueItemsNoTieredAsync(connectionString, order.Supplier.Id, catalogueItemType);
var selectedItem = RandomInformation.GetRandomItem(solution);
var catalogueItem = await context.FindAsync <CatalogueItem>(CatalogueItemId.ParseExact(selectedItem.CatalogueItemId))
?? selectedItem.ToDomain();
var catalogueItemPricingUnit = await GetPricingUnitAsync(provisioningType, connectionString);
var pricingUnit = await context.FindAsync <PricingUnit>(catalogueItemPricingUnit.Name) ?? catalogueItemPricingUnit;
var orderItem = new OrderItemBuilder(order.Id)
.WithCatalogueItem(catalogueItem)
.WithCataloguePriceType(cataloguePriceType)
.WithCurrencyCode()
.WithDefaultDeliveryDate(DateTime.Today)
.WithPrice(0.01M)
.WithPricingTimeUnit(timeUnit)
.WithProvisioningType(provisioningType)
.WithPricingUnit(pricingUnit)
.WithEstimationPeriod(timeUnit);
if (provisioningType == ProvisioningType.OnDemand)
{
orderItem.WithEstimationPeriod(timeUnit);
}
return(orderItem.Build());
}
private OrderItemEntityBuilder(
int orderId,
string catalogueItemId,
TimeUnit?estimationPeriod,
ProvisioningType provisioningType,
CataloguePriceType cataloguePriceType,
string currencyCode,
TimeUnit?timeUnit,
string pricingUnitName,
decimal?price,
DateTime created)
{
this.orderId = orderId;
this.catalogueItemId = catalogueItemId;
this.estimationPeriod = estimationPeriod;
this.provisioningType = provisioningType;
this.cataloguePriceType = cataloguePriceType;
this.currencyCode = currencyCode;
this.timeUnit = timeUnit;
this.pricingUnitName = pricingUnitName;
this.price = price;
this.created = created;
}
private OrderItemEntityBuilder(
string orderId,
string odsCode,
string catalogueItemId,
CatalogueItemType catalogueItemType,
string catalogueItemName,
DateTime?deliveryDate,
int quantity,
TimeUnit?estimationPeriod,
ProvisioningType provisioningType,
CataloguePriceType cataloguePriceType,
string currencyCode,
TimeUnit?timeUnit,
string pricingUnitTierName,
string pricingUnitDescription,
decimal?price,
DateTime created,
DateTime lastUpdated)
{
_orderId = orderId;
_odsCode = odsCode;
_catalogueItemId = catalogueItemId;
_catalogueItemType = catalogueItemType;
_catalogueItemName = catalogueItemName;
_deliveryDate = deliveryDate;
_quantity = quantity;
_estimationPeriod = estimationPeriod;
_provisioningType = provisioningType;
_cataloguePriceType = cataloguePriceType;
_currencyCode = currencyCode;
_timeUnit = timeUnit;
_pricingUnitTierName = pricingUnitTierName;
_pricingUnitDescription = pricingUnitDescription;
_price = price;
_created = created;
_lastUpdated = lastUpdated;
}
public OrderItemBuilder WithCataloguePriceType(CataloguePriceType cataloguePriceType)
{
orderItem.CataloguePriceType = cataloguePriceType;
return(this);
}
protected CataloguePriceBase(CataloguePriceType type)
{
CataloguePriceType = type;
}
public CreateCatalogueSolutionOrderItemRequestPayloadBuilder WithCataloguePriceType(CataloguePriceType cataloguePriceType)
{
_cataloguePriceType = cataloguePriceType;
return(this);
}
public void Configure(EntityTypeBuilder <OrderItem> builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.HasKey(orderItem => orderItem.OrderItemId);
builder.Property(orderItem => orderItem.OrderItemId)
.HasColumnName(nameof(OrderItem.OrderItemId))
.IsRequired();
builder.Property("OrderId")
.HasColumnName("OrderId")
.IsRequired();
builder.Property(orderItem => orderItem.CatalogueItemId)
.HasColumnName(nameof(OrderItem.CatalogueItemId))
.IsRequired();
builder
.Property(orderItem => orderItem.CatalogueItemType)
.HasConversion(input => input.Id, output => CatalogueItemType.FromId(output))
.HasColumnName("CatalogueItemTypeId");
builder.Property(orderItem => orderItem.CatalogueItemName)
.HasColumnName(nameof(OrderItem.CatalogueItemName))
.IsRequired();
builder.Property(orderItem => orderItem.OdsCode)
.HasColumnName(nameof(OrderItem.OdsCode));
builder
.Property(orderItem => orderItem.ProvisioningType)
.HasConversion(input => input.Id, output => ProvisioningType.FromId(output))
.HasColumnName("ProvisioningTypeId");
builder
.Property(orderItem => orderItem.CataloguePriceType)
.HasConversion(input => input.Id, output => CataloguePriceType.FromId(output))
.HasColumnName("CataloguePriceTypeId");
builder.OwnsOne(orderItem => orderItem.CataloguePriceUnit, navigationBuilder =>
{
navigationBuilder.Property(cataloguePriceUnit => cataloguePriceUnit.TierName)
.HasColumnName("PricingUnitTierName");
navigationBuilder.Property(cataloguePriceUnit => cataloguePriceUnit.Description)
.HasColumnName("PricingUnitDescription");
});
builder
.Property(orderItem => orderItem.PriceTimeUnit)
.HasConversion(input => input.Id, output => TimeUnit.FromId(output))
.HasColumnName("TimeUnitId");
builder.Property(orderItem => orderItem.CurrencyCode)
.HasColumnName(nameof(OrderItem.CurrencyCode))
.IsRequired();
builder.Property(orderItem => orderItem.Quantity)
.HasColumnName(nameof(OrderItem.Quantity))
.IsRequired();
builder
.Property(orderItem => orderItem.EstimationPeriod)
.HasConversion(input => input.Id, output => TimeUnit.FromId(output))
.HasColumnName("EstimationPeriodId");
builder.Property(orderItem => orderItem.DeliveryDate)
.HasColumnName(nameof(OrderItem.DeliveryDate));
builder.Property(orderItem => orderItem.Price)
.HasColumnName(nameof(OrderItem.Price))
.HasColumnType("decimal(18, 3)");
}
public static void ParseIgnoreCase_ReturnsExpectedEnumValue(string value, CataloguePriceType expected)
{
var actual = OrderingEnums.ParseStrictIgnoreCase <CataloguePriceType>(value);
actual.Should().Be(expected);
}
public void FromId_CataloguePriceTypeId_ReturnsExpectedType()
{
var actual = CataloguePriceType.FromId(1);
actual.Should().Be(CataloguePriceType.Flat);
}
public OrderItemEntityBuilder WithCataloguePriceType(CataloguePriceType cataloguePriceType)
{
_cataloguePriceType = cataloguePriceType;
return(this);
}
static void Test()
{
CataloguePriceType.FromName(null);
}
public void FromName_UnknownCataloguePriceTypeId_ReturnsNull()
{
var actual = CataloguePriceType.FromName("Unknown");
actual.Should().BeNull();
}
public void FromName_CataloguePriceTypeId_ReturnsExpectedType(string cataloguePriceTypeName)
{
var actual = CataloguePriceType.FromName(cataloguePriceTypeName);
actual.Should().Be(CataloguePriceType.Tiered);
}
