/// <summary>
/// Appends a <see cref="JsonPath"/> by specifying an expression which evaluates to the index to include.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The new <see cref="JsonPath"/>.</returns>
public static JsonPath Array(Expression <Func <JsonPathArray, int> > expression)
{
var path = new JsonPath();
path.Operators.Add(new ArrayOperator(new IndexExpressionQuery(ExpressionTranslator.Translate(expression))));
return(path);
}
/// <summary>
/// Appends a <see cref="JsonPath"/> by specifying a predicate expression which filters the values.
/// </summary>
/// <param name="expression">The predicate expression</param>
/// <returns>The new <see cref="JsonPath"/>.</returns>
public static JsonPath Array(Expression <Func <JsonPathValue, bool> > expression)
{
var path = new JsonPath();
path.Operators.Add(new ArrayOperator(new FilterExpressionQuery(ExpressionTranslator.Translate(expression))));
return(path);
}
public string GetSelectString <T>(string collectionName,
Expression <Func <T, Boolean> > filter,
string orderBy,
bool onlyOne = false)
{
ExpressionTranslator expressionTranslator = new ExpressionTranslator();
DbCollection collection = _collections[collectionName];
StringBuilder str = new StringBuilder();
str.Append(" select ");
if (onlyOne)
{
str.Append(" Top 1 ");
}
str.Append(collection.GetFields());
str.Append(" from [");
str.Append(collectionName);
str.Append("] ");
string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter);
str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere);
if (!string.IsNullOrEmpty(orderBy))
{
str.Append(orderBy);
}
return(str.ToString());
}
public async Task <int> UpdateAsync <T>(T obj, Expression <Func <T, bool> > predicate) where T : class, new()
{
var tableName = typeof(T).TableNameValidate();
var fields = typeof(T).GetProperties();
var primaryKey = fields.PrimaryKeyValidate();
var pkValue = primaryKey.GetValue(obj);
var parameters = Shared.Data.CRUDDataMapping(obj, Enumerables.SqlType.Update);
parameters.Remove(primaryKey.Name);
var translator = new ExpressionTranslator();
var translatorResult = translator.Translate(predicate);
var query = $@"UPDATE {tableName} SET
{string.Join(",", parameters.Select(x => $"{x.Key} = @{x.Key}"))}
WHERE " + translatorResult;
var parametersArray = parameters.Select(x => new TParameterType()
{
ParameterName = $"@{x.Key}",
Value = x.Value
}).ToList();
parametersArray.Add(new TParameterType()
{
ParameterName = $"@{primaryKey.Name}", Value = primaryKey.GetValue(obj)
});
var value = await ExecuteNonQueryAsync(query, parametersArray);
return(value);
}
public static XElement Translate(string xamlFile)
{
string translatedWorkflowString = null;
using (XamlReader xamlReader = new XamlXmlReader(xamlFile))
{
TranslationResults result = ExpressionTranslator.Translate(xamlReader);
if (result.Errors.Count == 0)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
}))
{
using (XamlXmlWriter writer = new XamlXmlWriter(xmlWriter, result.Output.SchemaContext))
{
XamlServices.Transform(result.Output, writer);
}
}
translatedWorkflowString = sb.ToString();
}
else
{
throw new InvalidOperationException("Translation errors");
}
}
return(XElement.Parse(translatedWorkflowString));
}
public void Translate(Expression e, string expected)
{
ExpressionTranslator expressionTransator = new ExpressionTranslator();
string actual = expressionTransator.Translate(e);
//Assert.AreEqual(expected, actual);
Assert.Pass(expected);
}
public async Task <int> DeleteAsync <T>(Expression <Func <T, bool> > predicate) where T : class, new()
{
var tableName = typeof(T).TableNameValidate();
var baseStatement = $@"DELETE FROM {tableName} WHERE ";
var translator = new ExpressionTranslator();
var translatorResult = translator.Translate(predicate);
var result = await ExecuteNonQueryAsync(baseStatement + translatorResult);
return(result);
}
public async Task <IEnumerable <T> > SelectAsync <T>(Expression <Func <T, bool> > predicate) where T : class, new()
{
var tableName = typeof(T).TableNameValidate();
var translator = new ExpressionTranslator();
var translatorResult = translator.Translate(predicate);
var query = $@"SELECT * FROM {tableName} WHERE {translatorResult}";
var result = await ExecuteReaderAsync <T>(query);
return(result);
}
public IEnumerable <T> Select <T>(Expression <Func <T, bool> > predicate) where T : class, new()
{
var tableName = typeof(T).TableNameValidate();
var baseStatement = $@"SELECT * FROM {tableName} ";
var translator = new ExpressionTranslator();
var tranlatorResult = translator.Translate(predicate);
var result = ExecuteReader <T>(baseStatement + tranlatorResult);
return(result);
}
public int Delete <T>(Expression <Func <T, bool> > predicate) where T : class, new()
{
var tableName = typeof(T).TableNameValidate();
var translator = new ExpressionTranslator();
var translatorResult = translator.Translate(predicate);
var query = $@"DELETE FROM {tableName} WHERE {translatorResult}";
var result = ExecuteNonQuery(query);
return(result);
}
public void TestContains()
{
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.Workstation.Contains("IZHW006"));
string translated = translator.Translate(expression);
Assert.AreEqual("Workstation:(*IZHW006*)", translated);
}
public void GivenQuery_WhenTwoPropertiesComparing_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.Workstation == e.Manager);
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
"Predicate should contain parameter and constant expression.");
}
public void GivenQuery_WhenIntTypeProvided_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.NonBillable < 100);
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
"Not supported expression type 'LessThan'.");
}
public void GivenQuery_WhenNotUnaryExpressionProvided_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => false);
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
$"'Constant' expression is not supported.");
}
public void GivenStringQuery_WhenNotSupportedMethodCalled_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.NativeName.IsNormalized(NormalizationForm.FormC));
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
$"Method 'IsNormalized' is not supported for type '{typeof(string)}'");
}
public void GivenQuery_WhenIntMethodCalled_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.NonBillable.Equals(100));
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
$"Not supported parameter type '{typeof(double)}'.");
}
public void GivenQuery_WhenSelectProvided_ThenNotSupportedExceptionRaised()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <string> > > expression
= query => query.Select(e => e.Workstation);
Assert.ThrowsException <NotSupportedException>(
() => translator.Translate(expression),
"Method 'Select' is not supported.");
}
public void Translate_GivenText_CallsTemplateBuilder()
{
var sut = new ExpressionTranslator();
string input = "Model.Property";
Span span = SpanHelper.BuildSpan(input);
sut.Translate(span, this._templateBuilder.Object);
this._templateBuilder.Verify(t => t.Write(input));
}
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(nameof(method), message);
}
var expressionTranslator = new ExpressionTranslator(_nameChanges);
expressionTranslator.Translate(result, method);
}
public void TestMethodEquals()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.Workstation.Equals("EPRUIZHW006"));
// Act
var result = translator.Translate(expression);
// Assert
Assert.AreEqual("Workstation:(EPRUIZHW006)", result);
}
/// <summary>
/// Returns rows count on specific condition from specified table.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static int Count <T>(this IDatabaseConnector connector, Expression <Func <T, bool> > predicate) where T : class
{
var con = connector as DatabaseConnectorBase;
if (con == null)
{
throw new InvalidCastException($"{connector.GetType().FullName} cannot be use with this extension (expected to get instance of {typeof(DatabaseConnectorBase).FullName}");
}
var tableName = AttributeExtension.TableNameAttributeValidate(typeof(T));
var exprTranslator = new ExpressionTranslator <T>(con.CompatibleFunctionName);
var translateResult = exprTranslator.Translate(predicate);
var query = $"SELECT COUNT(*) FROM {tableName} WHERE {translateResult.Expression}";
var count = con.ExecuteScalar(query, translateResult.Parameters);
var countAsString = count.ToString();
return(int.Parse(countAsString));
}
public static string TranslateWorkflow(string originalWorkflow)
{
using (var inputWorkflowReader = new StringReader(originalWorkflow))
using (var xamlReader = new XamlXmlReader(inputWorkflowReader))
{
var result = ExpressionTranslator.Translate(xamlReader);
if (result.Errors.Count > 0)
{
var message = CreateErrorMessage(result);
throw new ApplicationException(message);
}
else
{
return(CreateXamlString(result.Output));
}
}
}
/// <summary>
/// Returns rows count on specific condition from specified table.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static int Count <T>(this DbConnection connector, Expression <Func <T, bool> > predicate) where T : class
{
if (connector == null)
{
throw new InvalidCastException($"{connector.GetType().FullName} cannot be use with this extension (expected to get instance of {typeof(DbConnection).FullName}");
}
var constraint = RDapter.Global.GetSchemaConstraint <T>();
var tableName = constraint.TableName;
var exprTranslator = new ExpressionTranslator <T>();
var translateResult = exprTranslator.Translate(predicate);
var query = $"SELECT COUNT(*) FROM {tableName} WHERE {translateResult.Expression}";
var ec = new ExecutionCommand(query, translateResult.Parameters, System.Data.CommandType.Text, null);
var count = connector.ExecuteScalar(ec);
var countAsString = count.ToString();
return(int.Parse(countAsString));
}
public void TestAndQueryable()
{
// Arrange
var translator = new ExpressionTranslator();
Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression
= query => query.Where(e => e.Workstation == "EPRUIZHW006" && e.Manager.StartsWith("John"));
// Act
var result = translator.Translate(expression);
var lines = result.Split(Environment.NewLine);
// Assert
Assert.AreEqual(2, lines.Length);
Assert.AreEqual("Workstation:(EPRUIZHW006)", lines[0]);
Assert.AreEqual("Manager:(John*)", lines[1]);
}
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 string GetExistsString <T>(string collectionName,
Expression <Func <T, Boolean> > filter)
{
ExpressionTranslator expressionTranslator = new ExpressionTranslator();
DbCollection collection = _collections[collectionName];
StringBuilder str = new StringBuilder();
str.Append(" select count(*) from [");
str.Append(collectionName);
str.Append("] ");
string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter);
str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere);
return(str.ToString());
}
public virtual void Translate(MethodCallExpression method, ITranslationResult result)
{
if (method.Method.Name != _methodName)
{
string message = string.Format(Resources.TranslatorMethodNotSupported, method.Method.Name);
throw new ArgumentOutOfRangeException(nameof(method), message);
}
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 string GetUpdateString <T>(string collectionName,
Expression <Func <T, Boolean> > filter,
T entity)
{
ExpressionTranslator expressionTranslator = new ExpressionTranslator();
DbCollection collection = _collections[collectionName];
StringBuilder str = new StringBuilder();
str.Append(" update [");
str.Append(collectionName);
str.Append("] ");
str.Append(" set ");
str.Append(collection.GetFieldValuesForUpdate(entity));
string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter);
str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere);
return(str.ToString());
}
public static XElement TranslateString(string xamlFile)
{
string translatedWorkflowString = null;
using (XamlReader xamlReader = new XamlXmlReader(
new StringReader(xamlFile)))
{
TranslationResults result = ExpressionTranslator.Translate(xamlReader);
if (result.Errors.Count == 0)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
}))
{
using (XamlXmlWriter writer = new XamlXmlWriter(xmlWriter, result.Output.SchemaContext))
{
XamlServices.Transform(result.Output, writer);
}
}
translatedWorkflowString = sb.ToString();
}
else
{
string error = "Translation errors";
for (int i = 0; i < result.Errors.Count; i++)
{
error = error + " :::: [A:" + result.Errors[i].ActivityId + ", Line" + result.Errors[i].StartLine + "] \"" + result.Errors[i].ExpressionText + "\" (" + result.Errors[i].Message + ")";
}
throw new InvalidOperationException(error);
}
}
return(XElement.Parse(translatedWorkflowString));
}
