internal void CallHandlers(string name, ITranslationResult result)
{
var tmpHandlers = new List <TranslationResultHandler>();
var emptyCount = 0;
while (true)
{
lock (_lock)
{
if (TryGetHandlers(name, out var handlers))
{
tmpHandlers.AddRange(handlers);
handlers.Clear();
}
if (emptyCount > 1 && tmpHandlers.Count == 0)
{
_tracker.Remove(name);
return;
}
}
if (tmpHandlers.Count == 0)
{
emptyCount++;
continue;
}
tmpHandlers.CallHandlers(result);
tmpHandlers.Clear();
}
}
/// <summary>
/// Translates a LINQ expression into collection of query segments.
/// </summary>
/// <param name="expression">LINQ expression.</param>
/// <param name="result">Translation result.</param>
/// <returns>Collection of query segments.</returns>
public void Translate(Expression expression, ITranslationResult result)
{
if (expression.NodeType != ExpressionType.Call)
{
return;
}
var methodCall = (MethodCallExpression)expression;
// Visit method
VisitMethodCall(methodCall, result);
// ReSharper disable ForCanBeConvertedToForeach
// Visit arguments
for (int i = 0; i < methodCall.Arguments.Count; i++)
{
Expression argument = methodCall.Arguments[i];
if (argument.NodeType == ExpressionType.Call)
{
Translate(argument, result);
}
}
// ReSharper restore ForCanBeConvertedToForeach
}
private void AddPostProcessing(MethodCallExpression method, ITranslationResult result)
{
Type type = method.Arguments[0].Type.GetGenericArguments()[0];
ParameterExpression parameter = Expression.Parameter(typeof (IQueryable<>).MakeGenericType(type), null);
MethodCallExpression call = Expression.Call(method.Method, parameter, method.Arguments[1]);
result.AddPostProcesing(Expression.Lambda(call, parameter));
}
private void AddColumn(string parameterName, ITranslationResult result)
{
if (!_nameChanges.TryGetValue(parameterName, out string name))
{
name = parameterName;
}
result.AddColumn(name);
}
private void AddColumn(string parameterName, ITranslationResult result)
{
string name;
if (!_nameChanges.TryGetValue(parameterName, out name))
{
name = parameterName;
}
result.AddColumn(name);
}
public void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != MethodName)
{
throw new ArgumentOutOfRangeException(nameof(method), $"Method '{nameof(method)}' is not supported");
}
var expressionTranslator = new ExpressionTranslator(_nameChanges);
expressionTranslator.Translate(result, method);
}
public void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != MethodName)
{
var message = string.Format(Resources.TranslatorMemberNotSupported, method.NodeType);
throw new ArgumentOutOfRangeException("method", message);
}
var expressionTranslator = new ExpressionTranslator(_nameChanges);
expressionTranslator.Translate(result, method);
}
public void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != MethodName || method.Arguments.Count != 2)
{
var message = string.Format(Resources.TranslatorMemberNotSupported, method.NodeType);
throw new ArgumentOutOfRangeException("method", message);
}
var constant = (ConstantExpression) method.Arguments[1];
result.AddTop((int) constant.Value);
}
public void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != MethodName || method.Arguments.Count != 2)
{
var message = string.Format(Resources.TranslatorMemberNotSupported, method.NodeType);
throw new ArgumentOutOfRangeException("method", message);
}
var constant = (ConstantExpression)method.Arguments[1];
result.AddTop((int)constant.Value);
}
public void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != MethodName || method.Arguments.Count != 2)
{
var message = string.Format("Resources.TranslatorMethodNotSupported {0}", method.Method.Name);
throw new ArgumentOutOfRangeException("method", message);
}
var lambda = (LambdaExpression)ExpressionTranslator.StripQuotes(method.Arguments[1]);
// ReSharper disable ForCanBeConvertedToForeach
if (lambda.Body.NodeType == ExpressionType.MemberInit)
{
var memberInit = (MemberInitExpression)lambda.Body;
for (int i = 0; i < memberInit.Bindings.Count; i++)
{
MemberBinding binding = memberInit.Bindings[i];
AddColumn(binding.Member.Name, result);
}
}
else if (lambda.Body.NodeType == ExpressionType.New)
{
var newInstance = (NewExpression)lambda.Body;
for (int i = 0; i < newInstance.Arguments.Count; i++)
{
Expression argument = newInstance.Arguments[i];
var member = (MemberExpression)argument;
AddColumn(member.Member.Name, result);
}
}else if(lambda.Body.NodeType == ExpressionType.Parameter)
{
// from ent in source select ent.
}else if(lambda.Body.NodeType == ExpressionType.MemberAccess)
{
//from ent in source select ent.Name
var memberAccess = (MemberExpression)lambda.Body;
AddColumn(memberAccess.Member.Name, result);
}
else
{
throw new NotSupportedException(string.Format("Resources.TranslatorMemberNotSupported {0}", lambda.Body.NodeType));
}
// ReSharper restore ForCanBeConvertedToForeach
AddPostProcessing(method, result);
}
private void VisitMethodCall(MethodCallExpression methodCall, ITranslationResult result)
{
if (methodCall.Method.DeclaringType != typeof(System.Linq.Queryable))
{
throw new NotSupportedException(string.Format(Resources.TranslatorMethodNotSupported, methodCall.Method.Name));
}
// Get a method translator
if (!_methodTranslators.TryGetValue(methodCall.Method.Name, out IMethodTranslator translator))
{
string message = string.Format(Resources.TranslatorMethodNotSupported, methodCall.Method.Name);
throw new NotSupportedException(message);
}
translator.Translate(methodCall, result);
}
private void VisitMethodCall(MethodCallExpression methodCall, ITranslationResult result)
{
if (methodCall.Method.DeclaringType != typeof (System.Linq.Queryable))
{
throw new NotSupportedException(string.Format(Resources.TranslatorMethodNotSupported, methodCall.Method.Name));
}
// Get a method translator
IMethodTranslator translator;
if (!_methodTranslators.TryGetValue(methodCall.Method.Name, out translator))
{
string message = String.Format(Resources.TranslatorMethodNotSupported, methodCall.Method.Name);
throw new NotSupportedException(message);
}
translator.Translate(methodCall, result);
}
public virtual ITranslationResult Translate(ITranslatable target, string language)
{
ITranslationResult result = null;
foreach (KeyValuePair <string, Control> pair in target.TranslationTargets)
{
if (pair.Value is ITextControl)
{
ITextControl textControl = pair.Value as ITextControl;
result = this.Translate(pair.Key, textControl.Text, language);
if (result.IsSuccessful())
{
textControl.Text = result.Translation;
}
}
}
return(result);
}
public virtual void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != _methodName)
{
throw new ArgumentOutOfRangeException($"Method '{nameof(method)}' is not supported");
}
var expressionTranslator = new ExpressionTranslator(_nameChanges);
MethodCallExpression targetMethod = method;
if (method.Arguments.Count == 1 && method.Arguments[0].NodeType == ExpressionType.Call)
{
targetMethod = (MethodCallExpression)method.Arguments[0];
}
expressionTranslator.Translate(result, targetMethod);
expressionTranslator.AddPostProcessing(method);
}
public virtual void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != _methodName)
{
string message = string.Format("Resources.TranslatorMethodNotSupported {0}", method.Method.Name);
throw new ArgumentOutOfRangeException("method", message);
}
var expressionTranslator = new ExpressionTranslator(_configuration);
MethodCallExpression targetMethod = method;
if (method.Arguments.Count == 1 && method.Arguments[0].NodeType == ExpressionType.Call)
{
targetMethod = (MethodCallExpression)method.Arguments[0];
}
expressionTranslator.Translate(result, targetMethod);
expressionTranslator.AddPostProcessing(method);
}
public void Translate(ITranslationResult result, MethodCallExpression method)
{
_result = result;
if (method.Arguments.Count != 2)
{
return;
}
var lambda = (LambdaExpression) StripQuotes(method.Arguments[1]);
if (lambda.Body.NodeType == ExpressionType.Constant)
{
return;
}
_filter = new StringBuilder();
Visit(lambda.Body);
_result.AddFilter(TrimString(_filter));
}
public void Translate(ITranslationResult result, MethodCallExpression method)
{
_result = result;
if (method.Arguments.Count != 2)
{
return;
}
var lambda = (LambdaExpression)StripQuotes(method.Arguments[1]);
if (lambda.Body.NodeType == ExpressionType.Constant)
{
return;
}
_filter = new StringBuilder();
_keyFilters = new List<KeyFilter>();
Visit(lambda.Body);
var odataFilter = TrimString(_filter);
if (_keyFilters.Any())
{
var filter = new StringBuilder();
var keys = _keyFilters.GroupBy(k => k.Type)
.Select(k => new
{
k.Key,
PropertyName = string.Join(TableStorageContext.KeySeparator, k.OrderBy(v => v.Position).Select(v => v.PropertyName)),
StartsWithPattern = string.Join(TableStorageContext.KeySeparator, k.OrderBy(v => v.Position).Select(v => v.Value)),
HasStartsWith = k.Any(v=>v.StartsWith),// string.Join(TableStorageContext.KeySeparator, k.OrderBy(v => v.Position).Select(v => v.Value)),
}).ToArray();
for (int i = 0; i < keys.Length; ++i)
{
var key = keys[i];
if (!_nameChanges.Keys.Any(k => k.StartsWith(key.PropertyName)))
throw new Exception("Make sure that all the filters are used when having hasKeys(p=new { p.p1, p.p2}) ");
if (i > 0)
filter.Append(" and ");
if (!key.HasStartsWith)
{
filter.Append(key.Key);
filter.Append(" eq '");
filter.Append(key.StartsWithPattern);
filter.Append("'");
}else {
var length = key.StartsWithPattern.Length - 1;
var lastChar = key.StartsWithPattern[length];
var nextLastChar = (char)(lastChar + 1);
var startsWithEndPattern = key.StartsWithPattern.Substring(0, length) + nextLastChar;
filter.Append(key.Key);
filter.Append(" ge '");
filter.Append(key.StartsWithPattern);
filter.Append("' and ");
filter.Append(key.Key);
filter.Append(" lt '");
filter.Append(startsWithEndPattern);
filter.Append("'");
}
}
//var i = 0;
//if (odataFilter.StartsWith(" and "))
// i = " and ".Length;
//if (odataFilter.StartsWith("( and )"))
// i = "( and )".Length;
// "(( and ) and ) and"
int idx = 0;
do
{
idx = odataFilter.IndexOf("( and )");
if (idx > -1)
{
odataFilter = odataFilter.Remove(idx, "( and )".Length);
}
} while (idx > -1);
if (odataFilter.Equals(" and "))
odataFilter = "";
odataFilter = filter.ToString() + odataFilter;
}
_result.AddFilter(odataFilter);
}
internal static void CallHandlers(this IEnumerable <TranslationResultHandler> handlers, ITranslationResult result)
{
var count = 0;
foreach (var handler in handlers)
{
count++;
try
{
handler(result);
}
catch (Exception err)
{
Logger.LogError($"executing {handler.Method}: {err} {err.Message}");
}
}
}
protected static void FallbackTranslateAsync(string key, Action <ITranslationResult> onCompleted,
ITranslationResult cannedResult)
{
_ = key;
onCompleted(cannedResult);
}
internal void JobCompleteHandler(ITranslationResult _)
{
JobComplete();
}
public override void Translate(MethodCallExpression method, ITranslationResult result)
{
base.Translate(method, result);
result.AddTop(1);
}
public void CallHandlers(NameScope scope, string name, ITranslationResult result)
{
_tracker[scope].CallHandlers(name, result);
}
protected void FallbackTranslateAsync(string _, Action <ITranslationResult> onCompleted, ITranslationResult cannedResult)
{
onCompleted(cannedResult);
}
