public void Parse_should_exclude_empty_string_literals()
{
Expression expr;
ExpressionUtility.TryParse("${name}", out expr);
Assert.Equal(ExpressionType.Name, expr.ExpressionType);
}
/// Execute the creation of the parameter "facet.field"
/// </summary>
/// <param name="container">Container to parameters to request to SOLR</param>
public void Execute(List <string> container)
{
if (!container.Contains("facet=true"))
{
container.Add("facet=true");
}
var aliasName = this._expressionBuilder.GetPropertyNameFromExpression(this.Expression);
var fieldName = this._expressionBuilder.GetFieldNameFromExpression(this.Expression);
var facetField = this.Excludes.GetSolrFacetWithExcludes(aliasName, fieldName);
container.Add($"facet.field={facetField}");
if (this.SortType.HasValue)
{
string typeName;
string dummy;
Checker.IsTrue <UnsupportedSortTypeException>(this.SortType.Value == FacetSortType.CountDesc || this.SortType.Value == FacetSortType.IndexDesc);
ExpressionUtility.GetSolrFacetSort(this.SortType.Value, out typeName, out dummy);
container.Add($"f.{fieldName}.facet.sort={typeName}");
}
container.Add($"f.{fieldName}.facet.mincount=1");
if (this.Limit.HasValue)
{
container.Add($"f.{fieldName}.facet.limit={this.Limit.Value}");
}
}
public void Parse_should_handle_nominal_expression_syntax()
{
Expression expr;
ExpressionUtility.TryParse("${4 + a}", out expr);
Assert.Equal("4 + a", expr.ToString());
}
/// <summary>
/// Builds the Linq Expression for the provided propertyPath and type properties
/// </summary>
/// <param name="type">Type that exposes the property</param>
/// <param name="propertyPath">Public property. Can be nested.</param>
/// <returns>Resulting property expression</returns>
/// <exception cref="ArgumentException">When property is not found on the specified type.</exception>
public static Expression BuildPropertyExpression(Type type, string propertyPath)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (propertyPath == null)
{
throw new ArgumentNullException("propertyPath");
}
Expression propertyExpression =
ExpressionUtility.GenerateProperty(type, propertyPath, Expression.Parameter(type, string.Empty));
if (propertyExpression == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Resources.PropertyNotFound,
propertyPath,
type.Name));
}
return(propertyExpression);
}
/// <summary>
/// Execute the creation of the parameter "sort"
/// </summary>
/// <param name="container">Container to parameters to request to SOLR</param>
public void Execute(List <string> container)
{
if (!container.Contains("facet=true"))
{
container.Add("facet=true");
}
var query = this.Query.Execute();
container.Add($"facet.query={this.Excludes.GetSolrFacetWithExcludes(this.AliasName, query)}");
if (this.SortType.HasValue)
{
string typeName;
string dummy;
Checker.IsTrue <UnsupportedSortTypeException>(this.SortType.Value == FacetSortType.CountDesc || this.SortType.Value == FacetSortType.IndexDesc);
ExpressionUtility.GetSolrFacetSort(this.SortType.Value, out typeName, out dummy);
container.Add($"f.{this.AliasName}.facet.sort={typeName}");
}
container.Add($"f.{this.AliasName}.facet.mincount=1");
}
// -, !, not unary operators
protected Expression ParseUnary()
{
if (Token.Identity == TokenId.Minus || Token.Identity == TokenId.Exclamation ||
Token.IdentifierIs("not"))
{
Token op = Token;
NextToken();
//if (op.Identity == TokenId.Minus && (Token.Identity == TokenId.IntegerLiteral ||
// Token.Identity == TokenId.RealLiteral))
//{
// Token.Text = "-" + Token.Text;
// Token.Position = op.Position;
// return ParsePrimary();
//}
Expression expr = ParseUnary();
if (op.Identity == TokenId.Minus)
{
ExpressionUtility.CheckAndPromoteOperand(typeof(INegationSignatures), op.Text, ref expr, op.Position);
expr = Expression.Negate(expr);
}
else
{
ExpressionUtility.CheckAndPromoteOperand(typeof(INotSignatures), op.Text, ref expr, op.Position);
expr = Expression.Not(expr);
}
return(expr);
}
return(base.ParseExpression());
}
public void Parse_should_detect_escaped_expression()
{
Expression expr;
ExpressionUtility.TryParse("$${4 + a}", out expr);
Assert.Equal("[ '$', '{4 + a}' ]", expr.ToString());
}
private static object DoMathsOperation(object input, object operand, Func <Expression, Expression, BinaryExpression> operation)
{
return(input == null || operand == null
? null
: ExpressionUtility.CreateExpression(operation, input.GetType(), operand.GetType(), input.GetType(), true)
.DynamicInvoke(input, operand));
}
Expression ParseBetween(Expression expr)
{
NextToken();
//var u = new UnaryExpressionParser(this.exprParser);
//var parser = new UnaryExpressionParser(this.tokenCursor);
var left = ParseUnary();
ExpressionUtility.CheckAndPromoteOperands(typeof(IEqualitySignatures), ">=", ref expr, ref left, Token.Position);
left = ExpressionUtility.GenerateGreaterThanEqual(expr, left);
if (Token.Keyword != Keyword.And)
{
throw Error.TokenExpected(Token, Keyword.And);
}
NextToken();
var right = ParseUnary();
ExpressionUtility.CheckAndPromoteOperands(typeof(IEqualitySignatures), "<=", ref expr, ref right, Token.Position);
right = ExpressionUtility.GenerateLessThanEqual(expr, right);
expr = Expression.And(left, right);
return(expr);
}
/// <summary>
/// Execute creation of the parameter "facet field" using spatial formule
/// </summary>
/// <param name="container">Container to parameters to request to SOLR</param>
public void Execute(List <string> container)
{
Checker.IsNullOrWhiteSpace(this.AliasName);
Checker.IsNull(this.Expression);
if (!container.Contains("facet=true"))
{
container.Add("facet=true");
}
var fieldName = this._expressionBuilder.GetFieldNameFromExpression(this.Expression);
var formule = ExpressionUtility.GetSolrSpatialFormule(this.FunctionType, fieldName, this.CenterPoint, this.Distance);
var facetName = this.Excludes.GetSolrFacetWithExcludes(this.AliasName, formule);
container.Add($"facet.query={facetName}");
if (this.SortType.HasValue)
{
string typeName;
string dummy;
Checker.IsTrue <UnsupportedSortTypeException>(this.SortType.Value == FacetSortType.CountDesc || this.SortType.Value == FacetSortType.IndexDesc);
ExpressionUtility.GetSolrFacetSort(this.SortType.Value, out typeName, out dummy);
container.Add($"f.{this.AliasName}.facet.sort={typeName}");
}
container.Add($"f.{this.AliasName}.facet.mincount=1");
}
Expression ParseMultiplicative()
{
Expression left = ParseUnary();
while (Token.Identity == TokenId.Asterisk || Token.Identity == TokenId.Slash ||
Token.Identity == TokenId.Percent || TokenIdentifierIs("mod"))
{
var op = Token;
NextToken();
Expression right = ParseUnary();
ExpressionUtility.CheckAndPromoteOperands(typeof(IArithmeticSignatures), op.Text, ref left, ref right, op.Position);
if (op.Is(TokenId.Asterisk))
{
left = Expression.Multiply(left, right);
}
else if (op.Is(TokenId.Slash))
{
left = Expression.Divide(left, right);
}
else if (op.Is(TokenId.Percent) || op.Is(TokenId.Identifier))
{
left = Expression.Modulo(left, right);
}
}
return(left);
}
/// <summary>
/// Execute creation of the parameter "facet field" using spatial formule
/// </summary>
/// <param name="jObject">JSON object with parameters to request to SOLR</param>
public void Execute(JObject jObject)
{
var facetObject = (JObject)jObject["facet"] ?? new JObject();
var fieldName = this._expressionBuilder.GetFieldNameFromExpression(this.Expression);
var formule = ExpressionUtility.GetSolrSpatialFormule(
this.FunctionType,
fieldName,
this.CenterPoint,
this.Distance);
var array = new List <JProperty>
{
new JProperty("q", this.Excludes.GetSolrFacetWithExcludes(formule))
};
array.Add(new JProperty("mincount", 1));
if (this.SortType.HasValue)
{
string typeName;
string sortName;
ExpressionUtility.GetSolrFacetSort(this.SortType.Value, out typeName, out sortName);
array.Add(new JProperty("sort", new JObject(new JProperty(typeName, sortName))));
}
var jProperty = new JProperty(this.AliasName, new JObject(new JProperty("query", new JObject(array.ToArray()))));
facetObject.Add(jProperty);
jObject["facet"] = facetObject;
}
private Expression ParseMethodAccess(Expression instance, string methodName, Type type)
{
if (type == null)
{
type = instance.Type;
}
Debug.Assert(instance.Type == type);
Expression[] args = ParseArgumentList();
MethodBase mb;
var errorPos = Token.Position;
var methodsCount = ExpressionUtility.FindMethod(type, methodName, instance == null, args, out mb);
switch (methodsCount)
{
case 0:
throw Error.ParseError(errorPos, Res.NoApplicableMethod, methodName, TypeUtility.GetTypeName(type));
case 1:
MethodInfo method = (MethodInfo)mb;
if (method.ReturnType == typeof(void))
{
throw Error.ParseError(errorPos, Res.MethodIsVoid, methodName, TypeUtility.GetTypeName(method.DeclaringType));
}
return(Expression.Call(instance, (MethodInfo)method, args));
default:
throw Error.ParseError(errorPos, Res.AmbiguousMethodInvocation, methodName, TypeUtility.GetTypeName(type));
}
}
private Expression ParseStaticMemberAccess(Type type, string methodName,
Expression[] args, Token errorToken)
{
MethodBase mb;
var methodsCount = ExpressionUtility.FindMethod(type, methodName, true, args, out mb);
switch (methodsCount)
{
case 0:
throw Error.ParseError(errorToken, () => Res.NoApplicableMethod, methodName, TypeUtility.GetTypeName(type));
case 1:
MethodInfo method = (MethodInfo)mb;
if (method.ReturnType == typeof(void))
{
throw Error.ParseError(errorToken, Res.MethodIsVoid, methodName, TypeUtility.GetTypeName(method.DeclaringType));
}
return(Expression.Call(null, method, args));
default:
throw Error.ParseError(errorToken, Res.AmbiguousMethodInvocation, methodName, TypeUtility.GetTypeName(type));
}
}
public void TestScoreChanged()
{
const string descr = "TestScoreChanged";
const int penalty = 10;
const int newScore = UserActionsManager.StartingScore - penalty;
var dateService = _container.Resolve <IDateTimeService>();
var registratorMock = new Mock <IUserActionsRegistratorClient>(MockBehavior.Loose);
registratorMock.Setup(reg => reg.RegisterUserActionsAsync(
It.IsAny <long>(),
It.IsAny <Guid>(),
It.IsAny <ActionDescription[]>(),
It.IsAny <bool>()))
.Callback(() => registratorMock.Raise(mock => mock.RegisterUserActionsCompleted += null,
new RegisterUserActionsCompletedEventArgs(new object[] { newScore }, null, false, false)));
var flag = false;
using (var wrapper = DisposableWcfClientWrapper.Create(registratorMock.Object))
{
var manager = CreateUAManager(wrapper, dateService);
manager.PropertyChanged += (sender, args) =>
flag = args.PropertyName == ExpressionUtility.NameForMember((UserActionsManager m) => m.Score);
manager.RegisterMistake(descr, penalty);
Assert.That(manager.Score == newScore);
}
}
// +, -, & operators
private Expression ParseAdditive()
{
Expression left = ParseMultiplicative();
while (Token.Identity == TokenId.Plus || Token.Identity == TokenId.Minus ||
Token.Identity == TokenId.Amphersand)
{
var op = Token;
NextToken();
Expression right = ParseMultiplicative();
switch (op.Identity)
{
case TokenId.Plus:
if (left.Type == typeof(string) || right.Type == typeof(string))
{
goto case TokenId.Amphersand;
}
ExpressionUtility.CheckAndPromoteOperands(typeof(IAddSignatures), op.Text, ref left, ref right, op.Position);
left = GenerateAdd(left, right);
break;
case TokenId.Minus:
ExpressionUtility.CheckAndPromoteOperands(typeof(IAddSignatures), op.Text, ref left, ref right, op.Position);
left = GenerateSubtract(left, right);
break;
case TokenId.Amphersand:
left = GenerateStringConcat(left, right);
break;
}
}
return(left);
}
/// <summary>
/// Execute the creation of the parameter "sort"
/// </summary>
/// <param name="jObject">JSON object with parameters to request to SOLR</param>
public void Execute(JObject jObject)
{
var facetObject = (JObject)jObject["facet"] ?? new JObject();
var array = new List <JProperty>
{
new JProperty("q", this.Excludes.GetSolrFacetWithExcludes(this.Query.Execute()))
};
array.Add(new JProperty("mincount", 1));
if (this.SortType.HasValue)
{
string typeName;
string sortName;
ExpressionUtility.GetSolrFacetSort(this.SortType.Value, out typeName, out sortName);
array.Add(new JProperty("sort", new JObject(new JProperty(typeName, sortName))));
}
var jProperty = new JProperty(this.AliasName, new JObject(new JProperty("query", new JObject(array.ToArray()))));
facetObject.Add(jProperty);
jObject["facet"] = facetObject;
}
private static IEnumerable <object> BuildActions(ICollection <ActionDescription> actionDescriptions)
{
var actionNames = actionDescriptions
.Select(x => (x.ActionName, Key: (x.Controller, x.ActionMethodName, x.CustomActionImplementationOrder)))
.ToDictionary(x => $"{x.Key.Controller}.{x.Key.ActionMethodName}.{x.Key.CustomActionImplementationOrder}", x => x.ActionName);
foreach (var entityActionGroup in actionDescriptions.GroupBy(x => x.ResponseType))
{
var actionKeys = entityActionGroup.AsEnumerable().Select(x => $"{x.Controller}.{x.ActionMethodName}.{x.CustomActionImplementationOrder}");
var newActions = new Dictionary <string, string>();
foreach (var actionKey in actionKeys)
{
if (actionNames.TryGetValue(actionKey, out var newAction))
{
var split = actionKey.Split('.');
//var newKey = string.Join("", split[1], split[2]);
var newKey = split[1];
newActions.Add(newKey, newAction);
}
}
yield return(ExpressionUtility.CreateConstructor(typeof(EndpointAction <>).MakeGenericType(entityActionGroup.Key), typeof(IDictionary <string, string>))(newActions));
}
}
// *, /, %, mod operators
Expression ParseMultiplicative()
{
Expression left = ParseUnary();
while (Token.Identity == TokenId.Asterisk || Token.Identity == TokenId.Slash ||
Token.Identity == TokenId.Percent || Token.IdentifierIs("mod"))
{
Token op = Token;
NextToken();
Expression right = ParseUnary();
ExpressionUtility.CheckAndPromoteOperands(typeof(IArithmeticSignatures), op.Text, ref left, ref right, op.Position);
switch (op.Identity)
{
case TokenId.Asterisk:
left = Expression.Multiply(left, right);
break;
case TokenId.Slash:
left = Expression.Divide(left, right);
break;
case TokenId.Percent:
case TokenId.Identifier:
left = Expression.Modulo(left, right);
break;
}
}
return(left);
}
private Expression <Func <TEntity, bool> > QueryHandle(IEnumerable <IParameter> parameters)
{
Expression <Func <TEntity, bool> > predicate = p => true;
//if (nestedQueryTarget is not null)
//{
// //var dirtyEntityName = nestedQueryTarget.Type.Name.Split("Response")[0] + "s";
// var foreign = _foreignEntityDefinitions.FirstOrDefault(x => x.ResponseType == nestedQueryTarget.Type);
// var baseProperty = Expression.Parameter(typeof(TEntity));
// var field = Expression.PropertyOrField(baseProperty, $"{foreign.EntityType.Name}s");
// var hm = Expression.Parameter(foreign.EntityType);
// var idField = Expression.PropertyOrField(hm, "Id");
// var call = Expression.Call(typeof(IEnumerable<Guid>), "Select", null, field, idField); // new[] { field.Type, typeof(Guid) }
// var cons = Expression.Constant(nestedQueryTarget.Id);
// var contains = typeof(Guid).GetMethod(nameof(Method.Contains), new[] { typeof(Guid) });
// var cont = Expression.Call(call, contains, cons);
// var ah = Expression.Lambda<Func<TEntity, bool>>(cont, baseProperty);
// return ah;
// // var callSelect = Expression.Call(null, )
// //var access = Expression.ArrayAccess(field);
//}
foreach (var parameter in parameters)
{
predicate = ExpressionUtility.AndAlso(predicate, Filter(parameter));
}
return(predicate);
}
public static PpeService BuildService()
{
PpeService ppeService = new PpeService();
//Customer.CustomerType
ppeService.AddExpression <Customer>(nameof(CustomerBl.CustomerType), pe =>
{
var storeProperty = Expression.Property(pe, nameof(Customer.Store));
var personProperty = Expression.Property(pe, nameof(Customer.Person));
var isStoreNotNull = ExpressionUtility.IsNotNull(storeProperty);
var isPersonNotNull = ExpressionUtility.IsNotNull(personProperty);
return(Expression.Condition(isPersonNotNull,
Expression.Constant(CustomerType.PERSON.GetDisplayValue()),
Expression.Condition(isStoreNotNull,
Expression.Constant(CustomerType.STORE.GetDisplayValue()),
Expression.Constant(CustomerType.UNKNOWN.GetDisplayValue()))));
});
//Customer.DisplayName
ppeService.AddExpression <Customer>(nameof(CustomerBl.DisplayName), pe =>
{
var storeProperty = Expression.Property(pe, nameof(Customer.Store));
var personProperty = Expression.Property(pe, nameof(Customer.Person));
var storeName = Expression.Property(storeProperty, nameof(Store.Name));
var personName = ppeService.GetExpression <Person>(personProperty, nameof(PersonBl.DisplayName));
var isStoreNotNull = ExpressionUtility.IsNotNull(storeProperty);
var isPersonNotNull = ExpressionUtility.IsNotNull(personProperty);
return(Expression.Condition(isPersonNotNull,
personName,
Expression.Condition(isStoreNotNull,
storeName,
Expression.Constant(CustomerType.UNKNOWN.GetDisplayValue()))));
});
//Person.DisplayName
ppeService.AddExpression <Person>(nameof(PersonBl.DisplayName), pe =>
{
var lastNameProperty = Expression.Property(pe, nameof(Person.LastName));
var firstNameProperty = Expression.Property(pe, nameof(Person.FirstName));
var separatorExpression = Expression.Constant(", ");
var concatMethod = typeof(string).GetMethod(nameof(String.Concat), new[] { typeof(string), typeof(string) });
return(Expression.Add( //using Expression.Add instead of Expression.Call because the translator has difficulties translating String.Concat
lastNameProperty,
Expression.Add(
separatorExpression,
firstNameProperty,
concatMethod),
concatMethod));
});
return(ppeService);
}
/// <summary>
/// Execute the creation of the parameter "sort"
/// </summary>
/// <param name="jObject">JSON object with parameters to request to SOLR</param>
public void Execute(JObject jObject)
{
var jArray = (JArray)jObject["filter"] ?? new JArray();
jArray.Add(ExpressionUtility.GetSolrFilterWithTag(this.Value.Execute(), this.TagName));
jObject["filter"] = jArray;
}
private void HandlePropertyChanged(PropertyChangedEventArgs args)
{
if (args.PropertyName == ExpressionUtility.NameForMember((IUiBlockerAsyncProcessor p) => p.IsBusy))
{
// Нас могли дёрнуть из другого потока, поэтому доступ к UI - через Dispatcher.
Dispatcher.BeginInvoke(RecalculateIsLoadingData);
}
}
private void OnSerializing(StreamingContext context)
{
var cleanedExpression = ExpressionUtility.Ensure(_predicate);
var serializer = new ExpressionSerializer();
var xmlElement = serializer.Serialize(cleanedExpression);
_serializedPredicate = xmlElement.ToString();
}
public void CanGetSimplePropertyName()
{
// Act.
string name = ExpressionUtility.GetPropertyName <TestClass, string>(u => u.MyProp);
// Assert.
Assert.That(name, Is.EqualTo("MyProp"));
}
public void ThrowsIfNotBinaryExpression()
{
// Act.
string name;
object value;
ExpressionUtility.GetPropertyNameAndValue <TestClass>(u => true, out name, out value);
}
void OnDestroy()
{
luaenv.DoString(@"
local util = require 'xlua.util'
util.print_func_ref_by_csharp()");
// if (luaenv != null) luaenv.Dispose ();
ExpressionUtility.Dispose();
}
/// <summary>
/// Execute the creation of the parameter "sort"
/// </summary>
/// <param name="container">Container to parameters to request to SOLR</param>
public void Execute(List <string> container)
{
var fieldName = this._expressionBuilder.GetFieldNameFromExpression(this.Expression);
var formule = ExpressionUtility.GetSolrSpatialFormule(this.FunctionType, fieldName, this.CenterPoint, this.Distance);
container.Add($"fq={formule}");
}
/// <summary>
/// Useful for working with values that are not the direct evaluation result of a parameter.
/// This allows ExpressionNode authors to leverage the coercion and comparision functions
/// for any values.
///
/// Also note, the value will be canonicalized (for example numeric types converted to double) and any
/// matching interfaces applied.
/// </summary>
public static EvaluationResult CreateIntermediateResult(
EvaluationContext context,
Object obj)
{
var val = ExpressionUtility.ConvertToCanonicalValue(obj, out ValueKind kind, out Object raw);
return(new EvaluationResult(context, 0, val, kind, raw, omitTracing: true));
}
private Expression GenerateAdd(Expression left, Expression right)
{
if (left.Type == typeof(string) && right.Type == typeof(string))
{
return(ExpressionUtility.GenerateStaticMethodCall("Concat", left, right));
}
return(Expression.Add(left, right));
}
