public static string Execute540(string vri, INodesCollection mf)
{
var lmap = new List <(string, string)>();
foreach (var kv in map)
{
lmap.Add((kv.Key.Substring(0, kv.Key.Length - 2), kv.Value));
}
var pattern = @"\d+[.]\d+([.]\d+)?([.]\d+)?";
var matches = Regex.Matches(vri, pattern).Cast <Match>().Select(p => p.Value);
var result = "";
foreach (var match in matches)
{
foreach (var val in lmap)
{
if (match.Equals(val.Item1))
{
result += result.Length == 0? val.Item2 : ", " + val.Item2;
}
}
}
Codes codes = new Codes(mf);
codes.AddNodes(result);
codes.Sort();
codes.Distinct();
return(codes.Show);
}
public INodesCollection Transform(INodesCollection nodes)
{
var newNodes = new NodesCollection();
var boolType = typeof (bool);
for (var i = 0; i < nodes.Count; i++)
{
var memberNode = nodes[i] as MemberNode;
if(memberNode == null || memberNode.MemberType != boolType)
{
newNodes.AddNode(nodes[i]);
continue;
}
var firstNextNode = nodes.GetItemOrNullByIndex(i + 1) as OperatorNode;
var secondNextNode = nodes.GetItemOrNullByIndex(i + 2) as ValueNode;
var memberNodeIsPartOfCompleteBoolExpression =
firstNextNode != null &&
secondNextNode != null &&
secondNextNode.Value is bool;
if (memberNodeIsPartOfCompleteBoolExpression)
newNodes.AddNode(memberNode);
else
newNodes.AddNodes(memberNode, new OperatorNode(Operator.Equal()), new ValueNode(true));
}
return newNodes;
}
public static string Execute(string vri, int type, INodesCollection mf)
{
var pattern = @"\d+[.]\d+([.]\d+)?([.]\d+)?";
var matches = Regex.Matches(vri, pattern).Cast <Match>().Select(p => p.Value);
Codes codes = new Codes(mf);
foreach (var match in matches)
{
if (map.ContainsKey(match))
{
if (match.Equals("12.0.1") && type == 500)
{
codes.AddNodes(match);
}
else if (match.Equals("12.0.2") && type == 400)
{
codes.AddNodes(match);
}
else
{
codes.AddNodes(map[match]);
}
}
else
{
codes.AddNodes(match);
}
}
codes.Sort();
codes.Distinct();
return(codes.Show);
}
public CodeSeeker(string Input, ICodes codes, INodesCollection mf)
{
input = BullshitCleaner(Input);
_matches = new StringBuilder("");
Codes = codes;
this.mf = mf;
IsFederalSearch = false;
IsPZZSearch = false;
IsMainSearch = false;
}
public virtual INode[] Transform(int maxIndex, ref int index, INode node, INodesCollection orgNodes)
{
var nullableNode = node as NullableMemberNode;
if (nullableNode == null || !nullableNode.IsForHasValueCheck)
{
return new[] { node }
}
;
if (index == maxIndex)
{
return new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() }
}
;
var rightOperator = orgNodes.GetItemOrNullByIndex(index + 1) as OperatorNode;
var rightValue = orgNodes.GetItemOrNullByIndex(index + 2) as ValueNode;
if (rightOperator == null || rightValue == null)
{
return new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() }
}
;
var operatorType = rightOperator.Operator.OperatorType;
var hasValueIs = (bool)rightValue.Value;
var shouldBeIsNotNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs) ||
(operatorType == Operator.Types.NotEqual && hasValueIs == false);
var shouldBeIsNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs == false) ||
(operatorType == Operator.Types.Equal && hasValueIs == false);
if (shouldBeIsNotNullNodes)
{
index += 2;
return(new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() });
}
if (shouldBeIsNullNodes)
{
index += 2;
return(new INode[] { nullableNode, new OperatorNode(Operator.Is()), new NullNode() });
}
return(new[] { node });
}
}
}
public IParsedLambda Parse(LambdaExpression e)
{
if (e.Body.NodeType == ExpressionType.MemberAccess && e.Body.Type != typeof(bool))
throw new SisoDbException(ExceptionMessages.WhereExpressionParser_NoMemberExpressions);
lock (_lock)
{
_nodes = new NodesCollection();
Visit(e);
return CreateParsedLambda();
}
}
public virtual IParsedLambda Parse(LambdaExpression e)
{
if (e.Body.NodeType == ExpressionType.MemberAccess && !e.Body.Type.IsBoolType())
{
throw new SisoDbException(ExceptionMessages.WhereExpressionParser_NoMemberExpressions);
}
lock (_lock)
{
Nodes = new NodesCollection();
Visit(e);
return(CreateParsedLambda());
}
}
public virtual INode[] Transform(int maxIndex, ref int index, INode node, INodesCollection orgNodes)
{
var memberNode = node as MemberNode;
if (memberNode == null || !memberNode.DataType.IsBoolType())
return new[] { node };
var firstNextNode = orgNodes.GetItemOrNullByIndex(index + 1) as OperatorNode;
var secondNextNode = orgNodes.GetItemOrNullByIndex(index + 2) as ValueNode;
var memberNodeIsPartOfCompleteBoolExpression =
firstNextNode != null &&
secondNextNode != null &&
secondNextNode.Value is bool;
return memberNodeIsPartOfCompleteBoolExpression
? new[] { memberNode }
: new INode[] { memberNode, new OperatorNode(Operator.Equal()), new ValueNode(true) };
}
public virtual INode[] Transform(int maxIndex, ref int index, INode node, INodesCollection orgNodes)
{
var nullableNode = node as NullableMemberNode;
if (nullableNode == null || !nullableNode.IsForHasValueCheck)
return new[] { node };
if (index == maxIndex)
return new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() };
var rightOperator = orgNodes.GetItemOrNullByIndex(index + 1) as OperatorNode;
var rightValue = orgNodes.GetItemOrNullByIndex(index + 2) as ValueNode;
if (rightOperator == null || rightValue == null)
return new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() };
var operatorType = rightOperator.Operator.OperatorType;
var hasValueIs = (bool)rightValue.Value;
var shouldBeIsNotNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs)
|| (operatorType == Operator.Types.NotEqual && hasValueIs == false);
var shouldBeIsNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs == false)
|| (operatorType == Operator.Types.Equal && hasValueIs == false);
if (shouldBeIsNotNullNodes)
{
index += 2;
return new INode[] { nullableNode, new OperatorNode(Operator.IsNot()), new NullNode() };
}
if (shouldBeIsNullNodes)
{
index += 2;
return new INode[] { nullableNode, new OperatorNode(Operator.Is()), new NullNode() };
}
return new[] { node };
}
public virtual INode[] Transform(int maxIndex, ref int index, INode node, INodesCollection orgNodes)
{
var memberNode = node as MemberNode;
if (memberNode == null || !memberNode.DataType.IsBoolType())
{
return new[] { node }
}
;
var firstNextNode = orgNodes.GetItemOrNullByIndex(index + 1) as OperatorNode;
var secondNextNode = orgNodes.GetItemOrNullByIndex(index + 2) as ValueNode;
var memberNodeIsPartOfCompleteBoolExpression =
firstNextNode != null &&
secondNextNode != null &&
secondNextNode.Value is bool;
return(memberNodeIsPartOfCompleteBoolExpression
? new[] { memberNode }
: new INode[] { memberNode, new OperatorNode(Operator.Equal()), new ValueNode(true) });
}
}
public Codes(INodesCollection mf)
{
this.mf = mf;
Nodes = new List <INode>();
}
public INodesCollection Transform(INodesCollection nodes)
{
if (!nodes.OfType<NullableMemberNode>().Any(n => n.IsForHasValueCheck))
return nodes;
var maxIndex = nodes.Count - 1;
var newNodes = new NodesCollection();
for (var i = 0; i < nodes.Count; i++)
{
var nullableNode = nodes[i] as NullableMemberNode;
if (nullableNode == null || !nullableNode.IsForHasValueCheck)
{
newNodes.AddNode(nodes[i]);
continue;
}
if (i == maxIndex)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
continue;
}
var rightOperator = nodes[i + 1] as OperatorNode;
var rightValue = nodes[i + 2] as ValueNode;
if (rightOperator == null || rightValue == null)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
continue;
}
var operatorType = rightOperator.Operator.OperatorType;
var hasValueIs = (bool)rightValue.Value;
var shouldBeIsNotNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs)
|| (operatorType == Operator.Types.NotEqual && hasValueIs == false);
var shouldBeIsNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs == false)
|| (operatorType == Operator.Types.Equal && hasValueIs == false);
if (shouldBeIsNotNullNodes)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
i += 2;
continue;
}
if (shouldBeIsNullNodes)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.Is()), new NullNode());
i += 2;
continue;
}
}
return newNodes;
}
