//public FilterViewModel()
//{
//}
private static string GetEnumDescription(ConditionValue value)
{
// Get the Description attribute value for the enum value
FieldInfo fi = value.GetType().GetField(value.ToString());
DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes.Length > 0)
{
return(attributes[0].Description);
}
else
{
return(value.ToString());
}
}
private void saveToXml(XmlNode nodeFunctions)
{
var nodeFunction = Calculator.InsertNodeToXml(nodeFunctions, IsLimitation ? "limitation-function" : "function");
var nodeElements = Calculator.InsertNodeToXml(nodeFunction, "elements");
foreach (var element in Elements)
{
var nodeElement = Calculator.InsertNodeToXml(nodeElements, "element");
var nodeOperator = Calculator.InsertNodeToXml(nodeElement, "operator");
nodeOperator.InnerText = element.Operator == FunctionOperator.Addition ? "+" : "-";
var nodeValue = Calculator.InsertNodeToXml(nodeElement, "value");
nodeValue.InnerText = element.Value.ToString();
}
if (IsLimitation)
{
var nodeLimitation = Calculator.InsertNodeToXml(nodeFunction, "limitation");
var nodeCondition = Calculator.InsertNodeToXml(nodeLimitation, "condition");
nodeCondition.InnerText = Condition.ToString();
var nodeValue = Calculator.InsertNodeToXml(nodeLimitation, "value");
nodeValue.InnerText = ConditionValue.ToString();
}
}
public override IEnumerable <(string filedName, string value)> GetStringFields()
{
yield return("IfKeywordStr", IfKeywordStr);
yield return("ConditionStr", ConditionStr);
yield return("ConditionValue", ConditionValue.ToString());
yield return("BranchTaken", BranchTaken.ToString());
yield return("DirectiveNameTokenStr", DirectiveNameTokenStr);
yield return("HashTokenStr", HashTokenStr);
yield return("EndOfDirectiveTokenStr", EndOfDirectiveTokenStr);
yield return("IsActive", IsActive.ToString());
}
/// <summary>
/// Metoda vrsi evaluaciju po principu definisanim XACML standardom
/// </summary>
/// <param name="request"></param>
/// <param name="rule"></param>
/// <returns></returns>
public static DecisionType RuleEvaluate(RequestType request, RuleType rule)
{
DecisionType Effect = DecisionType.Permit;
if (rule.Effect.Equals(EffectType.Permit))
{
Effect = DecisionType.Permit;
}
else if (rule.Effect.Equals(EffectType.Deny))
{
Effect = DecisionType.Deny;
}
string AllOfValue = string.Empty;
string AnyOfValue = string.Empty;
TargetType Target = rule.Target;
ConditionType Condition = rule.Condition;
try
{
TargetResult TargetValue = TargetEvaluate.CheckTarget(Target, request);
ConditionResult ConditionValue;
if (TargetValue == TargetResult.NoMatch)
{
ConditionValue = ConditionResult.DontCare;
}
else
{
ConditionValue = ConditionEvaluate.CheckCondition(Condition, request);
}
Console.WriteLine("\nTarget evaluation: {0}", TargetValue.ToString());
Console.WriteLine("Condition evaluation: {0}", ConditionValue.ToString());
// RULE EVALUACIJA
if (TargetValue == TargetResult.Match && ConditionValue == ConditionResult.True)
{
return(Effect);
}
else if (TargetValue == TargetResult.Match && ConditionValue == ConditionResult.False)
{
return(DecisionType.NotApplicable);
}
else if (TargetValue == TargetResult.Match && ConditionValue == ConditionResult.Indeterminate)
{
return(DecisionType.Indeterminate);
}
else if (TargetValue == TargetResult.NoMatch && ConditionValue == ConditionResult.DontCare)
{
return(DecisionType.NotApplicable);
}
else if (TargetValue == TargetResult.Indeterminate && ConditionValue == ConditionResult.DontCare)
{
return(DecisionType.Indeterminate);
}
else
{
return(DecisionType.Indeterminate);
}
}
catch (Exception e)
{
Console.WriteLine("Error: {0}", e.Message);
return(DecisionType.Indeterminate);
}
}