private string GetXmlFragmentForLocation(string location)
{
var xpathToGetAllIIisConfigurationByLocation = string.Format("//*[@Location = \"{0}\"]", location);
var allIisProperties = new XPathOperator().applyXpath(MetabaseFileContent, xpathToGetAllIIisConfigurationByLocation, true);
return(string.Join(Environment.NewLine, allIisProperties));
}
private static bool Compare(XPathOperator xPathOperator, object left, object right)
{
if (!(left is IComparable comparable))
{
throw new Exception($"Cannot evaluate {xPathOperator} operator, value on the left side does not implement IComparable interface.");
}
var result = comparable.CompareTo(right);
switch (xPathOperator)
{
case XPathOperator.Eq:
return(result == 0);
case XPathOperator.Ge:
return(result > 0 || result == 0);
case XPathOperator.Gt:
return(result > 0);
case XPathOperator.Le:
return(result < 0 || result == 0);
case XPathOperator.Lt:
return(result < 0);
case XPathOperator.Ne:
return(result != 0);
}
throw new NotImplementedException("Unknown operator " + xPathOperator);
}
private string ToOperatorMethodName(XPathOperator xPathOperator)
{
switch (xPathOperator)
{
case XPathOperator.Divide:
return("op_Division");
case XPathOperator.Minus:
return("op_Subtraction");
case XPathOperator.Modulo:
return("op_Modulus");
case XPathOperator.Multiply:
return("op_Multiply");
case XPathOperator.Plus:
return("op_Addition");
case XPathOperator.UnaryMinus:
return("op_UnaryNegation");
}
return(null);
}
private MetabaseSessionConfiguration GetMetabasePropertyFromMBSchema(string id)
{
var xpathExpression = string.Format("//*[@ID='{0}']", id);
try
{
var propertyNode = new XPathOperator().applyXpath(XmlMBSchema, xpathExpression, true).FirstOrDefault();
if (!string.IsNullOrEmpty(propertyNode))
{
var name = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "InternalName", true);
var type = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Type", true);
var userType = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "UserType", true);
return(new MetabaseSessionConfiguration(name, id, type, userType));
}
return(null);
}
catch (XPathNoResultException)
{
try
{
var propertyNode = new XPathOperator().applyXpath(XmlMetabaseContent, xpathExpression, true).FirstOrDefault();
var name = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Name", false);
var type = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Type", false);
var userType = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "UserType", false);
return(new MetabaseSessionConfiguration(name, id, type, userType));
}
catch (XPathNoResultException)
{
return(null);
}
}
}
private string TryToGetAttributeValueFromMetabaseFragment(string metabaseXmlFragment, string attributeName, bool retryToGetValue)
{
var xPathOperator = new XPathOperator();
try
{
var xpathExpression = string.Format("//*/@{0}", attributeName);
return(xPathOperator.applyXpath(metabaseXmlFragment, xpathExpression).FirstOrDefault());
}
catch (XPathNoResultException)
{
try
{
if (retryToGetValue)
{
return(xPathOperator.applyXpath(metabaseXmlFragment, "//*/@Value").FirstOrDefault());
}
return(null);
}
catch (XPathNoResultException)
{
return(null);
}
}
}
public XPathPredicate(string left, XPathOperator op, string right)
{
this.Left = left;
this.Operator = op;
this.Right = Regex.Replace(right, @"^'|'$", "");
this.RightFormatted = right;
}
public virtual QilNode Operator(XPathOperator op, QilNode?left, QilNode?right)
{
Debug.Assert(op != XPathOperator.Unknown);
XPathOperatorGroup opGroup = s_operatorGroup[(int)op];
Debug.Assert((opGroup != XPathOperatorGroup.Negate && right != null) || (opGroup == XPathOperatorGroup.Negate && right == null));
switch (opGroup)
{
case XPathOperatorGroup.Logical: return(LogicalOperator(op, left !, right !));
case XPathOperatorGroup.Equality: return(EqualityOperator(op, left !, right !));
case XPathOperatorGroup.Relational: return(RelationalOperator(op, left !, right !));
case XPathOperatorGroup.Arithmetic: return(ArithmeticOperator(op, left !, right !));
case XPathOperatorGroup.Negate: return(NegateOperator(op, left !));
case XPathOperatorGroup.Union: return(UnionOperator(op, left, right !));
default:
Debug.Fail($"{op} is not a valid XPathOperator");
return(null);
}
}
private QilNode CompareValues(XPathOperator op, QilNode left, QilNode right, XmlTypeCode compType)
{
Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String);
Debug.Assert(compType == XmlTypeCode.Boolean || left.XmlType.IsSingleton && right.XmlType.IsSingleton, "Both comparison operands must be singletons");
left = _f.ConvertToType(compType, left);
right = _f.ConvertToType(compType, right);
switch (op)
{
case XPathOperator.Eq: return(_f.Eq(left, right));
case XPathOperator.Ne: return(_f.Ne(left, right));
case XPathOperator.Lt: return(_f.Lt(left, right));
case XPathOperator.Le: return(_f.Le(left, right));
case XPathOperator.Gt: return(_f.Gt(left, right));
case XPathOperator.Ge: return(_f.Ge(left, right));
default:
Debug.Fail("Wrong operator type");
return(null);
}
}
private QilNode EqualityOperator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Eq || op == XPathOperator.Ne);
XmlQueryType leftType = left.XmlType;
XmlQueryType rightType = right.XmlType;
if (_f.IsAnyType(left) || _f.IsAnyType(right))
{
return(_f.InvokeEqualityOperator(s_qilOperator[(int)op], left, right));
}
else if (leftType.IsNode && rightType.IsNode)
{
return(CompareNodeSetAndNodeSet(op, left, right, XmlTypeCode.String));
}
else if (leftType.IsNode)
{
return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*val:*/ right, rightType.TypeCode));
}
else if (rightType.IsNode)
{
return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*val:*/ left, leftType.TypeCode));
}
else
{
XmlTypeCode compType = (
leftType.TypeCode == XmlTypeCode.Boolean || rightType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean :
leftType.TypeCode == XmlTypeCode.Double || rightType.TypeCode == XmlTypeCode.Double ? XmlTypeCode.Double :
/*default:*/ XmlTypeCode.String
);
return(CompareValues(op, left, right, compType));
}
}
private QilNode RelationalOperator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Lt || op == XPathOperator.Le || op == XPathOperator.Gt || op == XPathOperator.Ge);
XmlQueryType leftType = left.XmlType;
XmlQueryType rightType = right.XmlType;
if (_f.IsAnyType(left) || _f.IsAnyType(right))
{
return(_f.InvokeRelationalOperator(s_qilOperator[(int)op], left, right));
}
else if (leftType.IsNode && rightType.IsNode)
{
return(CompareNodeSetAndNodeSet(op, left, right, XmlTypeCode.Double));
}
else if (leftType.IsNode)
{
XmlTypeCode compType = rightType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean : XmlTypeCode.Double;
return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*val:*/ right, compType));
}
else if (rightType.IsNode)
{
XmlTypeCode compType = leftType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean : XmlTypeCode.Double;
op = InvertOp(op);
return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*val:*/ left, compType));
}
else
{
return(CompareValues(op, left, right, XmlTypeCode.Double));
}
}
public XPathPredicate(IXPathOperand left, XPathOperator op, IXPathOperand right)
{
this.Left = left;
this.Operator = op;
this.Right = right;
this.RightFormatted = right.ToString();
}
public XElement Operator(XPathOperator op, XElement left, XElement right)
{
if (op == XPathOperator.UnaryMinus)
{
return(new XElement("negate", left));
}
return(new XElement(op.ToString(), left, right));
}
private QilNode CompareNodeSetAndValue(XPathOperator op, QilNode nodeset, QilNode val, XmlTypeCode compType)
{
_f.CheckNodeSet(nodeset);
Debug.Assert(val.XmlType !.IsSingleton);
Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String, "I don't know what to do with RTF here");
if (compType == XmlTypeCode.Boolean || nodeset.XmlType !.IsSingleton)
{
return(CompareValues(op, nodeset, val, compType));
}
public string Operator(XPathOperator op, string left, string right)
{
Debug.Assert(op != XPathOperator.Union);
if (op == XPathOperator.UnaryMinus)
{
return("-" + left);
}
return(left + opStrings[(int)op] + right);
}
public static string GetOperatorString(XPathOperator op)
{
switch (op)
{
case XPathOperator.Eq:
return("=");
}
throw new Exception("Unhandled XPathOperator");
}
private QilNode LogicalOperator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Or || op == XPathOperator.And);
left = _f.ConvertToBoolean(left);
right = _f.ConvertToBoolean(right);
return(
op == XPathOperator.Or ? _f.Or(left, right) :
/*default*/ _f.And(left, right)
);
}
// Inverts relational operator in order to swap operands of the comparison
private static XPathOperator InvertOp(XPathOperator op)
{
return(
op == XPathOperator.Lt ? XPathOperator.Gt : // '<' --> '>'
op == XPathOperator.Le ? XPathOperator.Ge : // '<=' --> '>='
op == XPathOperator.Gt ? XPathOperator.Lt : // '>' --> '<'
op == XPathOperator.Ge ? XPathOperator.Le : // '>=' --> '<='
/*default:*/ op
);
}
/*
* EqualityExpr ::= RelationalExpr (('=' | '!=') RelationalExpr)*
*/
private Node ParseEqualityExpr()
{
Node opnd = ParseRelationalExpr();
bool eq;
while ((eq = scanner.Kind == LexKind.Eq) || scanner.Kind == LexKind.Ne)
{
XPathOperator op = eq ? XPathOperator.Eq : XPathOperator.Ne;
scanner.NextLex();
opnd = builder.Operator(op, opnd, ParseRelationalExpr());
}
return(opnd);
}
/*
* AdditiveExpr ::= MultiplicativeExpr (('+' | '-') MultiplicativeExpr)*
*/
private Node ParseAdditiveExpr()
{
Node opnd = ParseMultiplicativeExpr();
bool plus;
while ((plus = scanner.Kind == LexKind.Plus) || scanner.Kind == LexKind.Minus)
{
XPathOperator op = plus ? XPathOperator.Plus : XPathOperator.Minus;
scanner.NextLex();
opnd = builder.Operator(op, opnd, ParseMultiplicativeExpr());
}
return(opnd);
}
public QilNode Operator(XPathOperator op, QilNode left, QilNode right) {
Debug.Assert(op == XPathOperator.Union);
Debug.Assert(left != null);
Debug.Assert(right != null);
// It is important to not create nested lists here
Debug.Assert(right.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter");
if (left.NodeType == QilNodeType.Sequence) {
((QilList)left).Add(right);
return left;
} else {
Debug.Assert(left.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter");
return f.Sequence(left, right);
}
}
private QilNode CompareNodeSetAndValue(XPathOperator op, QilNode nodeset, QilNode val, XmlTypeCode compType)
{
_f.CheckNodeSet(nodeset);
Debug.Assert(val.XmlType.IsSingleton);
Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String, "I don't know what to do with RTF here");
if (compType == XmlTypeCode.Boolean || nodeset.XmlType.IsSingleton)
{
return(CompareValues(op, nodeset, val, compType));
}
else
{
QilIterator it = _f.For(nodeset);
return(_f.Not(_f.IsEmpty(_f.Filter(it, CompareValues(op, _f.XPathNodeValue(it), val, compType)))));
}
}
public object Operator(XPathOperator op, object left, object right)
{
switch (op)
{
case XPathOperator.Eq:
return(EqOperator(left, right));
case XPathOperator.And:
return(AndOperator(left, right));
case XPathOperator.Or:
return(OrOperator(left, right));
}
throw new NotSupportedException($"Operator {op.ToString()} is not supported.");
}
public object Operator(XPathOperator op, object left, object right)
{
if (op == XPathOperator.Eq)
{
if (left is AutomationProperty property)
{
return(new CompareFunc((elem, index) =>
{
var propValue = elem.GetCurrentPropertyValue(property, true);
if (propValue != null)
{
return propValue.Equals(right);
}
return false;
}));
}
else if (left is UiAutomationElement en)
{
if (UiAutomationElement.ProgrammaticName == en)
{
return(new CompareFunc((elem, index) =>
{
string propValue = elem.Current.ControlType?.ProgrammaticName.Replace("ControlType.", "");
if (propValue != null)
{
return propValue.Equals(right);
}
return false;
}));
}
if (UiAutomationElement.Id == en)
{
return(new CompareFunc((elem, index) =>
{
int?propValue = elem.Current.ControlType?.Id;
if (propValue.HasValue)
{
return propValue.ToString().Equals(right);
}
return false;
}));
}
}
}
throw new NotSupportedException($"Operator {op.ToString()} is not supported.");
}
public QilNode Operator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Union);
Debug.Assert(left != null);
Debug.Assert(right != null);
// It is important to not create nested lists here
Debug.Assert(right.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter");
if (left.NodeType == QilNodeType.Sequence)
{
((QilList)left).Add(right);
return(left);
}
else
{
Debug.Assert(left.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter");
return(_f.Sequence(left, right));
}
}
private QilNode CompareNodeSetAndNodeSet(XPathOperator op, QilNode left, QilNode right, XmlTypeCode compType)
{
_f.CheckNodeSet(left);
_f.CheckNodeSet(right);
if (right.XmlType.IsSingleton)
{
return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*value:*/ right, compType));
}
if (left.XmlType.IsSingleton)
{
op = InvertOp(op);
return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*value:*/ left, compType));
}
QilIterator leftEnd = _f.For(left);
QilIterator rightEnd = _f.For(right);
return(_f.Not(_f.IsEmpty(_f.Loop(leftEnd, _f.Filter(rightEnd, CompareValues(op, _f.XPathNodeValue(leftEnd), _f.XPathNodeValue(rightEnd), compType))))));
}
public string Operator(XPathOperator op, string left, string right)
{
Debug.Assert(op != XPathOperator.Union);
if (op == XPathOperator.UnaryMinus)
{
return("-" + left);
}
if (left.StartsWith("attribute::"))
{
left = left.Remove(0, "attribute::".Length);
}
lastPredicate = new XPathPredicate(left, op, right);
return(left + opStrings[(int)op] + right);
}
private QilNode UnionOperator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Union);
if (left == null)
{
return(_f.EnsureNodeSet(right));
}
left = _f.EnsureNodeSet(left);
right = _f.EnsureNodeSet(right);
if (left.NodeType == QilNodeType.Sequence)
{
((QilList)left).Add(right);
return(left);
}
else
{
return(_f.Union(left, right));
}
}
QilNode UnionOperator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op == XPathOperator.Union);
if (left == null)
{
return(f.EnsureNodeSet(right));
}
left = f.EnsureNodeSet(left);
right = f.EnsureNodeSet(right);
if (left.NodeType == QilNodeType.Sequence)
{
// ToDo: drop this logic or move it to QilPatternFactory.Union()
((QilList)left).Add(right);
return(left);
}
else
{
return(f.Union(left, right));
}
}
private QilNode ArithmeticOperator(XPathOperator op, QilNode left, QilNode right)
{
left = _f.ConvertToNumber(left);
right = _f.ConvertToNumber(right);
switch (op)
{
case XPathOperator.Plus: return(_f.Add(left, right));
case XPathOperator.Minus: return(_f.Subtract(left, right));
case XPathOperator.Multiply: return(_f.Multiply(left, right));
case XPathOperator.Divide: return(_f.Divide(left, right));
case XPathOperator.Modulo: return(_f.Modulo(left, right));
default:
Debug.Fail("Wrong operator type");
return(null);
}
}
public virtual QilNode Operator(XPathOperator op, QilNode left, QilNode right)
{
Debug.Assert(op != XPathOperator.Unknown);
switch (s_operatorGroup[(int)op])
{
case XPathOperatorGroup.Logical: return(LogicalOperator(op, left, right));
case XPathOperatorGroup.Equality: return(EqualityOperator(op, left, right));
case XPathOperatorGroup.Relational: return(RelationalOperator(op, left, right));
case XPathOperatorGroup.Arithmetic: return(ArithmeticOperator(op, left, right));
case XPathOperatorGroup.Negate: return(NegateOperator(op, left, right));
case XPathOperatorGroup.Union: return(UnionOperator(op, left, right));
default:
Debug.Fail(op + " is not a valid XPathOperator");
return(null);
}
}
private void CheckFlaggedProperties(MetabaseSessionConfiguration metabaseSession)
{
if (string.IsNullOrWhiteSpace(metabaseSession.Value))
{
return;
}
if (this.IsFlaggedProperty(metabaseSession))
{
int propertyValue = 0;
var flags = metabaseSession.Value.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var flag in flags)
{
var xPathFlagNode = string.Format("//*[@InternalName='{0}']", flag.Trim());
var flagNode = new XPathOperator().applyXpath(this.XmlMBSchema, xPathFlagNode, true);
var flagValue = int.Parse(new XPathOperator().applyXpath(flagNode.First(), "//*/@Value", false).First());
propertyValue += flagValue;
}
metabaseSession.Value = propertyValue.ToString();
}
}
