/// <summary>
/// Retrieves eligibility parameters, transforms them into eligibilities, groups into rule sets and builds a Composite structure.
/// </summary>
/// <param name="productId">Build an eligibility structure belonging to the specified product.</param>
/// <returns>Product's Composite eligibility structure.</returns>
public IEligibility Create(int productId)
{
IQueryable <ProductEligibilityParam> eligibilityParameters = _prodEligRepository.GetProductEligibilityParams(productId);
IList <IEligibility> eligibilities = _eligibilityMapper.MapParamsToEligibility(eligibilityParameters.ToList <ProductEligibilityParam>());
IList <IEligibility> rawRuleSetEligibilities = new List <IEligibility>();
IEligibility compositeEligibilities = null;
IEligibility ruleSetEligibility = null;
int ruleSetCount = eligibilities.Any() ? eligibilities.Max(e => e.RuleSet) : 0; // .Max() throws if collection is empty.
for (int i = 1; i <= ruleSetCount; i++)
{
// Rule set 1 is handled differently from the subsequent rule sets.
if (i == 1)
{
ruleSetEligibility = CreateRuleSet <RuleSet1Eligibility>(eligibilities.Where(e => e.RuleSet == i));
rawRuleSetEligibilities.Add(ruleSetEligibility);
}
else
{
ruleSetEligibility = CreateRuleSet <RuleSetOtherEligibility>(eligibilities.Where(e => e.RuleSet == i));
rawRuleSetEligibilities.Add(ruleSetEligibility);
}
ruleSetEligibility.RuleSet = i;
}
// Process the list of IEligibles into a Composite structure, based on rulesets.
compositeEligibilities = CreateComposite(rawRuleSetEligibilities);
return(compositeEligibilities);
}
/// <summary>
/// Takes basic list of eligibility parameters and transforms it into a list of eligibilities.
/// Multiple eligibility parameters might be necessary to create a single eligibility.
/// </summary>
/// <param name="eligParams">A list with a basic representation of eligibility parameters.</param>
/// <returns>A list of eligibilities, with no particular structure.</returns>
public IList <IEligibility> MapParamsToEligibility(IList <ProductEligibilityParam> eligParams)
{
string eligibilityName = String.Empty;
int ruleSet = 0;
Type type;
IEligibility eligible = null;
List <IEligibility> eligList = new List <IEligibility>();
foreach (ProductEligibilityParam param in eligParams.OrderBy(p => p.RuleSet).ThenBy(p => p.EligibilityName))
{
// Multiple parameters might belong to the same eligibility.
if (eligibilityName != param.EligibilityName || ruleSet != param.RuleSet)
{
type = typeof(IEligibility).Assembly.GetTypes().Single(t => t.Name == param.EligibilityName);
eligible = (IEligibility)Activator.CreateInstance(type);
eligible.GetType().GetProperty("RuleSet").SetValue(eligible, param.RuleSet);
eligibilityName = param.EligibilityName;
ruleSet = param.RuleSet;
eligList.Add(eligible);
}
// Set eligibilities property values.
eligible.GetType().GetProperty(param.ParamName).SetValue(eligible, param.ParamValue);
}
return(eligList);
}
public void Return_Null_Object_If_No_Eligibilities()
{
// Arrange
_targetBuilder.WithNoEligibility();
CompositeEligibilityFactory target = _targetBuilder.Build();
// Act
IEligibility result = target.Create(1);
IEligibility nullResult = result as NullEligibility;
// Assert
Assert.IsInstanceOfType(nullResult, typeof(NullEligibility));
_targetBuilder._mockMapper.Verify(m => m.MapParamsToEligibility(It.IsAny <IList <ProductEligibilityParam> >()), Times.Once);
}
/// <summary>
/// Goes through provided flat rule set structure and builds a hierarchical composite structure.
/// </summary>
/// <param name="rawEligibilities">A flat list of rule set eligibilities.</param>
/// <returns>A hierarchical composite structure of rule set eligibilities</returns>
private IEligibility CreateComposite(IList <IEligibility> rawEligibilities)
{
IEligibility compositeEligibilities = null;
if (rawEligibilities.Count == 0)
{
return(new NullEligibility());
}
// Rule set 1 becomes the composite root by default.
compositeEligibilities = rawEligibilities[0];
// Skip the last eligibility as it doesn't contain any new Composites.
for (int i = 1; i < rawEligibilities.Count; i++)
{
compositeEligibilities.AddComponent(rawEligibilities[i]);
compositeEligibilities = rawEligibilities[i];
}
// Return composite root.
return(rawEligibilities[0]);
}
public void AddComponent(IEligibility eligibility)
{
throw new NotImplementedException();
}
public void AddComponent(IEligibility eligibility)
{
Components.Add(eligibility);
}
public void Can_Create_A_Composite_With_Multiple_Rule_Set_With_Multiple_Eligibility()
{
// Arrange
_targetBuilder.WithMultipleRuleSetWithMultipleEligibility(1);
CompositeEligibilityFactory target = _targetBuilder.Build();
// Act
IEligibility result = target.Create(1);
// Retrieve first rule set.
RuleSet1Eligibility ruleSetOne = result as RuleSet1Eligibility;
FormSubtypeEligibility formSubtype1 = ruleSetOne.Components[0] as FormSubtypeEligibility;
SubscriberTypeEligibility subscriberType1 = ruleSetOne.Components[1] as SubscriberTypeEligibility;
TariffsEligibility tariffs1 = ruleSetOne.Components[2] as TariffsEligibility;
// Retrieve second rule set.
RuleSetOtherEligibility ruleSetTwo = ruleSetOne.Components[3] as RuleSetOtherEligibility;
FormSubtypeEligibility formSubtype2 = ruleSetTwo.Components[0] as FormSubtypeEligibility;
SubscriberTypeEligibility subscriberType2 = ruleSetTwo.Components[1] as SubscriberTypeEligibility;
// Retrieve third rule set.
RuleSetOtherEligibility ruleSetThree = ruleSetTwo.Components[2] as RuleSetOtherEligibility;
SubscriberTypeEligibility subscriberType3 = ruleSetThree.Components[0] as SubscriberTypeEligibility;
TariffsEligibility tariffs2 = ruleSetThree.Components[1] as TariffsEligibility;
// Retrieve fourth rule set.
RuleSetOtherEligibility ruleSetFour = ruleSetThree.Components[2] as RuleSetOtherEligibility;
SubscriberTypeEligibility subscriberType4 = ruleSetFour.Components[0] as SubscriberTypeEligibility;
TariffsEligibility tariffs3 = ruleSetFour.Components[1] as TariffsEligibility;
// Assert - RuleSet1Eligibility representing Rule set 1
Assert.IsNotNull(ruleSetOne);
Assert.IsTrue(ruleSetOne.RuleSet == 1);
Assert.IsTrue(ruleSetOne.Components.Count == 4);
// Assert - FormSubtypeEligibility in Rule set 1
Assert.IsNotNull(formSubtype1);
Assert.IsTrue(formSubtype1.RuleSet == 1);
Assert.IsTrue(formSubtype1.ValidSubtypes == "1,5,7");
// Assert - SubscriberTypeEligibility in Rule set 1
Assert.IsNotNull(subscriberType1);
Assert.IsTrue(subscriberType1.RuleSet == 1);
Assert.IsTrue(subscriberType1.SubscriberType == "1,2,3");
// Assert - TariffsEligibility in Rule set 1
Assert.IsNotNull(tariffs1);
Assert.IsTrue(tariffs1.RuleSet == 1);
Assert.IsTrue(tariffs1.AllowedTariffs == "14,27,61");
// Assert - RuleSetOtherEligibility representing Rule set 2
Assert.IsNotNull(ruleSetTwo);
Assert.IsTrue(ruleSetTwo.RuleSet == 2);
// Assert - FormSubtypeEligibility in Rule set 2
Assert.IsNotNull(formSubtype2);
Assert.IsTrue(formSubtype2.RuleSet == 2);
Assert.IsTrue(formSubtype2.ValidSubtypes == "1");
// Assert - SubscriberTypeEligibility in Rule set 2
Assert.IsNotNull(subscriberType2);
Assert.IsTrue(subscriberType2.RuleSet == 2);
Assert.IsTrue(subscriberType2.SubscriberType == "2");
// Assert - RuleSetOtherEligibility representing Rule set 3
Assert.IsNotNull(ruleSetThree);
Assert.IsTrue(ruleSetThree.RuleSet == 3);
// Assert - SubscriberTypeEligibility in Rule set 3
Assert.IsNotNull(subscriberType3);
Assert.IsTrue(subscriberType3.RuleSet == 3);
Assert.IsTrue(subscriberType3.SubscriberType == "3");
// Assert - TariffsEligibility in Rule set 3
Assert.IsNotNull(tariffs2);
Assert.IsTrue(tariffs2.RuleSet == 3);
Assert.IsTrue(tariffs2.AllowedTariffs == "61");
// Assert - RuleSetOtherEligibility representing Rule set 4
Assert.IsNotNull(ruleSetFour);
Assert.IsTrue(ruleSetFour.RuleSet == 4);
// Assert - SubscriberTypeEligibility in Rule set 4
Assert.IsNotNull(subscriberType4);
Assert.IsTrue(subscriberType4.RuleSet == 4);
Assert.IsTrue(subscriberType4.SubscriberType == "1");
// Assert - TariffsEligibility in Rule set 4
Assert.IsNotNull(tariffs3);
Assert.IsTrue(tariffs3.RuleSet == 4);
Assert.IsTrue(tariffs3.AllowedTariffs == "14");
}
