Comment analyser le filtre OData $ avec une expression régulière en C #?

Salut, je me demandais quelle est la meilleure approche serait d'analyser un OData $chaîne de filtre en C#, par exemple

/API/organisations?$filtre="nom eq 'Facebook' ou le nom de l'égaliseur Twitter et abonnés gt '30'"

Doit retourner toutes les organisations avec un nom de Facebook ou Twitter et qui ont plus de 30 abonnés. J'ai recherché un peu, mais ne peut pas trouver des solutions qui ne tourne pas autour de la WCF. Je pensais à l'aide de Regex et en les regroupant j'ai donc une liste
des classes de Filtre tels que:

Filter
    Resource: Name
    Operator: Eq
    Value: Facebook
Filter
    Resource: Name
    Operator: Eq
    Value: Twitter
Filter
    Resource: Subscribers
    Operator: gt
    Value: 30

mais je suis perplexe, comme comment gérer Padn /ORs.

source d'informationauteur Nick Spicer

c#odata regex

Vérifier cette regex avec les drapeaux je et x.

(?<Filter>
 (?<Resource>.+?)\s+
 (?<Operator>eq|ne|gt|ge|lt|le|add|sub|mul|div|mod)\s+
 '?(?<Value>.+?)'?
)
(?:
    \s*$
   |\s+(?:or|and|not)\s+
)

Démo

http://regexhero.net/tester/?id=0a26931f-aaa3-4fa0-9fc9-1a67d34c16b3

Exemple de code

