public void CallAllRules()
{
Rule1 rule1 = new Rule1();
Rule2 rule2 = new Rule2();
Rule3 rule3 = new Rule3();
Rule4 rule4 = new Rule4();
Rule5 rule5 = new Rule5();
Rule6 rule6 = new Rule6();
Rule7 rule7 = new Rule7();
Rule8 rule8 = new Rule8();
Rule9 rule9 = new Rule9();
Rule10 rule10 = new Rule10();
Rule11 rule11 = new Rule11();
Rule12 rule12 = new Rule12();
Rule13 rule13 = new Rule13();
ReadExcelData readData = new ReadExcelData();
readData.ReadFromExcelFile("");
//calls all rules
int total;
foreach (var row in Records.records)
{
total = 0;
total += rule1.Evaluate(row).Score;
total += rule2.Evaluate(row).Score;
total += rule3.Evaluate(row).Score;
total += rule4.Evaluate(row).Score;
total += rule5.Evaluate(row).Score;
total += rule6.Evaluate(row).Score;
total += rule7.Evaluate(row).Score;
total += rule8.Evaluate(row).Score;
total += rule9.Evaluate(row).Score;
total += rule10.Evaluate(row).Score;
total += rule11.Evaluate(row).Score;
total += rule12.Evaluate(row).Score;
total += rule13.Evaluate(row).Score;
/* call all rules here */
Console.WriteLine("Total score: " + total);
}
}
public void RuleTest()
{
using (var scope = new TransactionScope())
{
using (var con = new SqlConnection(ConfigurationManager.ConnectionStrings["PMSDBConnection"].ConnectionString))
{
var uows = new MITD.Domain.Repository.UnitOfWorkScope(
new Data.NH.NHUnitOfWorkFactory(() => PMSAdmin.Persistence.NH.PMSAdminSession.GetSession(con)));
using (var uow = new NHUnitOfWork(PMSSession.GetSession(con)))
using (var uow2 = uows.CurrentUnitOfWork)
{
con.Open();
var pmsAdminService = new PMS.ACL.PMSAdmin.PMSAdminService(
new PMSAdmin.Application.UnitService(new PMSAdmin.Persistence.NH.UnitRepository(uows),
new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
new PMSAdmin.Application.JobService(new PMSAdmin.Persistence.NH.JobRepository(uows),
new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
new PMSAdmin.Application.CustomFieldService(new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
new PMSAdmin.Application.JobPositionService(new PMSAdmin.Persistence.NH.JobPositionRepository(uows)),
new PMSAdmin.Application.JobIndexService(new PMSAdmin.Persistence.NH.JobIndexRepository(uows),
new PMSAdmin.Persistence.NH.CustomFieldRepository(uows)),
new PMSAdmin.Application.UnitIndexService(new PMSAdmin.Persistence.NH.UnitIndexRepository(uows),
new PMSAdmin.Persistence.NH.CustomFieldRepository(uows))
);
EventPublisher publisher = new EventPublisher();
var rep = new PMS.Persistence.NH.EmployeeRepository(uow);
var periodRep = new PMS.Persistence.NH.PeriodRepository(uow);
var calcRep = new PMS.Persistence.NH.CalculationRepository(uow);
var policyRep = new MITD.PMS.Persistence.NH.PolicyRepository(uow, new PolicyConfigurator(
new RuleBasedPolicyEngineService(new LocatorProvider("PMSDbConnection"), publisher)));
var provider = new PMS.Application.CalculationDataProvider(rep, pmsAdminService,
new PMS.Persistence.NH.JobIndexPointRepository(uow));
var policy = policyRep.GetById(new PolicyId(1));
var period = periodRep.GetBy(c => c.Active);
var emp = rep.GetBy(new EmployeeId("150554", period.Id));
// if period has no calculation
var calculation = new Calculation(calcRep.GetNextId(), period, policy, Guid.NewGuid().ToString(), DateTime.Now, "150554");
calcRep.Add(calculation);
uow.Commit();
// if period has calculation , get it by its identifier
//var calculation = calcRep.GetById(new CalculationId(1));
MITD.PMSReport.Domain.Model.CalculationData empData;
var pathNo = 1;
List <SummaryCalculationPoint> calcList = new List <SummaryCalculationPoint>();
var session = new CalculatorSession();
while (pathNo <= 2)
{
Utils.Res = new MITD.PMS.RuleContracts.RuleResult();
session.AddCalculationPoints(calcList);
session.PathNo = pathNo;
var data = provider.Provide(emp, out empData, calculation, true, session);
var rule1 = new Rule10();
rule1.Execute(data);
var rule2 = new Rule11();
rule2.Execute(data);
var rule3 = new Rule12();
rule3.Execute(data);
//var rule4 = new Rule13();
//rule4.Execute(data);
var res = provider.Convert(Utils.Res, empData, emp, period, calculation);
calcList = res.CalculationPoints.OfType <SummaryCalculationPoint>().ToList();
var jipRep = new JobIndexPointRepository(uow);
if (res.EmployeePointsForAdd != null)
{
foreach (var point in res.EmployeePointsForAdd)
{
jipRep.Add(point);
}
}
if (res.EmployeePointsForUpdate != null)
{
foreach (var point in res.EmployeePointsForUpdate)
{
var employeePoint = jipRep.GetById(point.Key);
employeePoint.SetValue(point.Value);
}
}
uow.Commit();
pathNo++;
}
}
}
}
}
protected void RunScenario(string title, string input)
{
RunScenario(title, () =>
{
var lines = input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
var reSimpleRule = new Regex(@"^(\d+): ""(.*)""$");
var reSingleRule = new Regex(@"^(\d+): (\d+)$");
var rePairRule = new Regex(@"^(\d+): (\d+) (\d+)$");
var reTripleRule = new Regex(@"^(\d+): (\d+) (\d+) (\d+)$");
var reOrPairRule = new Regex(@"^(\d+): (\d+) (\d+) \| (\d+) (\d+)$");
var reOrSingleRule = new Regex(@"^(\d+): (\d+) \| (\d+)$");
var reOrSingleLeftRule = new Regex(@"^(\d+): (\d+) \| (\d+) (\d+)$");
var reOrSingleRightRule = new Regex(@"^(\d+): (\d+) (\d+) \| (\d+)$");
var rules = new Dictionary <string, Rule>();
var matchingRules = true;
var toCheck = new List <string>();
foreach (var line in lines)
{
if (line.Trim() == "X")
{
matchingRules = false;
continue;
}
if (matchingRules)
{
var simple = reSimpleRule.Match(line);
if (simple.Success)
{
rules.Add(simple.Groups[1].Value, new SimpleRule(rules, simple.Groups[2].Value));
}
else
{
var pair = rePairRule.Match(line);
if (pair.Success)
{
rules.Add(pair.Groups[1].Value, new PairRule(rules, pair.Groups[2].Value, pair.Groups[3].Value));
}
else
{
var orPair = reOrPairRule.Match(line);
if (orPair.Success)
{
rules.Add(orPair.Groups[1].Value, new OrPairRule(rules, orPair.Groups[2].Value, orPair.Groups[3].Value, orPair.Groups[4].Value, orPair.Groups[5].Value));
}
else
{
var orSinglePair = reOrSingleRule.Match(line);
if (orSinglePair.Success)
{
rules.Add(orSinglePair.Groups[1].Value, new OrSingleRule(rules, orSinglePair.Groups[2].Value, orSinglePair.Groups[3].Value));
}
else
{
var orSingleLeft = reOrSingleLeftRule.Match(line);
if (orSingleLeft.Success)
{
rules.Add(orSingleLeft.Groups[1].Value, new OrSingleLeftRule(rules, orSingleLeft.Groups[2].Value, orSingleLeft.Groups[3].Value, orSingleLeft.Groups[4].Value));
}
else
{
var orSingleRight = reOrSingleRightRule.Match(line);
if (orSingleRight.Success)
{
rules.Add(orSingleRight.Groups[1].Value, new OrSingleRightRule(rules, orSingleRight.Groups[2].Value, orSingleRight.Groups[3].Value, orSingleRight.Groups[4].Value));
}
else
{
var orSingle = reSingleRule.Match(line);
if (orSingle.Success)
{
rules.Add(orSingle.Groups[1].Value, new SingleRule(rules, orSingle.Groups[2].Value));
}
else
{
var triple = reTripleRule.Match(line);
if (triple.Success)
{
rules.Add(triple.Groups[1].Value, new TripleRule(rules, triple.Groups[2].Value, triple.Groups[3].Value, triple.Groups[4].Value));
}
else
{
throw new FormatException(line);
}
}
}
}
}
}
}
}
}
else
{
toCheck.Add(line);
}
}
//Console.WriteLine($"42: {BuildPattern(rules["42"])}");
//Console.WriteLine($"31: {BuildPattern(rules["31"])}");
rules["8"] = new Rule8(rules);
var lastCount = 0;
for (var i = 1; ; i += 1)
{
rules["11"] = new Rule11(rules, i);
var pattern = BuildPattern(rules["0"]);
//Console.WriteLine(pattern.ToString());
var count = toCheck.Count(i => pattern.IsMatch(i));
Console.WriteLine($"With {i} iterations, got: {count}");
if (count == lastCount)
{
break;
}
lastCount = count;
}
// 323 is wrong
////var keys = rules.Keys.Select(i => int.Parse(i)).OrderBy(i => i).ToList();
//var pattern = BuildPattern(rules["0"]);
//Console.WriteLine(pattern.ToString());
//var count = toCheck.Count(i => pattern.IsMatch(i));
//Console.WriteLine(count);
});
}
