I am writing a rules/eligibility Module. I have 2 sets of data, one is the customer data and the other is the customer products data. Customer data to Customer products data is one to many.
Now I have to go through a set of Eligibility rules for each of this Customer product data. For each customer products data, I can say the customer is eligible for that product or decline the eligibility and should move on to the next product record.
So in all the rules, I need to have access to customer and customer product data(the particular record that the rules are being executed against). Since all the rules can either approve a product or decline a product, I created an interface with those 2 methods and is implementing the this interface for all the rules. I am passing the Customer data and one product data for all the rules (because rules should be executed on each row of customer product data). An Ideal situation would be having the customer and customer product data available for the rule instead of passing them to each rule.
What is the best way of doing this in-terms of architecture?
Edit: Here is what I am doing
public class CustomerContract
{
public DateTime StartDate { get; set; }
public DateTime endDate { get; set; }
//Other Contract related details
}
public class Customer
{
public int ID { get; set; }
public string Name { get; set; }
public string state { get; set; }
}
public class CustomerInfo
{
public CustomerInfo(int CustomerID)
{
Customer = new Customer();// Get Customer from DB
AppliedProducts = new List<CustomerProduct>();// Get the customer products by customerID
CurrentContract = new CustomerContract();//Get the contract by CustomerID, State
declineReasons = new List<int>();// just intailizing. the decline codes are added by rules.
}
public CustomerContract CurrentContract { get; set; }
public IList<CustomerProduct> AppliedProducts { get; set; }
public IList<int> declineReasons { get; set; }
public Customer Customer { get; set; }
}
public class CustomerProduct
{
public decimal AmountCharged { get; set; }
public int DeclineReasonID { get; set; }
public int Product { get; set; }
public decimal DiscountApplicable { get; set; }
public decimal AmountQuoted { get; set; }
public decimal Tax { get; set; }
}
public interface IRule
{
// Since we need to have access to contracts when deciding the eligibility
CustomerProduct ExecuteRule(CustomerProduct currentproduct, CustomerInfo customerInfo);
//when denied,
CustomerProduct DenyProduct(CustomerProduct currentProduct);
}
public class EligibityEngine
{
List<IRule> rules = new List<IRule>();
private CustomerInfo c;
public EligibityEngine(int CustomerID)
{
c = new CustomerInfo(CustomerID);
LoadRules();
foreach (var customerProduct in c.AppliedProducts)
{
ExecuteRules(customerProduct);
}
}
private void ExecuteRules(CustomerProduct currentProductItem)
{
foreach (var rule in rules)
{
currentProductItem = rule.ExecuteRule(currentProductItem, c);
}
}
private void LoadRules()
{
// add all the IRule types here
//rules.Add();
}
}
When I execute the rule, I have pass the customer Product data and customer data. I have to pass the result of one rule execution to the other. In the above pattern, if the rule changes data in customerInfo class, it is not save unless it is passes as ref.
My question is I want the all rules to have access to this data with out passing them in. So I need not worry about capturing the out put of the rule.
I want the executeRule method to void.