string strRegex = @"(?<Filter>" + 
"\n" + @"     (?<Resource>.+?)\s+" + 
"\n" + @"     (?<Operator>eq|ne|gt|ge|lt|le|add|sub|mul|div|mod)\s+" + 
"\n" + @"     '?(?<Value>.+?)'?" + 
"\n" + @")" + 
"\n" + @"(?:" + 
"\n" + @"    \s*$" + 
"\n" + @"   |\s+(?:or|and|not)\s+" + 
"\n" + @")" + 
"\n";
Regex myRegex = new Regex(strRegex, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
string strTargetString = @"name eq 'Facebook' or name eq 'Twitter' and subscribers gt '30'";
string strReplace = @"Filter >> ${Filter}" + "\n" + @"   Resource : ${Resource}" + "\n" + @"   Operator : ${Operator}" + "\n" + @"   Value    : ${Value}" + "\n\n";

return myRegex.Replace(strTargetString, strReplace);

De sortie

Filter >> name eq 'Facebook'
   Resource : name
   Operator : eq
   Value    : Facebook

Filter >> name eq 'Twitter'
   Resource : name
   Operator : eq
   Value    : Twitter

Filter >> subscribers gt '30'
   Resource : subscribers
   Operator : gt
   Value    : 30

Discussion

Afin d'avoir des majuscules pour des ressources et de l'opérateur, l'utilisation d'un MatchEvaluator.
Le regroupement avec ( et ) ne sont pas pris en charge. Laisser un commentaire si vous voulez que la regex pour le soutenir.

12

.NET, il y a une librairie qui va le faire pour vous. La rédaction de votre propre regex risque de rater certains cas limites.

À l'aide de NuGet, apporter de Microsoft.Les données.OData. Ensuite, vous pouvez faire:
```
using Microsoft.Data.OData.Query;

var result = ODataUriParser.ParseFilter(
  "name eq 'Facebook' or name eq 'Twitter' and subscribers gt 30",
  model,
  type);
```
result ici sera sous la forme d'un AST représentant la clause de filtre.

(Pour obtenir le model et type entrées, vous pouvez analyser votre $fichier de métadonnées en utilisant quelque chose comme ceci:
```
using Microsoft.Data.Edm;
using Microsoft.Data.Edm.Csdl;

IEdmModel model = EdmxReader.Parse(new XmlTextReader(/*stream of your $metadata file*/));
IEdmEntityType type = model.FindType("organisation");
```
)

Appuyant sur ce que Jen S dit, vous pouvez parcourir les AST de l'arbre qui est retourné par la FilterClause.

Par exemple, vous pouvez récupérer le FilterClause à partir du contrôleur d'options de requête:

public IQueryable<ModelObject> GetModelObjects(ODataQueryOptions<ModelObject> queryOptions)        
    {
        var filterClause = queryOptions.Filter.FilterClause;

Vous pouvez alors parcourir la résultante de l'AST de l'arbre avec le code suivant (emprunté à cet article):

var values = new Dictionary<string, object>();
TryNodeValue(queryOptions.Filter.FilterClause.Expression, values);

La fonction appelée est comme suit:

public void TryNodeValue(SingleValueNode node, IDictionary<string, object> values)
{
if (node is BinaryOperatorNode )
{
var bon = (BinaryOperatorNode)node;
var left = bon.Left;
var right = bon.Right;
if (left is ConvertNode)
{
var convLeft = ((ConvertNode)left).Source;
if (convLeft is SingleValuePropertyAccessNode && right is ConstantNode)
ProcessConvertNode((SingleValuePropertyAccessNode)convLeft, right, bon.OperatorKind, values);
else
TryNodeValue(((ConvertNode)left).Source, values);                    
}
if (left is BinaryOperatorNode)
{
TryNodeValue(left, values);
}
if (right is BinaryOperatorNode)
{
TryNodeValue(right, values);
}
if (right is ConvertNode)
{
TryNodeValue(((ConvertNode)right).Source, values);                  
}
if (left is SingleValuePropertyAccessNode && right is ConstantNode)
{
ProcessConvertNode((SingleValuePropertyAccessNode)left, right, bon.OperatorKind, values);
}
}
}
public void ProcessConvertNode(SingleValuePropertyAccessNode left, SingleValueNode right, BinaryOperatorKind opKind, IDictionary<string, object> values)
{            
if (left is SingleValuePropertyAccessNode && right is ConstantNode)
{
var p = (SingleValuePropertyAccessNode)left;
if (opKind == BinaryOperatorKind.Equal)
{
var value = ((ConstantNode)right).Value;
values.Add(p.Property.Name, value);
}
}
}

Ensuite, vous pouvez aller dans le dictionnaire de la liste et récupérer vos valeurs:

 if (values != null && values.Count() > 0)
{
//iterate through the filters and assign variables as required
foreach (var kvp in values)
{
switch (kvp.Key.ToUpper())
{
case "COL1":
col1 = kvp.Value.ToString();
break;
case "COL2":
col2 = kvp.Value.ToString();
break;
case "COL3":
col3 = Convert.ToInt32(kvp.Value);
break;
default: break;
}
}
}

Cet exemple est assez simpliste qu'il ne représente que "eq" les évaluations, mais pour ma part ça a bien fonctionné. YMMV. 😉

Je pense que vous êtes censé travserse l'AST avec l'interface fournie à l'aide du modèle visiteur.

Considérez que vous avez cette classe qui représente un filtre

public class FilterValue
{
public string ComparisonOperator { get; set; }
public string Value { get; set; }
public string FieldName { get; set; }
public string LogicalOperator { get; set; }
}

Alors, comment pouvons-nous "extrait de" les filtres qui vient avec le OData paramètres de votre classe?

Bien le FilterClause objet ont une Expression qui est un SingleValueNode qui hérite d'une QueryNode. Le QueryNode ont l'Accepter méthode qui prend un QueryNodeVisitor.

    public virtual T Accept<T>(QueryNodeVisitor<T> visitor);

Droit, de sorte que vous devez mettre en place votre propre QueryNodeVisitor et faire de votre stuff. Ci-dessous est un non fini (je n'ai pas de remplacer tous les visiteurs potentiels).

public class MyVisitor<TSource> : QueryNodeVisitor<TSource>
where TSource: class
{ 
List<FilterValue> filterValueList = new List<FilterValue>();
FilterValue current = new FilterValue();
public override TSource Visit(BinaryOperatorNode nodeIn)
{
if(nodeIn.OperatorKind == Microsoft.Data.OData.Query.BinaryOperatorKind.And 
|| nodeIn.OperatorKind == Microsoft.Data.OData.Query.BinaryOperatorKind.Or)
{
current.LogicalOperator = nodeIn.OperatorKind.ToString();
}
else
{
current.ComparisonOperator = nodeIn.OperatorKind.ToString();
}
nodeIn.Right.Accept(this);
nodeIn.Left.Accept(this);
return null;
}
public override TSource Visit(SingleValuePropertyAccessNode nodeIn)
{
current.FieldName = nodeIn.Property.Name;
//We are finished, add current to collection.
filterValueList.Add(current);
//Reset current
current = new FilterValue();
return null;
}
public override TSource Visit(ConstantNode nodeIn)
{
current.Value = nodeIn.LiteralText;
return null;
}
}

Puis, le feu de suite 🙂

MyVisitor<object> visitor = new MyVisitor<object>();
options.Filter.FilterClause.Expression.Accept(visitor);

Quand il a parcouru l'arborescence de votre

visitor.filterValueList

doit contenir les filtres dans le format désiré. Je suis sûr que plus de travail est nécessaire, mais si vous pouvez l'obtenir de roulement, je pense que vous pouvez comprendre.

Vous devez vous connecter pour publier un commentaire.