/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); XmlDocument doc = context.ContextDocument.XmlDocument; if( context.ContextDocument.XmlNamespaceManager == null ) { context.ContextDocument.AddNamespaces( context.PolicyDocument.Namespaces ); } string xPath = GetStringArgument( args, 0 ); XmlNodeList firstList = doc.DocumentElement.SelectNodes( xPath, context.ContextDocument.XmlNamespaceManager ); xPath = GetStringArgument( args, 1 ); XmlNodeList secondList = doc.DocumentElement.SelectNodes( xPath, context.ContextDocument.XmlNamespaceManager ); foreach( XmlNode firstNode in firstList ) { foreach( XmlNode secondNode in secondList ) { if( firstNode == secondNode ) { return EvaluationValue.True; } } } return EvaluationValue.False; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IDataType type = DataType; BagValue retBag = new BagValue( type ); inf.IFunction function = type.EqualFunction; inf.IFunction functionDup = type.IsInFunction; foreach( object par1 in args[0].Elements ) { foreach( object par2 in args[1].Elements ) { EvaluationValue retVal = function.Evaluate( context, new EvaluationValue( par1, args[0].GetType( context ) ), new EvaluationValue( par2, args[1].GetType( context ) ) ); if( retVal.BoolValue ) { retVal = functionDup.Evaluate( context, new EvaluationValue( par2, args[1].GetType( context ) ), retBag ); if( !retVal.BoolValue ) { retBag.Add( new EvaluationValue( par1, args[0].GetType( context ) ) ); } } } } return new EvaluationValue( retBag, type ); }
/// <summary> /// Method called by the EvaluationEngine to evaluate the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param> /// <returns></returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = args[0].GetFunction( 0 ); foreach( object par1 in args[1].Elements ) { bool hasFound = false; foreach( object par2 in args[2].Elements ) { EvaluationValue retVal = function.Evaluate( context, new EvaluationValue( par1, args[1].GetType( context ) ), new EvaluationValue( par2, args[2].GetType( context ) ) ); if( retVal.BoolValue ) { hasFound = true; break; } } if( !hasFound ) { return EvaluationValue.False; } } return EvaluationValue.True; }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="policies">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the policy evaluation.</returns> public Decision Evaluate( EvaluationContext context, IMatchEvaluableCollection policies ) { foreach( IMatchEvaluable policy in policies ) { Decision decision = policy.Evaluate( context ); context.TraceContextValues(); if( decision == Decision.Deny ) { context.ProcessingError = false; context.IsMissingAttribute = false; return Decision.Deny; } if( decision == Decision.Permit ) { context.ProcessingError = false; context.IsMissingAttribute = false; return Decision.Permit; } if( decision == Decision.NotApplicable ) { continue; } if( decision == Decision.Indeterminate ) { return Decision.Indeterminate; } } return Decision.NotApplicable; }
/// <summary> /// Method called by the EvaluationEngine when an attribute is not found. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="designator">The attribute designator.</param> /// <returns>An instance of an Attribute with it's value.</returns> public ctx.AttributeElement GetAttribute(rtm.EvaluationContext context, pol.AttributeDesignatorBase designator) { if (context == null) { throw new ArgumentNullException("context"); } if (designator == null) { throw new ArgumentNullException("designator"); } foreach (ctx.AttributeElement attrib in _attributes) { if (attrib.AttributeId == designator.AttributeId) { if (designator.Issuer != null && designator.Issuer.Length != 0) { if (designator.Issuer == attrib.Issuer) { return(attrib); } } else { return(attrib); } } } return(null); }
/// <summary> /// Method called by the EvaluationEngine to evaluate the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param> /// <returns></returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); int argCount = GetIntegerArgument( args, 0 ); if( args.Length - 1 < argCount ) { return EvaluationValue.Indeterminate; } else if( argCount == 0 ) { return EvaluationValue.True; } else { int count = 0; for( int i = 1; i < args.Length; i++ ) { if( GetBooleanArgument( args, i ) ) { count++; } if( count == argCount ) { return EvaluationValue.True; } } return EvaluationValue.False; } }
/// <summary> /// Method called by the EvaluationEngine to evaluate the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param> /// <returns></returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = args[0].GetFunction( 0 ); if( function.Returns != DataTypeDescriptor.Boolean ) { return EvaluationValue.Indeterminate; } foreach( object par1 in args[1].Elements ) { foreach( object par2 in args[2].Elements ) { EvaluationValue retVal = function.Evaluate( context, new EvaluationValue( par1, args[1].GetType( context ) ), new EvaluationValue( par2, args[2].GetType( context ) ) ); if( !retVal.BoolValue ) { return EvaluationValue.False; } } } return EvaluationValue.True; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); if( GetBase64BinaryArgument( args, 0 ).Equals( GetBase64BinaryArgument( args, 1 ) ) ) { return EvaluationValue.True; } return EvaluationValue.False; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); bool retVal = GetBooleanArgument( args, 0 ); for( int i = 1; i < args.Length; i++ ) { retVal &= GetBooleanArgument( args, i ); } return new EvaluationValue( retVal, DataTypeDescriptor.Boolean ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); UriBuilder uri = new UriBuilder( GetAnyUriArgument( args, 0 ) ); for( int i = 1; i < args.Length; i++ ) { uri.Path = Path.Combine( uri.Path, GetStringArgument( args, i ) ); } return new EvaluationValue( uri.Uri, DataTypeDescriptor.AnyUri ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); double add = 0; for( int i = 0; i < args.Length; i++ ) { add += GetDoubleArgument( args, i ); } return new EvaluationValue( add, DataTypeDescriptor.Double ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); StringBuilder concat = new StringBuilder(); for( int i = 0; i < args.Length; i++ ) { concat.Append( GetStringArgument( args, i ) ); } return new EvaluationValue( concat.ToString(), DataTypeDescriptor.String ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IDataType type = DataType; BagValue bag = new BagValue( type ); for( int i = 0; i < args.Length; i++ ) { bag.Add( args[ i ].GetTypedValue( type, i ) ); } return new EvaluationValue( bag, type ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); DateTime baseDate = GetDateArgument( args, 0 ); typ.YearMonthDuration yearMonthDuration = (typ.YearMonthDuration)args[1].GetTypedValue( DataTypeDescriptor.YearMonthDuration, 1 ); baseDate = baseDate.AddYears( yearMonthDuration.Years*-1 ); baseDate = baseDate.AddMonths( yearMonthDuration.Months*-1 ); return new EvaluationValue( baseDate, DataTypeDescriptor.Date ); }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="policies">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the policy evaluation.</returns> public Decision Evaluate( EvaluationContext context, IMatchEvaluableCollection policies ) { Boolean atLeastOne = false; Policy selectedPolicy = null; TargetEvaluationValue appResult; for( int i = 0; i < policies.Count; i++ ) { Policy tempPolicy = (Policy)policies[ i ]; appResult = appResult = tempPolicy.Match( context ); if( appResult == TargetEvaluationValue.Indeterminate ) { context.ProcessingError = true; context.TraceContextValues(); return Decision.Indeterminate; } if( appResult == TargetEvaluationValue.Match ) { if ( atLeastOne ) { context.ProcessingError = true; context.TraceContextValues(); return Decision.Indeterminate; } else { atLeastOne = true; selectedPolicy = (Policy)policies[i]; } } if ( appResult == TargetEvaluationValue.NoMatch ) { continue; } } if ( atLeastOne ) { Decision retValue = selectedPolicy.Evaluate( context ); context.TraceContextValues(); if( retValue == Decision.Deny || retValue == Decision.Permit ) { context.ProcessingError = false; context.IsMissingAttribute = false; } return retValue; } else { return Decision.NotApplicable; } }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); if( ((typ.Rfc822Name)args[1].GetTypedValue( DataTypeDescriptor.Rfc822Name, 1 )).Matches( GetStringArgument( args, 0 ) ) ) { return EvaluationValue.True; } else { return EvaluationValue.False; } }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); if(String.Compare( GetStringArgument( args, 0 ), GetStringArgument( args, 1 ) ) < 0 ) { return EvaluationValue.True; } else { return EvaluationValue.False; } }
/// <summary> /// Method called by the EvaluationEngine when the evaluation is executed without a policy document, this /// method search in the policy repository and return the first policy that matches its target with the /// context document specified. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <returns>The policy document ready to be used by the evaluation engine.</returns> public pol.PolicyDocument Match(rtm.EvaluationContext context) { if (context == null) { throw new ArgumentNullException("context"); } pol.PolicyDocument polEv = null; //Search if there is a policySet which target matches the context document foreach (pol.PolicyDocument policy in _policySets.Values) { rtm.PolicySet tempPolicy = new rtm.PolicySet(context.Engine, (pol.PolicySetElement)policy.PolicySet); rtm.EvaluationContext tempContext = new rtm.EvaluationContext(context.Engine, policy, context.ContextDocument); // Match the policy set target with the context document if (tempPolicy.Match(tempContext) == rtm.TargetEvaluationValue.Match) { if (polEv == null) { polEv = policy; } else { throw new EvaluationException(Resource.ResourceManager[Resource.MessageKey.exc_duplicated_policy_in_repository]); } } } //Search if there is a policy which target matches the context document foreach (pol.PolicyDocument policy in _policies.Values) { rtm.Policy tempPolicy = new rtm.Policy((pol.PolicyElement)policy.Policy); rtm.EvaluationContext tempContext = new rtm.EvaluationContext(context.Engine, policy, context.ContextDocument); // Match the policy target with the context document if (tempPolicy.Match(tempContext) == rtm.TargetEvaluationValue.Match) { if (polEv == null) { polEv = policy; } else { throw new EvaluationException(Resource.ResourceManager[Resource.MessageKey.exc_duplicated_policy_in_repository]); } } } return(polEv); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); if( args[0].IsBag && args[0].BagSize == 1 ) { inf.IFunctionParameter attrib = (inf.IFunctionParameter)args[0].Elements[0]; return new EvaluationValue( GetTypedValue( attrib ), DataType ); } else { return EvaluationValue.Indeterminate; } }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); DateTime baseDate = GetDateTimeArgument( args, 0 ); typ.DaytimeDuration dayTimeDuration = GetDaytimeDurationArgument( args, 1 ); baseDate = baseDate.AddDays( dayTimeDuration.Days ); baseDate = baseDate.AddHours( dayTimeDuration.Hours ); baseDate = baseDate.AddMinutes( dayTimeDuration.Minutes ); baseDate = baseDate.AddSeconds( dayTimeDuration.Seconds ); return new EvaluationValue( baseDate, DataTypeDescriptor.DateTime ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); XmlDocument doc = context.ContextDocument.XmlDocument; if( context.ContextDocument.XmlNamespaceManager == null ) { context.ContextDocument.AddNamespaces( context.PolicyDocument.Namespaces ); } string xPath = GetStringArgument( args, 0 ); XmlNodeList list = doc.DocumentElement.SelectNodes( xPath, context.ContextDocument.XmlNamespaceManager ); return new EvaluationValue( list.Count, DataTypeDescriptor.Integer ); }
/// <summary> /// Method called by the EvaluationEngine to evaluate the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param> /// <returns></returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = args[0].GetFunction( 0 ); EvaluationValue value = new EvaluationValue( args[1], args[1].GetType( context ) ); foreach( object par in args[2].Elements ) { EvaluationValue retVal = function.Evaluate( context, value, new EvaluationValue( par, args[2].GetType( context ) ) ); if( !retVal.BoolValue ) { return retVal; } } return EvaluationValue.True; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); string pattern = GetStringArgument( args, 0 ); string input = GetArgumentAsString( args, 1 ); Regex regEx = new Regex( pattern ); Match m = regEx.Match( input ); if( m.Success ) { return EvaluationValue.True; } else { return EvaluationValue.False; } }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = DataType.SubsetFunction; if( ( function.Evaluate( context, new EvaluationValue( args[0], args[0].GetType( context ) ), new EvaluationValue( args[1], args[1].GetType( context ) ) ) == EvaluationValue.True ) && ( function.Evaluate( context, new EvaluationValue( args[1], args[1].GetType( context ) ), new EvaluationValue( args[0], args[0].GetType( context ) ) ) == EvaluationValue.True ) ) { return EvaluationValue.True; } else { return EvaluationValue.False; } }
/// <summary> /// Method called by the EvaluationEngine to evaluate the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param> /// <returns></returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = args[0].GetFunction( 0 ); if( !args[ 1 ].IsBag ) { return EvaluationValue.False; } BagValue retVal = new BagValue( args[1].GetType( context ) ); foreach( object par in args[1].Elements ) { retVal.Add( function.Evaluate( context, new EvaluationValue( par, args[1].GetType( context ) ) ) ); } return new EvaluationValue( retVal, args[1].GetType( context ) ); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); if( args[1].IsBag ) { inf.IFunction function = DataType.EqualFunction; foreach( object value in args[1].Elements ) { if( function.Evaluate( context, new EvaluationValue( args[0], args[0].GetType( context ) ), new EvaluationValue( value, args[1].GetType( context ) ) ) == EvaluationValue.True ) { return EvaluationValue.True; } } } return EvaluationValue.False; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); try { if( GetAnyUriArgument( args, 0 ).Equals( GetAnyUriArgument( args, 1 ) ) ) { return EvaluationValue.True; } else { return EvaluationValue.False; } } catch( EvaluationException e ) { context.Trace( Resource.TRACE_ERROR, e.Message ); return EvaluationValue.False; } }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="args">The function arguments.</param> /// <returns>The result value of the function evaluation.</returns> public override EvaluationValue Evaluate( EvaluationContext context, params inf.IFunctionParameter[] args ) { if (context == null) throw new ArgumentNullException("context"); if (args == null) throw new ArgumentNullException("args"); inf.IFunction function = DataType.EqualFunction; foreach( object par1 in args[0].Elements ) { foreach( object par2 in args[1].Elements ) { EvaluationValue retVal = function.Evaluate( context, new EvaluationValue( par1, args[0].GetType( context ) ), new EvaluationValue( par2, args[1].GetType( context ) ) ); if( retVal.BoolValue ) { return EvaluationValue.True; } } } return EvaluationValue.False; }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="rules">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the rule evaluation.</returns> public Decision Evaluate( EvaluationContext context, RuleCollection rules ) { Decision decision = Decision.Indeterminate; context.Trace( "Evaluating rules..." ); context.AddIndent(); try { foreach( Rule rule in rules ) { decision = rule.Evaluate( context ); context.TraceContextValues(); if( decision == Decision.Deny ) { decision = Decision.Deny; return decision; } if( decision == Decision.Permit ) { decision = Decision.Permit; return decision; } if( decision == Decision.NotApplicable ) { continue; } if( decision == Decision.Indeterminate ) { decision = Decision.Indeterminate; return decision; } } return Decision.NotApplicable; } finally { context.Trace( "Rule combination algorithm: {0}", decision.ToString() ); context.RemoveIndent(); } }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="policies">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the policy evaluation.</returns> public Decision Evaluate( EvaluationContext context, IMatchEvaluableCollection policies ) { if (context == null) throw new ArgumentNullException("context"); if (policies == null) throw new ArgumentNullException("policies"); bool atLeastOnePermit = false; foreach( IMatchEvaluable policy in policies ) { Decision decision = policy.Evaluate( context ); if( decision == Decision.Deny ) { context.ProcessingError = false; context.IsMissingAttribute = false; return Decision.Deny; } if( decision == Decision.Permit ) { atLeastOnePermit = true; continue; } if( decision == Decision.NotApplicable ) { continue; } if( decision == Decision.Indeterminate ) { context.ProcessingError = false; context.IsMissingAttribute = false; return Decision.Deny; } } if( atLeastOnePermit ) { context.ProcessingError = false; context.IsMissingAttribute = false; return Decision.Permit; } return Decision.NotApplicable; }
/// <summary> /// Evaluates the rule contents. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <returns>A decission for this evalauation.</returns> public Decision Evaluate( EvaluationContext context ) { if (context == null) throw new ArgumentNullException("context"); context.Trace( "Evaluating rule: {0}", _rule.Description ); context.AddIndent(); context.CurrentRule = this; try { // Validate the Target element TargetEvaluationValue targetEvaluation = Match( context ); // If the target matches the conditions ar evaluated EvaluationValue conditionEvaluation = EvaluationValue.True; if( _rule.HasCondition ) { // Evaluate the condition conditionEvaluation = _condition.Evaluate( context ); } else { context.Trace( "Rule does not have a condition" ); } // Decite the final rule evaluation value if( targetEvaluation == TargetEvaluationValue.Indeterminate || conditionEvaluation.IsIndeterminate ) { _evaluationValue = Decision.Indeterminate; } else if( targetEvaluation == TargetEvaluationValue.Match && conditionEvaluation.BoolValue ) { _evaluationValue = ((_rule.Effect == pol.Effect.Permit) ? Decision.Permit : Decision.Deny); } else if( ( targetEvaluation == TargetEvaluationValue.NoMatch ) || ( targetEvaluation == TargetEvaluationValue.Match && !conditionEvaluation.BoolValue ) ) { _evaluationValue = Decision.NotApplicable; } // Return the value context.Trace( "Rule: {0}", _evaluationValue ); return _evaluationValue; } finally { context.RemoveIndent(); context.CurrentRule = null; } }
/// <summary> /// Verifies if the rule target matches /// </summary> /// <param name="context">The evaluation context instance.</param> /// <returns>The result of the Match process.</returns> public TargetEvaluationValue Match( EvaluationContext context ) { if (context == null) throw new ArgumentNullException("context"); TargetEvaluationValue targetEvaluationValue = TargetEvaluationValue.Indeterminate; context.Trace( "Evaluating rule target" ); context.AddIndent(); try { // Evaluate the policy target targetEvaluationValue = TargetEvaluationValue.Match; if( _target != null ) { targetEvaluationValue = _target.Evaluate( context ); context.TraceContextValues(); } return targetEvaluationValue; } finally { context.RemoveIndent(); context.Trace( "Target: {0}", targetEvaluationValue ); } }
/// <summary> /// Gets the data type of the value. /// </summary> /// <param name="context">The evaluation context.</param> /// <returns>The data type descriptor.</returns> public inf.IDataType GetType(rtm.EvaluationContext context) { return(rtm.EvaluationEngine.GetDataType(DataTypeValue)); }