public static StronkConfig Consul(this SourceExpression self, string prefix = null, QueryOptions options = null)
{
return(self.Source(new ConsulConfigurationSource(
() => new ConsulClient(),
prefix,
options)));
}
protected internal override Expression VisitSelect(SelectExpression select)
{
var saveFrom = this.currentFrom;
var saveInAggregate = this.inAggregate;
this.inAggregate = false;
SourceExpression from = this.VisitSource(select.From !);
this.currentFrom = from;
Expression?top = this.Visit(select.Top);
Expression? where = this.Visit(select.Where);
ReadOnlyCollection <ColumnDeclaration> columns = Visit(select.Columns, VisitColumnDeclaration);
ReadOnlyCollection <OrderExpression> orderBy = Visit(select.OrderBy, VisitOrderBy);
ReadOnlyCollection <Expression> groupBy = Visit(select.GroupBy, Visit);
from = this.currentFrom;
this.inAggregate = saveInAggregate;
this.currentFrom = saveFrom;
if (top != select.Top || from != select.From || where != select.Where || columns != select.Columns || orderBy != select.OrderBy || groupBy != select.GroupBy)
{
return(new SelectExpression(select.Alias, select.IsDistinct, top, columns, from, where, orderBy, groupBy, select.SelectOptions));
}
return(select);
}
public EditStepVM(SourceExpression expression)
{
Title = expression.Title;
Description = expression.Description;
Expression = expression.Expression;
Condition = expression.Condition;
}
public void ShouldFilterByIsNotCondition()
{
FilterCondition condition = new FilterCondition
{
Field = new ConversationField {
Name = "Source", DataType = FieldDataType.Option
},
MatchType = ConditionMatchType.IsNot,
Value = "1"
};
var expression = new SourceExpression().Build(condition);
var conditions = new List <Conversation>
{
new Conversation {
Id = 1, Source = ConversationSource.FacebookMessage
},
new Conversation {
Id = 2, Source = ConversationSource.FacebookVisitorPost
}
}.AsQueryable();
var result = conditions.Where(expression).ToList();
Assert.Equal(1, result.Count);
Assert.Equal(2, result.First().Id);
}
protected override Expression VisitSelect(SelectExpression select)
{
var saveFrom = this.currentFrom;
var saveInAggregate = this.inAggregate;
this.inAggregate = false;
SourceExpression from = this.VisitSource(select.From);
this.currentFrom = from;
Expression top = this.Visit(select.Top);
Expression where = this.Visit(select.Where);
ReadOnlyCollection<ColumnDeclaration> columns = select.Columns.NewIfChange(VisitColumnDeclaration);
ReadOnlyCollection<OrderExpression> orderBy = select.OrderBy.NewIfChange(VisitOrderBy);
ReadOnlyCollection<Expression> groupBy = select.GroupBy.NewIfChange(Visit);
from = this.currentFrom;
this.inAggregate = saveInAggregate;
this.currentFrom = saveFrom;
if (top != select.Top || from != select.From || where != select.Where || columns != select.Columns || orderBy != select.OrderBy || groupBy != select.GroupBy)
return new SelectExpression(select.Alias, select.IsDistinct, top, columns, from, where, orderBy, groupBy, select.SelectOptions);
return select;
}
public ActionResult UpdateStep(EditStepSM sm)
{
try
{
EvaluationContext context = Session["Context"] as EvaluationContext;
SourceExpression expression = context.Plan.Expressions[sm.Index];
expression.Title = sm.Title;
expression.Description = sm.Description;
expression.Expression = sm.Expression;
expression.Condition = sm.Condition;
context.Refresh();
SetUpdateCount(sm.EditID);
return(new JsonResult()
{
Data = new { success = true }, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(new JsonResult()
{
Data = new { message = ex.Message.Replace("\r\n", "<br/>") }, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
private void WriteCSharpSwitch(ICSharpWriter writer)
{
ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(EntityNameList);
SourceExpression.WriteCSharp(writer, ExpressionContext, -1);
Debug.Assert(ExpressionContext.FilledDestinationTable.Count == 1);
string EntityName = EntityNameList[0].Name;
string LastExpressionText = ExpressionContext.FilledDestinationTable[EntityName];
if (LastExpressionText == null)
{
LastExpressionText = ExpressionContext.ReturnValue;
}
writer.WriteIndentedLine($"switch ({LastExpressionText})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
for (int i = 0; i < AttachmentList.Count; i++)
{
ICSharpAttachment Attachment = AttachmentList[i];
Attachment.WriteCSharpCase(writer, EntityName);
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
public StronkConfig()
{
From = new SourceExpression(this);
Write = new WriterExpression(this);
Map = new MapExpression(this);
Convert = new ConversionExpression(this);
Validate = new ValidationExpression(this);
Log = new LogExpression(this);
}
/// <summary>
/// Gets the source code corresponding to the expression.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="expressionContext">The context.</param>
/// <param name="skippedIndex">Index of a destination to skip.</param>
public override void WriteCSharp(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex)
{
Debug.Assert(WriteDown);
Debug.Assert(TypeList.Count > 0);
string CloneMethod = Source.Type == BaseNode.CloneType.Shallow ? "CloneShallow" : "Clone";
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
SourceExpression.WriteCSharp(writer, SourceExpressionContext, -1);
IList <string> ResultList = new List <string>();
int ReturnValueIndex = SourceExpressionContext.ReturnValueIndex;
string ReturnValue = SourceExpressionContext.ReturnValue;
if (TypeList.Count == 1)
{
ICSharpType ClonedType = TypeList[0];
string SourceTypeText = ClonedType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None);
string SourceText = SourceExpressionContext.ReturnValue;
Debug.Assert(SourceText != null);
expressionContext.SetSingleReturnValue($"({SourceTypeText})({SourceText}).{CloneMethod}()");
}
else
{
for (int i = 0; i < SourceExpressionContext.CompleteDestinationNameList.Count; i++)
{
if (i == ReturnValueIndex)
{
Debug.Assert(ReturnValue != null);
ResultList.Add(ReturnValue);
}
else
{
ResultList.Add(SourceExpressionContext.CompleteDestinationNameList[i]);
}
}
Debug.Assert(TypeList.Count == ResultList.Count);
IList <string> OutgoingResultList = new List <string>();
for (int i = 0; i < TypeList.Count; i++)
{
ICSharpType ClonedType = TypeList[i];
string SourceTypeText = ClonedType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None);
string SourceText = ResultList[i];
OutgoingResultList.Add($"({SourceTypeText})({SourceText}).{CloneMethod}()");
}
expressionContext.SetMultipleResult(OutgoingResultList, ReturnValueIndex);
}
}
static bool HasApplyJoin(SourceExpression source)
{
if (source is not JoinExpression join)
{
return(false);
}
return(join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply || HasApplyJoin(join.Left) || HasApplyJoin(join.Right));
}
protected internal override Expression VisitSelect(SelectExpression select)
{
Dictionary <ColumnExpression, ColumnExpression?> askedColumns = CurrentScope.Keys.Where(k => select.KnownAliases.Contains(k.Alias)).ToDictionary(k => k, k => (ColumnExpression?)null);
Dictionary <ColumnExpression, ColumnExpression?> externalAnswers = CurrentScope.Where(kvp => !select.KnownAliases.Contains(kvp.Key.Alias) && kvp.Value != null).ToDictionary();
var disposable = NewScope();//SCOPE START
var scope = CurrentScope;
scope.AddRange(askedColumns.Where(kvp => kvp.Key.Alias != select.Alias).ToDictionary());
scope.AddRange(externalAnswers);
var col = GetColumnCollector(select.KnownAliases);
col.Visit(select.Top);
col.Visit(select.Where);
foreach (var cd in select.Columns)
{
col.Visit(cd.Expression);
}
foreach (var oe in select.OrderBy)
{
col.Visit(oe.Expression);
}
foreach (var e in select.GroupBy)
{
col.Visit(e);
}
SourceExpression from = this.VisitSource(select.From !);
Expression? top = this.Visit(select.Top);
Expression? where = this.Visit(select.Where);
ReadOnlyCollection <OrderExpression> orderBy = Visit(select.OrderBy, VisitOrderBy);
if (orderBy.HasItems())
{
orderBy = RemoveDuplicates(orderBy);
}
ReadOnlyCollection <Expression> groupBy = Visit(select.GroupBy, Visit);
ReadOnlyCollection <ColumnDeclaration> columns = Visit(select.Columns, VisitColumnDeclaration);;
columns = AnswerAndExpand(columns, select.Alias, askedColumns);
var externals = CurrentScope.Where(kvp => !select.KnownAliases.Contains(kvp.Key.Alias) && kvp.Value == null).ToDictionary();
disposable.Dispose(); ////SCOPE END
CurrentScope.SetRange(externals);
CurrentScope.SetRange(askedColumns);
if (top != select.Top || from != select.From || where != select.Where || columns != select.Columns || orderBy != select.OrderBy || groupBy != select.GroupBy)
{
return(new SelectExpression(select.Alias, select.IsDistinct, top, columns, from, where, orderBy, groupBy, select.SelectOptions));
}
return(select);
}
public ExpressionParser(SourceExpression sourceExpression, ReadOnlyParseOption option)
{
index = 0;
se = sourceExpression;
this.option = option;
maxUnaryOperatorLength = option.UnaryOperators.Any() ?
(from item in option.UnaryOperators select item.Operator.Length).Max(x => x) : 0;
maxBinaryOperatorLength = option.BinaryOperators.Any() ?
(from item in option.BinaryOperators select item.Operator.Length).Max(x => x) : 0;
}
public void BuildSourceExpressionThrowsInvalidFormat(string expression)
{
// Arrange & Act
Action test = () => SourceExpression.Build(expression);
// Assert
OpenApiException exception = Assert.Throws <OpenApiException>(test);
Assert.Equal(String.Format(SRResource.SourceExpressionHasInvalidFormat, expression), exception.Message);
}
/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
SourceExpression.SetWriteDown();
}
protected internal virtual Expression VisitJoin(JoinExpression join)
{
SourceExpression left = this.VisitSource(join.Left);
SourceExpression right = this.VisitSource(join.Right);
Expression? condition = this.Visit(join.Condition);
if (left != join.Left || right != join.Right || condition != join.Condition)
{
return(new JoinExpression(join.JoinType, left, right, condition));
}
return(join);
}
public EvaluableExpression Parse(string expr, ReadOnlyParseOption option = null)
{
if (string.IsNullOrWhiteSpace(expr))
{
throw new ArgumentException($"{nameof(expr)} can not be null, empty, and consists only of white-space");
}
var sourceExpression = new SourceExpression(expr);
var parser = new ExpressionParser(sourceExpression, option ?? defaultParseOption);
var expression = parser.Parse();
return(expression);
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
SourceExpression.WriteCSharp(writer, SourceExpressionContext, -1);
string SourceString = SourceExpressionContext.ReturnValue;
writer.WriteIndentedLine($"switch ({SourceString})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
bool WithInserted = false;
foreach (ICSharpWith Item in WithList)
{
if (!WithInserted)
{
WithInserted = true;
}
else
{
writer.WriteEmptyLine();
}
Item.WriteCSharp(writer);
}
if (WithInserted)
{
writer.WriteEmptyLine();
}
writer.WriteIndentedLine("default:");
if (ElseInstructions != null)
{
ElseInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Indifferent, false);
writer.WriteIndentedLine("break;");
}
else
{
writer.IncreaseIndent();
writer.WriteIndentedLine("throw new ArgumentOutOfRangeException();");
writer.DecreaseIndent();
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
public void RequestExpressionConstructorWorks()
{
// Arrange
SourceExpression source = SourceExpression.Build("header.accept");
// Act
RequestExpression request = new RequestExpression(source);
// Assert
Assert.Same(source, request.Source);
Assert.Equal("$request.header.accept", request.Expression);
Assert.Equal("$request.header.accept", request.ToString());
}
internal JoinExpression(JoinType joinType, SourceExpression left, SourceExpression right, Expression?condition)
: base(DbExpressionType.Join)
{
if (condition == null && joinType != JoinType.CrossApply && joinType != JoinType.OuterApply && joinType != JoinType.CrossJoin)
{
throw new ArgumentNullException(nameof(condition));
}
this.JoinType = joinType;
this.Left = left ?? throw new ArgumentNullException(nameof(left));
this.Right = right ?? throw new ArgumentNullException(nameof(right));
this.Condition = condition;
}
public void BuildHeaderExpressionReturnsHeaderExpression()
{
// Arrange
string expression = "header.accept";
// Act
var sourceExpression = SourceExpression.Build(expression);
// Assert
Assert.NotNull(sourceExpression);
var header = Assert.IsType <HeaderExpression>(sourceExpression);
Assert.Equal(expression, header.Expression);
Assert.Equal("accept", header.Token);
}
public void BuildQueryExpressionReturnsQueryExpression()
{
// Arrange
string expression = "query.anyValue";
// Act
var sourceExpression = SourceExpression.Build(expression);
// Assert
Assert.NotNull(sourceExpression);
var query = Assert.IsType <QueryExpression>(sourceExpression);
Assert.Equal(expression, query.Expression);
Assert.Equal("anyValue", query.Name);
}
public void BuildPathExpressionReturnsPathExpression()
{
// Arrange
string expression = "path.anyValue";
// Act
var sourceExpression = SourceExpression.Build(expression);
// Assert
Assert.NotNull(sourceExpression);
var path = Assert.IsType <PathExpression>(sourceExpression);
Assert.Equal(expression, path.Expression);
Assert.Equal("anyValue", path.Name);
}
public void BuildBodyExpressionReturnsBodyExpression()
{
// Arrange
string expression = "body#/user/uuid";
// Act
var sourceExpression = SourceExpression.Build(expression);
// Assert
Assert.NotNull(sourceExpression);
var body = Assert.IsType <BodyExpression>(sourceExpression);
Assert.Equal(expression, body.Expression);
Assert.Equal("/user/uuid", body.Fragment);
}
/// <summary>Determines whether the specified object is equal to the current object.</summary>
/// <param name="operand">Type: <see cref="System.Object" />
/// The object to compare with the current object.</param>
/// <returns>Type: <see cref="System.Boolean" />
/// <b>true</b> if the specified object is equal to the current object; otherwise, <b>false</b>.</returns>
public override bool Equals(object operand)
{
if (Object.Equals(operand, null))
{
return(false);
}
if (operand.GetType() != typeof(IdentifierEntityAccessor))
{
return(false);
}
IdentifierEntityAccessor accessor = (IdentifierEntityAccessor)operand;
return((About != null ? About.Equals(accessor.About) : Object.Equals(accessor.About, null)) &&
(SourceExpression != null ? SourceExpression.Equals(accessor.SourceExpression) : Object.Equals(accessor.SourceExpression, null)) &&
(Source == accessor.Source) && (_entityAccessor.Equals(accessor._entityAccessor)));
}
private int writeSourceExpression(string originalText, ref IEnumerable<SourceExpression> localCacheDataList)
{
int sourceItemID = 0;
Repository<SourceExpression> sourceExpr = new Repository<SourceExpression>();
SourceExpression itemSource = new SourceExpression();
itemSource.Text = originalText;
//itemSource.DirectionID = direction.GetCurrentDirectionId();
itemSource.LanguageFromID = direction.LanguageFrom.ID;
itemSource.LanguageToID = direction.LanguageTo.ID;
if (sourceExpr.Save(itemSource) == 1)
{
localCacheDataList = sourceExpressionManager.GetSourceExpressionCollection(originalText, direction);
sourceItemID = localCacheDataList.ToList()[0].ID;
}
return sourceItemID;
}
IEnumerable <object> GetAllowedValues(ModelInstance root)
{
// Value properties
if (Property is ModelValueProperty)
{
// Get the list of allowed values
IEnumerable instances;
if (modelSource != null)
{
instances = modelSource.GetValue(root) as IEnumerable;
}
else
{
instances = SourceExpression.Invoke(root) as IEnumerable;
}
return(instances != null?instances.Cast <object>().ToArray() : null);
}
// Reference properties
else
{
// Get the model type of the property the rule applies to
ModelType propertyType = ((ModelReferenceProperty)Property).PropertyType;
// Get the list of allowed values
if (modelSource != null)
{
// Model Source
var instances = modelSource.GetList(root);
if (instances != null)
{
return(instances.ToArray());
}
}
else
{
// Model Expression
var instances = SourceExpression.Invoke(root) as IEnumerable;
if (instances != null)
{
return(instances.Cast <object>().Select(i => propertyType.GetModelInstance(i)).ToArray());
}
}
}
return(null);
}
public static EvaluationContext GetEvaluationContext(string text, EvaluationContext ec)
{
var plan = new Plan();
plan.Variables = ec.Variables.Select(m => new SourceVariable {
Name = m, Type = DataType.Number
}).ToArray();
var e = new SourceExpression
{
Expression = text
};
plan.Expressions = new SourceExpression[1] {
e
};
return(plan.CreateEvaluationContext());
}
protected internal virtual Expression VisitSelect(SelectExpression select)
{
Expression? top = this.Visit(select.Top);
SourceExpression from = this.VisitSource(select.From !);
Expression? where = this.Visit(select.Where);
ReadOnlyCollection <ColumnDeclaration> columns = Visit(select.Columns, VisitColumnDeclaration);
ReadOnlyCollection <OrderExpression> orderBy = Visit(select.OrderBy, VisitOrderBy);
ReadOnlyCollection <Expression> groupBy = Visit(select.GroupBy, Visit);
if (top != select.Top || from != select.From || where != select.Where || columns != select.Columns || orderBy != select.OrderBy || groupBy != select.GroupBy)
{
return(new SelectExpression(select.Alias, select.IsDistinct, top, columns, from, where, orderBy, groupBy, select.SelectOptions));
}
return(select);
}
private void WriteCSharpIf(ICSharpWriter writer)
{
ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext();
SourceExpression.WriteCSharp(writer, ExpressionContext, -1);
for (int i = 0; i < AttachmentList.Count; i++)
{
ICSharpAttachment Attachment = AttachmentList[i];
Attachment.WriteCSharpIf(writer, i, EntityNameList, ExpressionContext);
}
if (ElseInstructions != null)
{
writer.WriteIndentedLine("else");
ElseInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Mandatory, false);
}
}
protected internal override Expression VisitJoin(JoinExpression join)
{
this.Visit(join.Condition);
if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
{
this.VisitSource(join.Right);
}
SourceExpression left = this.VisitSource(join.Left);
SourceExpression right = this.VisitSource(join.Right);
Expression? condition = this.Visit(join.Condition);
if (left != join.Left || right != join.Right || condition != join.Condition)
{
return(new JoinExpression(join.JoinType, left, right, condition));
}
return(join);
}
protected override Expression VisitScalar(ScalarExpression scalar)
{
if (connector.SupportsScalarSubquery &&
(!inAggregate || connector.SupportsScalarSubqueryInAggregates))
{
return base.VisitScalar(scalar);
}
else
{
var select = scalar.Select;
if (string.IsNullOrEmpty(select.Columns[0].Name))
{
select = new SelectExpression(select.Alias, select.IsDistinct, select.Top,
new[] { new ColumnDeclaration("scalar", select.Columns[0].Expression) },
select.From, select.Where, select.OrderBy, select.GroupBy, select.SelectOptions);
}
this.currentFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, select, null);
return new ColumnExpression(scalar.Type, scalar.Select.Alias, select.Columns[0].Name);
}
}
/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
SourceExpression.SetWriteDown();
foreach (ICSharpWith With in WithList)
{
With.SetWriteDown();
}
if (ElseInstructions != null)
{
ElseInstructions.SetWriteDown();
}
}
protected internal override Expression VisitJoin(JoinExpression join)
{
if (join.Condition != null)
{
GetColumnCollector(join.KnownAliases).Visit(join.Condition);
}
else if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
{
GetColumnCollector(join.Left.KnownAliases).Visit(join.Right);
}
SourceExpression left = this.VisitSource(join.Left);
SourceExpression right = this.VisitSource(join.Right);
Expression? condition = this.Visit(join.Condition);
if (left != join.Left || right != join.Right || condition != join.Condition)
{
return(new JoinExpression(join.JoinType, left, right, condition));
}
return(join);
}
protected override SourceExpression VisitSource(SourceExpression source)
{
if (source is SourceWithAliasExpression)
{
if (source is TableExpression || source is SqlTableValuedFunctionExpression)
Visit(source);
else
{
sb.Append("(");
Visit(source);
sb.Append(")");
}
sb.Append(" AS ");
sb.Append(((SourceWithAliasExpression)source).Alias.Name.SqlEscape());
}
else
this.VisitJoin((JoinExpression)source);
return source;
}
static bool HasApplyJoin(SourceExpression source)
{
var join = source as JoinExpression;
if (join == null)
return false;
return join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply || HasApplyJoin(join.Left) || HasApplyJoin(join.Right);
}
public static IEnumerable<ColumnExpression> Keys(SourceExpression source)
{
if (source is SelectExpression)
return KeysSelect((SelectExpression)source);
if (source is TableExpression)
return KeysTable((TableExpression)source);
if(source is JoinExpression)
return KeysJoin((JoinExpression)source);
if (source is SetOperatorExpression)
return KeysSet((SetOperatorExpression)source);
throw new InvalidOperationException("Unexpected source");
}
protected virtual SourceExpression VisitSource(SourceExpression source)
{
return (SourceExpression)this.Visit(source);
}
