public Node GetIterateNextQuestion(NodeSet parentNodeSet, AssessmentState parentAst)
{
if (this.iterateNodeSet == null && this.givenListSize != 0)
{
this.iterateNodeSet = CreateIterateNodeSet(parentNodeSet);
this.iterateIE = new InferenceEngine(this.iterateNodeSet);
if (this.iterateIE.GetAssessment() == null)
{
this.iterateIE.SetAssessment(new Assessment(this.iterateNodeSet, this.GetNodeName()));
}
}
Node firstIterateQuestionNode = parentNodeSet.GetNodeByNodeId(parentNodeSet.GetDependencyMatrix().GetToChildDependencyList(this.GetNodeId()).Min());
Node questionNode = null;
if (!parentAst.GetWorkingMemory().ContainsKey(FactValue.GetValueInString(this.value.GetFactValueType(), this.value))) // a list is not given yet so that the engine needs to find out more info.
{
if (!parentAst.GetWorkingMemory().ContainsKey(firstIterateQuestionNode.GetNodeName()))
{
questionNode = firstIterateQuestionNode;
}
else
{
if (!CanBeSelfEvaluated(parentAst.GetWorkingMemory()))
{
questionNode = this.iterateIE.GetNextQuestion(this.iterateIE.GetAssessment());
}
}
}
return(questionNode);
}
public int NumberOfTrueChildren(Dictionary <string, FactValue> workingMemory)
{
return(this.iterateIE.GetNodeSet().GetDependencyMatrix().GetToChildDependencyList(this.nodeId)
.Where((i) => i != this.nodeId + 1)
.Where((id) => FactValue.GetValueInString(workingMemory[this.iterateIE.GetNodeSet().GetNodeIdMap()[id]].GetFactValueType(), workingMemory[this.iterateIE.GetNodeSet().GetNodeIdMap()[id]]).ToLower().Equals("true"))
.ToList().Count);
}
public override FactValue SelfEvaluate(Dictionary <string, FactValue> workingMemory, Jint.Engine nashorn)
{
FactValue fv = null;
/*
* Negation and Known type are a part of dependency
* hence, only checking its variableName value against the workingMemory is necessary.
* type is as follows;
* 1. the rule is a plain statement
* 2. the rule is a statement of 'A IS B'
* 3. the rule is a statement of 'A IS IN LIST: B'
* 4. the rule is a statement of 'needs(wants) A'. this is from a child node of ExprConclusionLine type
*/
if (!this.isPlainStatementFormat)
{
if (tokens.tokensList.Any(s => s.Equals("IS")))
{
fv = this.value;
}
else if (tokens.tokensList.Any((s) => s.Equals("IS IN LIST:")))
{
bool lineValue = false;
string listName = FactValue.GetValueInString(this.GetFactValue().GetFactValueType(), this.GetFactValue());
if (workingMemory[listName] != null)
{
FactValue variableValueFromWorkingMemory = workingMemory[this.variableName];
lineValue = variableValueFromWorkingMemory != null ?
((FactListValue)workingMemory[listName]).GetValue().Any((item) => (item as FactStringValue).GetValue().Equals(FactValue.GetValueInString(variableValueFromWorkingMemory.GetFactValueType(), variableValueFromWorkingMemory)))
:
((FactListValue)workingMemory[listName]).GetValue().Any((item) => (item as FactStringValue).GetValue().Equals(this.variableName));
}
fv = FactValue.Parse(lineValue);
}
}
return(fv);
}
///*
// * this method is used when a givenList does NOT exist
// */
public void IterateFeedAnswers(Node targetNode, string questionName, FactValue nodeValue, NodeSet parentNodeSet, AssessmentState parentAst, Assessment ass)
{
if (this.iterateNodeSet == null)
{
Node firstIterateQuestionNode = parentNodeSet.GetNodeByNodeId(parentNodeSet.GetDependencyMatrix().GetToChildDependencyList(this.GetNodeId()).Min());
if (questionName.Equals(firstIterateQuestionNode.GetNodeName()))
{
this.givenListSize = Int32.Parse(FactValue.GetValueInString(nodeValue.GetFactValueType(), nodeValue));
}
this.iterateNodeSet = CreateIterateNodeSet(parentNodeSet);
this.iterateIE = new InferenceEngine(this.iterateNodeSet);
if (this.iterateIE.GetAssessment() == null)
{
this.iterateIE.SetAssessment(new Assessment(this.iterateNodeSet, this.GetNodeName()));
}
}
this.iterateIE.GetAssessment().SetNodeToBeAsked(targetNode);
this.iterateIE.FeedAnswerToNode(targetNode, questionName, nodeValue, this.iterateIE.GetAssessment());
Dictionary <string, FactValue> iterateWorkingMemory = this.iterateIE.GetAssessmentState().GetWorkingMemory();
Dictionary <string, FactValue> parentWorkingMemory = parentAst.GetWorkingMemory();
TranseferFactValue(iterateWorkingMemory, parentWorkingMemory);
}
public bool CanBeSelfEvaluated(Dictionary <string, FactValue> workingMemory)
{
bool canBeSelfEvaluated = false;
if (this.iterateIE != null)
{
FactValue outFactValue = null;
List <int> numberOfDeterminedSecondLevelNode = this.iterateIE.GetNodeSet().GetDependencyMatrix().GetToChildDependencyList(this.nodeId)
.Where((i) => i != this.nodeId + 1)
.Where((id) => workingMemory.TryGetValue(this.iterateIE.GetNodeSet().GetNodeIdMap()[id], out outFactValue) && outFactValue != null && FactValue.GetValueInString(outFactValue.GetFactValueType(), outFactValue) != null)
.ToList();
if (this.givenListSize == numberOfDeterminedSecondLevelNode.Count && this.iterateIE.HasAllMandatoryChildAnswered(this.nodeId))
{
canBeSelfEvaluated = true;
}
}
return(canBeSelfEvaluated);
}
public NodeSet CreateIterateNodeSet(NodeSet parentNodeSet)
{
DependencyMatrix parentDM = parentNodeSet.GetDependencyMatrix();
Dictionary <string, Node> parentNodeMap = parentNodeSet.GetNodeMap();
Dictionary <int?, string> parentNodeIdMap = parentNodeSet.GetNodeIdMap();
Dictionary <string, Node> thisNodeMap = new Dictionary <string, Node>();
Dictionary <int?, string> thisNodeIdMap = new Dictionary <int?, string>();
List <Dependency> tempDependencyList = new List <Dependency>();
NodeSet newNodeSet = new NodeSet();
thisNodeMap.Add(this.nodeName, this);
thisNodeIdMap.Add(this.nodeId, this.nodeName);
Enumerable.Range(1, this.givenListSize).ToList().ForEach((nth) =>
{
parentDM.GetToChildDependencyList(this.nodeId).ForEach((item) =>
{
if (this.GetNodeId() + 1 != item) // not first question id
{
Node tempChildNode = parentNodeMap[parentNodeIdMap[item]];
LineType lineType = tempChildNode.GetLineType();
Node tempNode = null;
string nextNThInString = Oridinal(nth);
if (lineType.Equals(LineType.VALUE_CONCLUSION))
{
tempNode = new ValueConclusionLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
}
else if (lineType.Equals(LineType.COMPARISON))
{
tempNode = new ComparisonLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
FactValue tempNodeFv = ((ComparisonLine)tempNode).GetRHS();
if (tempNodeFv.GetFactValueType().Equals(FactValueType.STRING))
{
FactValue tempFv = FactValue.Parse(nextNThInString + " " + this.GetVariableName() + " " + FactValue.GetValueInString(FactValueType.STRING, tempNodeFv));
tempNode.SetValue(tempFv);
}
}
else if (lineType.Equals(LineType.EXPR_CONCLUSION))
{
tempNode = new ExprConclusionLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
}
thisNodeMap.Add(tempNode.GetNodeName(), tempNode);
thisNodeIdMap.Add(tempNode.GetNodeId(), tempNode.GetNodeName());
tempDependencyList.Add(new Dependency(this, tempNode, parentDM.GetDependencyType(this.nodeId, item)));
CreateIterateNodeSetAux(parentDM, parentNodeMap, parentNodeIdMap, thisNodeMap, thisNodeIdMap, tempDependencyList, item, tempNode.GetNodeId(), nextNThInString);
}
else // first question id
{
Node firstIterateQuestionNode = parentNodeSet.GetNodeByNodeId(parentNodeSet.GetDependencyMatrix().GetToChildDependencyList(this.GetNodeId()).Min());
if (!thisNodeMap.ContainsKey(firstIterateQuestionNode.GetNodeName()))
{
thisNodeMap.Add(firstIterateQuestionNode.GetNodeName(), firstIterateQuestionNode);
thisNodeIdMap.Add(item, firstIterateQuestionNode.GetNodeName());
tempDependencyList.Add(new Dependency(this, firstIterateQuestionNode, parentDM.GetDependencyType(this.nodeId, item)));
}
}
});
});
int numberOfRules = Node.GetStaticNodeId();
int[,] dependencyMatrix = new int[numberOfRules, numberOfRules];
tempDependencyList.ForEach(dp => {
int parentId = dp.GetParentNode().GetNodeId();
int childId = dp.GetChildNode().GetNodeId();
int dpType = dp.GetDependencyType();
dependencyMatrix[parentId, childId] = dpType;
});
newNodeSet.SetNodeIdMap(thisNodeIdMap);
newNodeSet.SetNodeMap(thisNodeMap);
newNodeSet.SetDependencyMatrix(new DependencyMatrix(dependencyMatrix));
newNodeSet.SetFactMap(parentNodeSet.GetFactMap());
newNodeSet.SetNodeSortedList(TopoSort.DfsTopoSort(thisNodeMap, thisNodeIdMap, dependencyMatrix));
// newNodeSet.getNodeSortedList().stream().forEachOrdered(item->System.out.println(item.getNodeId()+"="+item.getNodeName()));
return(newNodeSet);
}
public void CreateIterateNodeSetAux(DependencyMatrix parentDM, Dictionary <string, Node> parentNodeMap, Dictionary <int?, string> parentNodeIdMap, Dictionary <string, Node> thisNodeMap, Dictionary <int?, string> thisNodeIdMap, List <Dependency> tempDependencyList, int originalParentId, int modifiedParentId, string nextNThInString)
{
List <int> childDependencyList = parentDM.GetToChildDependencyList(originalParentId);
if (childDependencyList.Count > 0)
{
childDependencyList.ForEach((item) => {
Node tempChildNode = parentNodeMap[parentNodeIdMap[item]];
LineType lt = tempChildNode.GetLineType();
Node tempNode;
thisNodeMap.TryGetValue(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), out tempNode);
if (tempNode == null)
{
if (lt.Equals(LineType.VALUE_CONCLUSION))
{
tempNode = new ValueConclusionLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
if (parentNodeMap[parentNodeIdMap[originalParentId]].GetLineType().Equals(LineType.EXPR_CONCLUSION))
{
ExprConclusionLine exprTempNode = thisNodeMap[thisNodeIdMap[modifiedParentId]] as ExprConclusionLine;
string replacedString = FactValue.GetValueInString(exprTempNode.GetEquation().GetFactValueType(), exprTempNode.GetEquation()).Replace(tempChildNode.GetNodeName(), nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName());
exprTempNode.SetValue(FactValue.Parse(replacedString));
exprTempNode.SetEquation(FactValue.Parse(replacedString));
}
}
else if (lt.Equals(LineType.COMPARISON))
{
tempNode = new ComparisonLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
FactValue tempNodeFv = ((ComparisonLine)tempNode).GetRHS();
if (tempNodeFv.GetFactValueType().Equals(FactValueType.STRING))
{
FactValue tempFv = FactValue.Parse(nextNThInString + " " + this.GetVariableName() + " " + tempNodeFv);
tempNode.SetValue(tempFv);
}
}
else if (lt.Equals(LineType.EXPR_CONCLUSION))
{
tempNode = new ExprConclusionLine(nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName(), tempChildNode.GetTokens());
}
}
else
{
if (lt.Equals(LineType.VALUE_CONCLUSION) && parentNodeMap[parentNodeIdMap[originalParentId]].GetLineType().Equals(LineType.EXPR_CONCLUSION))
{
ExprConclusionLine exprTempNode = ((ExprConclusionLine)thisNodeMap[thisNodeIdMap[modifiedParentId]]);
string replacedString = FactValue.GetValueInString(exprTempNode.GetEquation().GetFactValueType(), exprTempNode.GetEquation()).Replace(tempChildNode.GetNodeName(), nextNThInString + " " + this.GetVariableName() + " " + tempChildNode.GetNodeName());
exprTempNode.SetValue(FactValue.Parse(replacedString));
exprTempNode.SetEquation(FactValue.Parse(replacedString));
}
}
if (!thisNodeMap.ContainsKey(tempNode.GetNodeName()))
{
thisNodeMap.Add(tempNode.GetNodeName(), tempNode);
thisNodeIdMap.Add(tempNode.GetNodeId(), tempNode.GetNodeName());
tempDependencyList.Add(new Dependency(thisNodeMap[thisNodeIdMap[modifiedParentId]], tempNode, parentDM.GetDependencyType(originalParentId, item)));
CreateIterateNodeSetAux(parentDM, parentNodeMap, parentNodeIdMap, thisNodeMap, thisNodeIdMap, tempDependencyList, item, tempNode.GetNodeId(), nextNThInString);
}
});
}
}
public override FactValue SelfEvaluate(Dictionary <string, FactValue> workingMemory, Jint.Engine jint)
{
/*
* Negation type can only be used for this line type
*
*/
FactValue workingMemoryLhsValue = workingMemory.ContainsKey(this.variableName) ? workingMemory[this.variableName] : null;
string rhsValueInString = FactValue.GetValueInString(this.GetRHS().GetFactValueType(), this.GetRHS());
FactValue workingMemoryRhsValue = this.GetRHS().GetFactValueType().Equals(FactValueType.STRING) ?
workingMemory[rhsValueInString]
:
this.GetRHS();
String script = "";
/*
* There will NOT be the case of that workingMemoryRhsValue is null because the node must be in following format;
* - A = 12231 (int or double)
* - A = Adam sandler (String)
* - A = 11/11/1977 (Date)
* - A = 123123dfae1421412aer(Hash)
* - A = 1241414-12421312-142421312(UUID)
* - A = true(Boolean)
* - A = www.aiBrain.com(URL)
* - A = B(another variable)
*/
/*
* if it is about date comparison then string of 'script' needs rewriting
*/
if ((workingMemoryLhsValue != null && workingMemoryLhsValue.GetFactValueType().Equals(FactValueType.DATE)) || (workingMemoryRhsValue != null && workingMemoryRhsValue.GetFactValueType().Equals(FactValueType.DATE)))
{
Boolean returnValue;
switch (this.operatorString)
{
case ">":
returnValue = (((FactDateValue)workingMemoryLhsValue).GetValue()).CompareTo((((FactDateValue)workingMemoryRhsValue).GetValue())) > 0 ? true : false;
return(FactValue.Parse(returnValue));
case ">=":
returnValue = (((FactDateValue)workingMemoryLhsValue).GetValue()).CompareTo((((FactDateValue)workingMemoryRhsValue).GetValue())) >= 0 ? true : false;
return(FactValue.Parse(returnValue));
case "<":
returnValue = (((FactDateValue)workingMemoryLhsValue).GetValue()).CompareTo((((FactDateValue)workingMemoryRhsValue).GetValue())) < 0 ? true : false;
return(FactValue.Parse(returnValue));
case "<=":
returnValue = (((FactDateValue)workingMemoryLhsValue).GetValue()).CompareTo((((FactDateValue)workingMemoryRhsValue).GetValue())) <= 0 ? true : false;
return(FactValue.Parse(returnValue));
}
// script = "new Date("+((FactDateValue)workingMemoryLhsValue).getValue().getYear()+"/"+((FactDateValue)workingMemoryLhsValue).getValue().getMonthValue()+"/"+((FactDateValue)workingMemoryLhsValue).getValue().getDayOfMonth()+")"+operator+"new Date("+((FactDateValue)workingMemoryRhsValue).getValue().getYear()+"/"+((FactDateValue)workingMemoryRhsValue).getValue().getMonthValue()+"/"+((FactDateValue)workingMemoryRhsValue).getValue().getDayOfMonth()+");" ;
}
else if (workingMemoryLhsValue != null && (workingMemoryLhsValue.GetFactValueType().Equals(FactValueType.DECIMAL) || workingMemoryLhsValue.GetFactValueType().Equals(FactValueType.DOUBLE) ||
workingMemoryLhsValue.GetFactValueType().Equals(FactValueType.INTEGER) || workingMemoryLhsValue.GetFactValueType().Equals(FactValueType.NUMBER)))
{
script = FactValue.GetValueInString(workingMemoryLhsValue.GetFactValueType(), workingMemoryLhsValue) + operatorString + FactValue.GetValueInString(workingMemoryRhsValue.GetFactValueType(), workingMemoryRhsValue);
}
else
{
if (workingMemoryRhsValue != null && workingMemoryLhsValue != null)
{
script = "'" + FactValue.GetValueInString(workingMemoryLhsValue.GetFactValueType(), workingMemoryLhsValue) + "' " + operatorString + " '" + FactValue.GetValueInString(workingMemoryRhsValue.GetFactValueType(), workingMemoryRhsValue) + "'";
}
}
Boolean result;
FactValue fv = null;
if (workingMemoryRhsValue != null && workingMemoryLhsValue != null)
{
result = Convert.ToBoolean(jint.Execute(script).GetCompletionValue().ToString());
fv = FactValue.Parse(result);
}
return(fv);
}
public void HandleParent(string parentText, int lineNumber)
{
Node data = nodeSet.GetNodeMap().ContainsKey(parentText)?nodeSet.GetNodeMap()[parentText]:null;
if (data == null)
{
Tokens tokens = Tokenizer.GetTokens(parentText);
Regex[] matchPatterns = { META_PATTERN_MATCHER, VALUE_MATCHER, EXPRESSION_CONCLUSION_MATCHER, WARNING_MATCHER };
for (int i = 0; i < matchPatterns.Length; i++)
{
//matcher = Regex.Match(tokens.tokensString, matchPatterns[i]);
Regex regex = matchPatterns[i];
Match match = regex.Match(tokens.tokensString);
if (match.Success)
{
string variableName;
Node tempNode;
List <string> possibleParentNodeKeyList;
switch (i)
{
case 3: //warningMatcher case
HandleWarning(parentText);
break;
case 0: //metaMatcher case
data = new MetadataLine(parentText, tokens);
if (data.GetFactValue().GetFactValueType() != FactValueType.LIST && FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
case 1: //valueConclusionLine case
data = new ValueConclusionLine(parentText, tokens);
if (match.Groups[2] != null ||
(tokens.tokensString.Equals("L") || tokens.tokensString.Equals("LM") || tokens.tokensString.Equals("ML") || tokens.tokensString.Equals("M")))
{
variableName = data.GetVariableName();
tempNode = data;
/*
* following lines are to look for any nodes having a its nodeName with any operators due to the reason that
* the node could be used to define a node previously used as a child node for other nodes
*/
possibleParentNodeKeyList = nodeSet.GetNodeMap().Keys.Where(key => Regex.Match(key, "(.+)?(\\s[<>=]+\\s?)?(" + variableName + ")(\\s?[<>=]+)*(?!(.*(IS)))(.*(IS IN LIST).*)*").Success).ToList();
if (possibleParentNodeKeyList.Count != 0)
{
possibleParentNodeKeyList.ForEach(item => {
this.dependencyList.Add(new Dependency(nodeSet.GetNodeMap()[item], tempNode, DependencyType.GetOr())); //Dependency Type :OR
});
}
}
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
case 2: //exprConclusionMatcher case
data = new ExprConclusionLine(parentText, tokens);
variableName = data.GetVariableName();
tempNode = data;
/*
* following lines are to look for any nodes having a its nodeName with any operators due to the reason that
* the exprConclusion node could be used to define another node as a child node for other nodes if the variableName of exprConclusion node is mentioned somewhere else.
* However, it is excluding nodes having 'IS' keyword because if it has the keyword then it should have child nodes to define the node otherwise the entire rule set has NOT been written in correct way
*/
possibleParentNodeKeyList = nodeSet.GetNodeMap().Keys.Where(key => Regex.Match(key, "(.+)?(\\s[<>=]+\\s?)?(" + variableName + ")(\\s?[<>=]+)*(?!(.*(IS)))(.*(IS IN LIST).*)*").Success).ToList();
if (possibleParentNodeKeyList.Count != 0)
{
possibleParentNodeKeyList.ForEach(item => {
this.dependencyList.Add(new Dependency(nodeSet.GetNodeMap()[item], tempNode, DependencyType.GetOr())); //Dependency Type :OR
});
}
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
default:
HandleWarning(parentText);
break;
}
data.SetNodeLine(lineNumber);
if (data.GetLineType().Equals(LineType.META))
{
if (((MetadataLine)data).GetMetaType().Equals(MetaType.INPUT))
{
this.nodeSet.GetInputMap().Add(data.GetVariableName(), data.GetFactValue());
}
else if (((MetadataLine)data).GetMetaType().Equals(MetaType.FIXED))
{
this.nodeSet.GetFactMap().Add(data.GetVariableName(), data.GetFactValue());
}
}
else
{
this.nodeSet.GetNodeMap().Add(data.GetNodeName(), data);
this.nodeSet.GetNodeIdMap().Add(data.GetNodeId(), data.GetNodeName());
}
break;
}
}
}
}
public void HandleChild(string parentText, string childText, string firstKeywordsGroup, int lineNumber)
{
/*
* the reason for using '*' at the last group of pattern within comparison is that
* the last group contains No, Da, De, Ha, Url, Id.
* In order to track more than one character within the square bracket of last group '*'(Matches 0 or more occurrences of the preceding expression) needs to be used.
*
*/
int dependencyType = 0;
// is 'ITEM' child line
if (Regex.Match(childText, "(ITEM)(.*)").Success)
{
if (!Regex.Match(parentText, "(.*)(AS LIST)").Success)
{
HandleWarning(childText);
return;
}
// is an indented item child
childText = childText.Remove(childText.IndexOf("ITEM", StringComparison.CurrentCulture), "ITEM".Length).Trim();
MetaType?metaType = null;
if (Regex.Match(parentText, "^(INPUT)(.*)").Success)
{
metaType = MetaType.INPUT;
}
else if (Regex.Match(parentText, "^(FIXED)(.*)").Success)
{
metaType = MetaType.FIXED;
}
HandleListItem(parentText, childText, metaType);
}
else // is 'A-statement', 'A IS B', 'A <= B', or 'A IS CALC (B * C)' child line
{
if (Regex.Match(firstKeywordsGroup, "^(AND\\s?)(.*)").Success)
{
dependencyType = HandleNotKnownManOptPos(firstKeywordsGroup, DependencyType.GetAnd()); // 8-AND | 1-KNOWN? 2-NOT? 64-MANDATORY? 32-OPTIONALLY? 16-POSSIBLY?
}
else if (Regex.Match(firstKeywordsGroup, "^(OR\\s?)(.*)").Success)
{
dependencyType = HandleNotKnownManOptPos(firstKeywordsGroup, DependencyType.GetOr()); // 4-OR | 1-KNOWN? 2-NOT? 64-MANDATORY? 32-OPTIONALLY? 16-POSSIBLY?
}
else if (Regex.Match(firstKeywordsGroup, "^(WANTS)").Success)
{
dependencyType = DependencyType.GetOr(); // 4-OR
}
else if (Regex.Match(firstKeywordsGroup, "^(NEEDS)").Success)
{
dependencyType = DependencyType.GetMandatory() | DependencyType.GetAnd(); // 8-AND | 64-MANDATORY
}
/*
* the keyword of 'AND' or 'OR' should be removed individually.
* it should NOT be removed by using firstToken string in Tokens.tokensList.get(0)
* because firstToken string may have something else.
* (e.g. string: 'AND NOT ALL Males' name should sound Male', then Token string will be 'UMLM', and 'U' contains 'AND NOT ALL'.
* so if we used 'firstToken string' to remove 'AND' in this case as 'string.replace(firstTokenString)'
* then it will remove 'AND NOT ALL' even we only need to remove 'AND'
*
*/
Node data = null;
nodeSet.GetNodeMap().TryGetValue(childText, out data);
Tokens tokens = Tokenizer.GetTokens(childText);
if (data == null)
{
Regex[] matchPatterns = { VALUE_MATCHER, COMPARISON_MATCHER, ITERATE_MATCHER, EXPRESSION_CONCLUSION_MATCHER, WARNING_MATCHER };
Node tempNode;
List <string> possibleChildNodeKeyList;
for (int i = 0; i < matchPatterns.Length; i++)
{
Regex regex = matchPatterns[i];
Match match = regex.Match(tokens.tokensString);
if (match.Success)
{
switch (i)
{
case 4: // warningMatcher case
HandleWarning(childText);
break;
case 0: // valueConclusionMatcher case
data = new ValueConclusionLine(childText, tokens);
tempNode = data;
possibleChildNodeKeyList = nodeSet.GetNodeMap().Keys.Where(key => Regex.Match(key, "^(" + tempNode.GetVariableName() + ")(\\s+(IS(?!(\\s+IN\\s+LIST))).*)*$").Success).ToList();
if (possibleChildNodeKeyList.Count != 0)
{
possibleChildNodeKeyList.ForEach(item => {
this.dependencyList.Add(new Dependency(tempNode, nodeSet.GetNodeMap()[item], DependencyType.GetOr())); //Dependency Type :OR
});
}
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
case 1: // comparisonMatcher case
data = new ComparisonLine(childText, tokens);
FactValueType rhsType = ((ComparisonLine)data).GetRHS().GetFactValueType();
string rhsString = FactValue.GetValueInString(((ComparisonLine)data).GetRHS().GetFactValueType(), ((ComparisonLine)data).GetRHS());
string lhsString = ((ComparisonLine)data).GetLHS();
tempNode = data;
possibleChildNodeKeyList = rhsType.Equals(FactValueType.STRING) ?
nodeSet.GetNodeMap().Keys.Where(key => Regex.Match(key, "^(" + lhsString + ")(\\s+(IS(?!(\\s+IN\\s+LIST))).*)*$").Success || Regex.Match(key, "^(" + rhsString + ")(\\s+(IS(?!(\\s+IN\\s+LIST))).*)*$").Success).ToList()
:
nodeSet.GetNodeMap().Keys.Where(key => Regex.Match(key, "^(" + lhsString + ")(\\s+(IS(?!(\\s+IN\\s+LIST))).*)*$").Success).ToList();
if (possibleChildNodeKeyList.Count != 0)
{
possibleChildNodeKeyList.ForEach(item => {
this.dependencyList.Add(new Dependency(tempNode, nodeSet.GetNodeMap()[item], DependencyType.GetOr())); //Dependency Type :OR
});
}
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
case 2: // iteratenMatcher case
data = new IterateLine(childText, tokens);
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
case 3: //exprConclusionMatcher case
data = new ExprConclusionLine(childText, tokens);
/*
* In this case, there is no mechanism to find possible parent nodes.
* I have brought 'local variable' concept for this case due to it may massed up with structuring node dependency tree with topological sort
* If ExprConclusion node is used as a child, then it means that this node is a local node which has to be strictly bound to its parent node only.
*/
if (FactValue.GetValueInString(data.GetFactValue().GetFactValueType(), data.GetFactValue()).Equals("WARNING"))
{
HandleWarning(parentText);
}
break;
}
data.SetNodeLine(lineNumber);
this.nodeSet.GetNodeMap().Add(data.GetNodeName(), data);
this.nodeSet.GetNodeIdMap().Add(data.GetNodeId(), data.GetNodeName());
break;
}
}
}
this.dependencyList.Add(new Dependency(this.nodeSet.GetNode(parentText), data, dependencyType));
}
}
public override FactValue SelfEvaluate(Dictionary <string, FactValue> workingMemory, Jint.Engine jint)
{
/*
* calculation can only handle int, double(long) and difference in years between two dates at the moment.
* if difference in days or months is required then new 'keyword' must be introduced such as 'Diff Years', 'Diff Days', or 'Diff Months'
*/
string equationInString = FactValue.GetValueInString(this.equation.GetFactValueType(), this.equation);
string pattern = @"[-+/*()?:;,.""](\s*)";
string datePattern = @"([0-2]?[0-9]|3[0-1])/(0?[0-9]|1[0-2])/([0-9][0-9])?[0-9][0-9]|([0-9][0-9])?[0-9][0-9]/(0?[0-9]|1[0-2])/([0-2]?[0-9]|3[0-1])";
/*
* logic for this is as follows;
* 1. replace all variables with actual values from 'workingMemory'
* 2. find out if equation is about date (difference in years) calculation or not
* 3. if it is about date then call 'java.time.LocalDate'and 'java.time.temporal.ChronoUnit' package then do the calculation
* 3-1. if it is about int or double(long) then use plain Javascript
*
*/
string script = equationInString;
string tempScript = script;
string result;
if (Regex.IsMatch(equationInString, pattern))
{
string[] tempArray = Regex.Split(equationInString, pattern);
int tempArrayLength = tempArray.Length;
string tempItem;
for (int i = 0; i < tempArrayLength; i++)
{
tempItem = tempArray[i];
if (!string.IsNullOrEmpty(tempItem.Trim()) && (workingMemory.ContainsKey(tempItem.Trim()) && workingMemory[tempItem.Trim()] != null))
{
FactValue tempFv = workingMemory[tempItem.Trim()];
if (tempFv.GetFactValueType().Equals(FactValueType.DATE))
{
/*
* below line is temporary solution.
* Within next iteration it needs to be that this node should take dateFormatter for its constructor to determine which date format it needs
*/
string tempStr = DateTime.ParseExact(FactValue.GetValueInString(tempFv.GetFactValueType(), tempFv), dateFormatter, CultureInfo.InvariantCulture).ToString().Split(' ')[0].Trim();
tempScript = tempScript.Replace(tempItem.Trim(), tempStr);
}
else
{
tempScript = tempScript.Replace(tempItem.Trim(), FactValue.GetValueInString(workingMemory[tempItem.Trim()].GetFactValueType(), workingMemory[tempItem.Trim()]).Trim());
}
}
}
}
MatchCollection dateMatcher = Regex.Matches(tempScript, datePattern);
List <DateTime> dateTimeList = new List <DateTime>();
if (dateMatcher.Count > 0)
{
foreach (Match match in dateMatcher)
{
string[] datetimeString = Regex.Split(match.Groups[0].ToString(), @"/");
int year = 0;
int month = 0;
int day = 0;
if (Int32.TryParse(datetimeString[2], out year) && Int32.TryParse(datetimeString[1], out month) && Int32.TryParse(datetimeString[0], out day))
{
dateTimeList.Add(new DateTime(year, month, day));
}
}
result = (dateTimeList[0].Subtract(dateTimeList[1]).TotalDays / 365.25).ToString();
}
else
{
result = jint.Execute(tempScript).GetCompletionValue().ToString();
}
FactValue returnValue = null;
switch (Tokenizer.GetTokens(result).tokensString)
{
case "No":
int intResult = 0;
Int32.TryParse(result, out intResult);
returnValue = FactValue.Parse(intResult);
break;
case "De":
returnValue = FactValue.Parse(Convert.ToDouble(result));
break;
//there is no function for outcome to be a date at the moment E.g.The determination IS CALC(enrollment date + 5 days)
//case "Da":
default:
returnValue = FactValue.Parse(result);
break;
}
return(returnValue);
}