/// <summary> /// Creates an instance of a TargetMatchBase with the values specified. /// </summary> /// <param name="matchId">The match id</param> /// <param name="attributeValue">The attribute value instance.</param> /// <param name="attributeReference">An attribute reference instance.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBaseReadWrite( string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion schemaVersion ) : base( XacmlSchema.Policy, schemaVersion ) { _id = matchId; _attributeValue = attributeValue; _attributeReference = attributeReference; }
/// <summary> /// Creates an instance of a TargetMatchBase with the values specified. /// </summary> /// <param name="matchId">The match id</param> /// <param name="attributeValue">The attribute value instance.</param> /// <param name="attributeReference">An attribute reference instance.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBaseReadWrite(string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion schemaVersion) : base(XacmlSchema.Policy, schemaVersion) { _id = matchId; _attributeValue = attributeValue; _attributeReference = attributeReference; }
private void CreateAttributeValue(object sender, EventArgs args) { pol.AttributeValueElementReadWrite attr = new pol.AttributeValueElementReadWrite(InternalDataTypes.XsdString, "TODO: Add content", XacmlVersion.Version11); AttributeValue node = new AttributeValue(attr); tvwCondition.Nodes.Add(node); _condition.Arguments.Add(attr); }
private void CreateAttributeValueFromFunction(object sender, EventArgs args) { FunctionExecution func = (FunctionExecution)tvwCondition.SelectedNode; pol.ApplyBaseReadWrite parentApply = func.ApplyBaseDefinition; pol.AttributeValueElementReadWrite attr = new pol.AttributeValueElementReadWrite(InternalDataTypes.XsdString, "TODO: Add content", XacmlVersion.Version11); AttributeValue node = new AttributeValue(attr); func.Nodes.Add(node); parentApply.Arguments.Add(attr); }
/// <summary> /// Creates an instance of the TargetMatchBase class using the XmlReader specified, the name of the node that defines /// the match (the name of the node changes depending on the target item that defines it) and the attribute /// designator node name which also changes depending on the target item that defines the match. /// </summary> /// <param name="reader">The XmlReader positioned at the "matchNodeName" node.</param> /// <param name="matchNodeName">The name of the match node for this target item.</param> /// <param name="attributeDesignatorNode">The name of the attribute designator node for this target item.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBaseReadWrite(XmlReader reader, string matchNodeName, string attributeDesignatorNode, XacmlVersion schemaVersion) : base(XacmlSchema.Policy, schemaVersion) { if (reader == null) { throw new ArgumentNullException("reader"); } if (reader.LocalName == matchNodeName && ValidateSchema(reader, schemaVersion)) { _id = reader.GetAttribute(MatchElement.MatchId); while (reader.Read()) { if (reader.LocalName == PolicySchema1.AttributeValueElement.AttributeValue && ValidateSchema(reader, schemaVersion) && reader.NodeType != XmlNodeType.EndElement) { _attributeValue = new AttributeValueElementReadWrite(reader, schemaVersion); } else if (reader.LocalName == attributeDesignatorNode && ValidateSchema(reader, schemaVersion) && reader.NodeType != XmlNodeType.EndElement) { _attributeReference = CreateAttributeDesignator(reader); } else if (reader.LocalName == PolicySchema1.AttributeSelectorElement.AttributeSelector && ValidateSchema(reader, schemaVersion) && reader.NodeType != XmlNodeType.EndElement) { _attributeReference = new AttributeSelectorElement(reader, schemaVersion); } else if (reader.LocalName == matchNodeName && reader.NodeType == XmlNodeType.EndElement) { break; } } } else { throw new Exception(Resource.ResourceManager[Resource.MessageKey.exc_invalid_node_name, reader.LocalName]); } }
/// <summary> /// Creates an instance of the ResourceMatch class using the specified arguments. /// </summary> /// <param name="matchId">The function id for this match.</param> /// <param name="attributeValue">The attribute value to use as the first parameter to the function.</param> /// <param name="attributeReference">The attribute reference in the context document.</param> /// <param name="version">The version of the schema that was used to validate.</param> public ResourceMatchElementReadWrite(string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion version) : base(matchId, attributeValue, attributeReference, version) { }
/// <summary> /// Evaluates the variable into a value. /// </summary> /// <param name="context">The contex of the evaluation.</param> /// <returns>The value of the function.</returns> public EvaluationValue Evaluate(EvaluationContext context) { if (context == null) { throw new ArgumentNullException("context"); } context.Trace("Evaluating variable"); context.AddIndent(); try { if (_variableDefinition.Expression is pol.ApplyElement) { context.Trace("Apply within condition."); // There is a nested apply un this policy a new Apply will be created and also // evaluated. It's return value will be used as the processed argument. Apply _childApply = new Apply((pol.ApplyElement)_variableDefinition.Expression); // Evaluate the Apply _value = _childApply.Evaluate(context); context.TraceContextValues(); return(_value); } else if (_variableDefinition.Expression is pol.FunctionElement) { throw new NotImplementedException("FunctionElement"); //TODO: } else if (_variableDefinition.Expression is pol.VariableReferenceElement) { pol.VariableReferenceElement variableRef = _variableDefinition.Expression as pol.VariableReferenceElement; VariableDefinition variableDef = context.CurrentPolicy.VariableDefinition[variableRef.VariableId] as VariableDefinition; context.TraceContextValues(); if (!variableDef.IsEvaluated) { return(variableDef.Evaluate(context)); } else { return(variableDef.Value); } } else if (_variableDefinition.Expression is pol.AttributeValueElementReadWrite) { // The AttributeValue does not need to be processed context.Trace("Attribute value {0}", _variableDefinition.Expression.ToString()); pol.AttributeValueElementReadWrite att = (pol.AttributeValueElementReadWrite)_variableDefinition.Expression; pol.AttributeValueElement attributeValue = new pol.AttributeValueElement(att.DataType, att.Contents, att.SchemaVersion); _value = new EvaluationValue( attributeValue.GetTypedValue(attributeValue.GetType(context), 0), attributeValue.GetType(context)); return(_value); } else if (_variableDefinition.Expression is pol.AttributeDesignatorBase) { // Resolve the AttributeDesignator using the EvaluationEngine public methods. context.Trace("Processing attribute designator: {0}", _variableDefinition.Expression.ToString()); pol.AttributeDesignatorBase attrDes = (pol.AttributeDesignatorBase)_variableDefinition.Expression; BagValue bag = EvaluationEngine.Resolve(context, attrDes); // If the attribute was not resolved by the EvaluationEngine search the // attribute in the context document, also using the EvaluationEngine public // methods. if (bag.BagSize == 0) { if (_variableDefinition.Expression is pol.SubjectAttributeDesignatorElement) { ctx.AttributeElement attrib = EvaluationEngine.GetAttribute(context, attrDes); if (attrib != null) { context.Trace("Adding subject attribute designator: {0}", attrib.ToString()); bag.Add(attrib); } } else if (_variableDefinition.Expression is pol.ResourceAttributeDesignatorElement) { ctx.AttributeElement attrib = EvaluationEngine.GetAttribute(context, attrDes); if (attrib != null) { context.Trace("Adding resource attribute designator {0}", attrib.ToString()); bag.Add(attrib); } } else if (_variableDefinition.Expression is pol.ActionAttributeDesignatorElement) { ctx.AttributeElement attrib = EvaluationEngine.GetAttribute(context, attrDes); if (attrib != null) { context.Trace("Adding action attribute designator {0}", attrib.ToString()); bag.Add(attrib); } } else if (_variableDefinition.Expression is pol.EnvironmentAttributeDesignatorElement) { ctx.AttributeElement attrib = EvaluationEngine.GetAttribute(context, attrDes); if (attrib != null) { context.Trace("Adding environment attribute designator {0}", attrib.ToString()); bag.Add(attrib); } } } // If the argument was not found and the attribute must be present this is // a MissingAttribute situation so set the flag. Otherwise add the attribute // to the processed arguments. if (bag.BagSize == 0 && attrDes.MustBePresent) { context.Trace("Attribute is missing"); context.IsMissingAttribute = true; context.AddMissingAttribute(attrDes); _value = EvaluationValue.Indeterminate; } else { _value = new EvaluationValue(bag, bag.GetType(context)); } return(_value); } else if (_variableDefinition.Expression is pol.AttributeSelectorElement) { // Resolve the XPath query using the EvaluationEngine public methods. context.Trace("Attribute selector"); try { pol.AttributeSelectorElement attributeSelector = (pol.AttributeSelectorElement)_variableDefinition.Expression; BagValue bag = EvaluationEngine.Resolve(context, attributeSelector); if (bag.Elements.Count == 0 && attributeSelector.MustBePresent) { context.Trace("Attribute is missing"); context.IsMissingAttribute = true; context.AddMissingAttribute(attributeSelector); _value = EvaluationValue.Indeterminate; } else { _value = new EvaluationValue(bag, bag.GetType(context)); } } catch (EvaluationException e) { context.Trace("ERR: {0}", e.Message); context.ProcessingError = true; _value = EvaluationValue.Indeterminate; } return(_value); } throw new NotSupportedException("internal error"); } finally { _isEvaluated = true; context.RemoveIndent(); } }
private void CreateAttributeValue( object sender, EventArgs args ) { pol.AttributeValueElementReadWrite attr = new pol.AttributeValueElementReadWrite( InternalDataTypes.XsdString, "TODO: Add content", XacmlVersion.Version11 ); AttributeValue node = new AttributeValue( attr ); tvwCondition.Nodes.Add( node ); _condition.Arguments.Add( attr ); }
private void CreateAttributeValueFromFunction( object sender, EventArgs args ) { FunctionExecution func = (FunctionExecution)tvwCondition.SelectedNode; pol.ApplyBaseReadWrite parentApply = func.ApplyBaseDefinition; pol.AttributeValueElementReadWrite attr = new pol.AttributeValueElementReadWrite( InternalDataTypes.XsdString, "TODO: Add content", XacmlVersion.Version11 ); AttributeValue node = new AttributeValue( attr ); func.Nodes.Add( node ); parentApply.Arguments.Add( attr ); }
/// <summary> /// Creates an instance of the TargetMatchBase class using the XmlReader specified, the name of the node that defines /// the match (the name of the node changes depending on the target item that defines it) and the attribute /// designator node name which also changes depending on the target item that defines the match. /// </summary> /// <param name="reader">The XmlReader positioned at the "matchNodeName" node.</param> /// <param name="matchNodeName">The name of the match node for this target item.</param> /// <param name="attributeDesignatorNode">The name of the attribute designator node for this target item.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBaseReadWrite( XmlReader reader, string matchNodeName, string attributeDesignatorNode, XacmlVersion schemaVersion ) : base( XacmlSchema.Policy, schemaVersion ) { if (reader == null) throw new ArgumentNullException("reader"); if( reader.LocalName == matchNodeName && ValidateSchema( reader, schemaVersion ) ) { _id = reader.GetAttribute( MatchElement.MatchId ); while( reader.Read() ) { if( reader.LocalName == PolicySchema1.AttributeValueElement.AttributeValue && ValidateSchema( reader, schemaVersion ) && reader.NodeType != XmlNodeType.EndElement ) { _attributeValue = new AttributeValueElementReadWrite( reader, schemaVersion ); } else if( reader.LocalName == attributeDesignatorNode && ValidateSchema( reader, schemaVersion ) && reader.NodeType != XmlNodeType.EndElement ) { _attributeReference = CreateAttributeDesignator( reader ); } else if( reader.LocalName == PolicySchema1.AttributeSelectorElement.AttributeSelector && ValidateSchema( reader, schemaVersion ) && reader.NodeType != XmlNodeType.EndElement ) { _attributeReference = new AttributeSelectorElement( reader, schemaVersion ); } else if( reader.LocalName == matchNodeName && reader.NodeType == XmlNodeType.EndElement ) { break; } } } else { throw new Exception( Resource.ResourceManager[ Resource.MessageKey.exc_invalid_node_name, reader.LocalName ] ); } }
/// <summary> /// Creates an instance of a TargetMatchBase with the values specified. /// </summary> /// <param name="matchId">The match id</param> /// <param name="attributeValue">The attribute value instance.</param> /// <param name="attributeReference">An attribute reference instance.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBase(string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion schemaVersion) : base(matchId, attributeValue, attributeReference, schemaVersion) { }
/// <summary> /// Creates an instance of the EnvironmentMatch class using the specified arguments. /// </summary> /// <param name="matchId">The function id for this match.</param> /// <param name="attributeValue">The attribute value to use as the first parameter to the function.</param> /// <param name="attributeReference">The attribute reference in the context document.</param> /// <param name="version">The version of the schema that was used to validate.</param> public EnvironmentMatchElementReadWrite( string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion version ) : base( matchId, attributeValue, attributeReference, version ) { }
/// <summary> /// /// </summary> /// <param name="attributeValue"></param> public AttributeValue( pol.AttributeValueElementReadWrite attributeValue ) { _attributeValue = attributeValue; this.Text = "[" + attributeValue.DataType + "] " + attributeValue.Contents; }
/// <summary> /// Creates an instance of the EnvironmentMatch class using the specified arguments. /// </summary> /// <param name="matchId">The function id for this match.</param> /// <param name="attributeValue">The attribute value to use as the first parameter to the function.</param> /// <param name="attributeReference">The attribute reference in the context document.</param> /// <param name="version">The version of the schema that was used to validate.</param> public EnvironmentMatchElement(string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion version) : base(matchId, attributeValue, attributeReference, version) { }
/// <summary> /// Creates an instance of a TargetMatchBase with the values specified. /// </summary> /// <param name="matchId">The match id</param> /// <param name="attributeValue">The attribute value instance.</param> /// <param name="attributeReference">An attribute reference instance.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> protected TargetMatchBase( string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion schemaVersion ) : base( matchId, attributeValue, attributeReference, schemaVersion ) { }
/// <summary> /// Creates an instance of the ResourceMatch class using the specified arguments. /// </summary> /// <param name="matchId">The function id for this match.</param> /// <param name="attributeValue">The attribute value to use as the first parameter to the function.</param> /// <param name="attributeReference">The attribute reference in the context document.</param> /// <param name="version">The version of the schema that was used to validate.</param> public ResourceMatchElement( string matchId, AttributeValueElementReadWrite attributeValue, AttributeReferenceBase attributeReference, XacmlVersion version ) : base( matchId, attributeValue, attributeReference, version ) { }
/// <summary> /// /// </summary> /// <param name="attributeValue"></param> public AttributeValue(pol.AttributeValueElementReadWrite attributeValue) { _attributeValue = attributeValue; this.Text = "[" + attributeValue.DataType + "] " + attributeValue.Contents; }