public void TestParseErrorGetsReported()
{
// Create an instance of our language grammar and set handlers for its rules.
LanguageGrammar<Expression> g = new LanguageGrammar<Expression>();
g.DivideRule.Action = (e1, e2) => Expression.Divide(e1, e2);
g.DoubleLiteralRule.Action = (d) => Expression.Constant(d);
g.IntLiteralRule.Action = (i) => Expression.Constant(i);
g.StringLiteralRule.Action = (s) => Expression.Constant(s);
g.MinusRule.Action = (e1, e2) => Expression.Subtract(e1, e2);
g.ModRule.Action = (e1, e2) => Expression.Modulo(e1, e2);
g.MultiplyRule.Action = (e1, e2) => Expression.Multiply(e1, e2);
g.NegateRule.Action = (e) => Expression.Negate(e);
g.PlusRule.Action = (e1, e2) => Expression.Add(e1, e2);
g.VariableRefRule.SetStatefulAction<ParserState>((s, name) => s.GetVariable(name));
// Spin up a parser for our language.
// TODO: Package this up and simplify it.
var expressionHelper = new ExpressionHelper();
var classifierSession = new TerminalClassifierSession<char, ParserState, int>()
.AddSkipTerminal(new Terminal<char> { Name = "Whitespace", InitialState = RegexCharNFABuilder.RegexCompiler(@"\s+") })
.CurrentCharExprIs(x => x.CurrentChar())
.GetFromMarkExprIs(x => x.GetFromMarkedPos())
.HasCurrentCharExprIs(x => x.HasCurrentChar())
.MarkPosExprIs(x => x.MarkPos())
.MoveNextCharExprIs(x => x.MoveNextChar())
.GetLocationIs(x=>new ParseLocation {Line = 1, Column = x.GetPos()})
.ErrorCollectionIs(x=>x.Errors)
.UnmarkPosExprIs(x => x.UnmarkPos());
var parserGen = new ParserGenerator<char>(expressionHelper);
var parseTableBuilder = new LRParseTableBuilder();
var parseTable = parseTableBuilder.BuildParseTable(g);
var session = parserGen.NewSession<ParserState>()
.NonTerminalValueExprIs<object>(x => x.NonTerminalValue)
.TerminalValueExprIs<string>(x => x.TerminalStringValue)
.TerminalValueExprIs<int>(x => x.TerminalIntValue)
.TerminalValueExprIs<double>(x => x.TerminalDoubleValue)
.TerminalIs(x => x.Terminal)
.NonTerminalIs(x => x.NonTerminal)
.IncludeSymbols(true)
.DebugOutputIs(x => Debug.WriteLine(x))
.Generate("LanguageParser", parseTable, classifierSession);
// At this point, session is an Expression<ParserState,int> representing our parser.
// We can compile it into a delegate or a MethodBuilder. For the examples, we'll use a delegate.
var compiler = session.Compile();
// Create a parser state object and initialize it.
ParserState ps = new ParserState("x*y +* 2.0");
ps.SetParameters(
Expression.Parameter(typeof(double), "x"),
Expression.Parameter(typeof(double), "y"));
Assert.AreNotEqual(0, compiler(ps));
Assert.AreNotEqual(0, ps.Errors.Count);
Assert.Less(ps.Errors.First().ExpectedTerminalNames.Count, g.Terminals.Count);
}
public static string FieldNameFor <T, TResult>(this HtmlHelper <T> html, Expression <Func <T, TResult> > expression)
{
return(html.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression)));
}
public Expression BuildExpression(IBuildContext context, Expression expression)
{
var newExpr = expression.Convert2(expr =>
{
if (_skippedExpressions.Contains(expr))
{
return(new ExpressionHelper.ConvertInfo(expr, true));
}
if (expr.Find(IsNoneSqlMember) != null)
{
return(new ExpressionHelper.ConvertInfo(expr));
}
switch (expr.NodeType)
{
case ExpressionType.MemberAccess:
{
if (IsServerSideOnly(expr) || PreferServerSide(expr))
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
var ma = (MemberExpression)expr;
if (SqlProvider.ConvertMember(ma.Member) != null)
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr))); //break;
}
//var l = SqlProvider.ConvertMember(ma.Member);
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new ExpressionHelper.ConvertInfo(ctx.BuildExpression(expr, 0)));
}
var ex = ma.Expression;
if (ex != null && ex.NodeType == ExpressionType.Constant)
{
// field = localVariable
//
var c = _expressionAccessors[ex];
return(new ExpressionHelper.ConvertInfo(
Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member)));
}
break;
}
case ExpressionType.Parameter:
{
if (expr == ParametersParam)
{
break;
}
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new ExpressionHelper.ConvertInfo(ctx.BuildExpression(expr, 0)));
}
break;
}
case ExpressionType.Constant:
{
if (ExpressionHelper.IsConstant(expr.Type))
{
break;
}
if (_expressionAccessors.ContainsKey(expr))
{
return(new ExpressionHelper.ConvertInfo(Expression.Convert(_expressionAccessors[expr], expr.Type)));
}
break;
}
case ExpressionType.Coalesce:
if (expr.Type == typeof(string) && MappingSchema.GetDefaultNullValue <string>() != null)
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Conditional:
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Call:
{
var ce = (MethodCallExpression)expr;
if (IsGroupJoinSource(context, ce))
{
foreach (var arg in ce.Arguments.Skip(1))
{
if (!_skippedExpressions.Contains(arg))
{
_skippedExpressions.Add(arg);
}
}
break;
}
if (IsSubQuery(context, ce))
{
if (TypeHelper.IsSameOrParent(typeof(IEnumerable), expr.Type) && expr.Type != typeof(string) && !expr.Type.IsArray)
{
return(new ExpressionHelper.ConvertInfo(BuildMultipleQuery(context, expr)));
}
return(new ExpressionHelper.ConvertInfo(GetSubQuery(context, ce).BuildExpression(null, 0)));
}
if (IsServerSideOnly(expr) || PreferServerSide(expr))
{
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
}
break;
}
if (EnforceServerSide(context))
{
switch (expr.NodeType)
{
case ExpressionType.MemberInit:
case ExpressionType.New:
case ExpressionType.Convert:
break;
default:
if (CanBeCompiled(expr))
{
break;
}
return(new ExpressionHelper.ConvertInfo(BuildSql(context, expr)));
}
}
return(new ExpressionHelper.ConvertInfo(expr));
});
return(newExpr);
}
/// <summary>
/// 输出设置标题图的标签（单选）
/// </summary>
/// <param name="htmlHelper">被扩展的htmlHelper实例</param>
/// <param name="expression">选择实体中类别属性的lamda表达式</param>
/// <param name="tenantTypeId">租户类型Id</param>
/// <param name="associateId">附件关联Id （默认为0）</param>
/// <returns>MvcHtmlString</returns>
public static MvcHtmlString SetTitleImageFor <TModel>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, long> > expression, string tenantTypeId, long associateId = 0)
{
if (string.IsNullOrEmpty(tenantTypeId))
{
throw new ExceptionFacade("租户类型Id不能为空");
}
string htmlFieldName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
AttachmentService <Attachment> attachementService = new AttachmentService <Attachment>(tenantTypeId);
var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
long attachmentId = (long)metadata.Model;
List <Attachment> attachments = new List <Attachment>();
if (attachmentId > 0)
{
var attachment = attachementService.Get(attachmentId);
if (attachment != null)
{
attachments.Add(attachment);
}
}
return(htmlHelper.EditorForModel("SetTitleImage", new { tenantTypeId = tenantTypeId, associateId = associateId, htmlFieldName = htmlFieldName, attachments = attachments, isMultiSelect = false }));
}
/// <summary>
/// Gets the group placement registrants.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="currentPerson">The current person.</param>
/// <returns></returns>
public List <GroupPlacementRegistrant> GetGroupPlacementRegistrants(GetGroupPlacementRegistrantsParameters options, Person currentPerson)
{
var rockContext = this.Context as RockContext;
var registrationRegistrantService = new RegistrationRegistrantService(rockContext);
var registrationRegistrantQuery = registrationRegistrantService.Queryable();
registrationRegistrantQuery = registrationRegistrantQuery
.Where(a => a.Registration.RegistrationInstance.RegistrationTemplateId == options.RegistrationTemplateId);
if (options.RegistrationInstanceId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Registration.RegistrationInstanceId == options.RegistrationInstanceId.Value);
}
else if (options.RegistrationTemplateInstanceIds?.Any() == true)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => options.RegistrationTemplateInstanceIds.Contains(a.Registration.RegistrationInstanceId));
}
if (options.RegistrantPersonDataViewFilterId.HasValue)
{
var dataFilter = new DataViewFilterService(rockContext).Get(options.RegistrantPersonDataViewFilterId.Value);
List <string> errorMessages = new List <string>();
var personService = new PersonService(rockContext);
var paramExpression = personService.ParameterExpression;
var personWhereExpression = dataFilter?.GetExpression(typeof(Person), personService, paramExpression, errorMessages);
if (personWhereExpression != null)
{
var personIdQry = personService.Queryable().Where(paramExpression, personWhereExpression, null).Select(x => x.Id);
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => personIdQry.Contains(a.PersonAlias.PersonId));
}
}
if (options.RegistrantId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Id == options.RegistrantId.Value);
}
Block registrationInstanceGroupPlacementBlock = new BlockService(rockContext).Get(options.BlockId);
if (registrationInstanceGroupPlacementBlock != null && currentPerson != null)
{
const string RegistrantAttributeFilter_RegistrationInstanceId = "RegistrantAttributeFilter_RegistrationInstanceId_{0}";
const string RegistrantAttributeFilter_RegistrationTemplateId = "RegistrantAttributeFilter_RegistrationTemplateId_{0}";
string userPreferenceKey;
if (options.RegistrationInstanceId.HasValue)
{
userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationInstanceId, options.RegistrationInstanceId);
}
else
{
userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationTemplateId, options.RegistrationTemplateId);
}
var attributeFilters = PersonService.GetUserPreference(currentPerson, userPreferenceKey).FromJsonOrNull <Dictionary <int, string> >() ?? new Dictionary <int, string>();
var parameterExpression = registrationRegistrantService.ParameterExpression;
Expression registrantWhereExpression = null;
foreach (var attributeFilter in attributeFilters)
{
var attribute = AttributeCache.Get(attributeFilter.Key);
var attributeFilterValues = attributeFilter.Value.FromJsonOrNull <List <string> >();
var entityField = EntityHelper.GetEntityFieldForAttribute(attribute);
if (entityField != null && attributeFilterValues != null)
{
var attributeWhereExpression = ExpressionHelper.GetAttributeExpression(registrationRegistrantService, parameterExpression, entityField, attributeFilterValues);
if (registrantWhereExpression == null)
{
registrantWhereExpression = attributeWhereExpression;
}
else
{
registrantWhereExpression = Expression.AndAlso(registrantWhereExpression, attributeWhereExpression);
}
}
}
if (registrantWhereExpression != null)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(parameterExpression, registrantWhereExpression);
}
}
var registrationTemplatePlacement = new RegistrationTemplatePlacementService(rockContext).Get(options.RegistrationTemplatePlacementId);
if (options.FilterFeeId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeId == options.FilterFeeId.Value));
}
if (options.FilterFeeOptionIds?.Any() == true)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeItemId.HasValue && options.FilterFeeOptionIds.Contains(f.RegistrationTemplateFeeItemId.Value)));
}
// don't include registrants that are on the waiting list
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.OnWaitList == false);
registrationRegistrantQuery = registrationRegistrantQuery.OrderBy(a => a.PersonAlias.Person.LastName).ThenBy(a => a.PersonAlias.Person.NickName);
var registrationTemplatePlacementService = new RegistrationTemplatePlacementService(rockContext);
var registrationInstanceService = new RegistrationInstanceService(rockContext);
// get a queryable of PersonIds for the registration template shared groups so we can determine if the registrant has been placed
var registrationTemplatePlacementGroupsPersonIdQuery = registrationTemplatePlacementService.GetRegistrationTemplatePlacementPlacementGroups(registrationTemplatePlacement).SelectMany(a => a.Members).Select(a => a.PersonId);
// and also get a queryable of PersonIds for the registration instance placement groups so we can determine if the registrant has been placed
IQueryable <InstancePlacementGroupPersonId> allInstancesPlacementGroupInfoQuery = null;
if (!options.RegistrationInstanceId.HasValue && (options.RegistrationTemplateInstanceIds == null || !options.RegistrationTemplateInstanceIds.Any()))
{
// if neither RegistrationInstanceId or RegistrationTemplateInstanceIds was specified, use all of the RegistrationTemplates instances
options.RegistrationTemplateInstanceIds = new RegistrationTemplateService(rockContext).GetSelect(options.RegistrationTemplateId, s => s.Instances.Select(i => i.Id)).ToArray();
}
if (options.RegistrationInstanceId.HasValue)
{
allInstancesPlacementGroupInfoQuery =
registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(options.RegistrationInstanceId.Value))
.Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId)
.SelectMany(a => a.Members).Select(a => a.PersonId)
.Select(s => new InstancePlacementGroupPersonId
{
PersonId = s,
RegistrationInstanceId = options.RegistrationInstanceId.Value
});
}
else if (options.RegistrationTemplateInstanceIds?.Any() == true)
{
foreach (var registrationInstanceId in options.RegistrationTemplateInstanceIds)
{
var instancePlacementGroupInfoQuery = registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(registrationInstanceId))
.Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId)
.SelectMany(a => a.Members).Select(a => a.PersonId)
.Select(s => new InstancePlacementGroupPersonId
{
PersonId = s,
RegistrationInstanceId = registrationInstanceId
});
if (allInstancesPlacementGroupInfoQuery == null)
{
allInstancesPlacementGroupInfoQuery = instancePlacementGroupInfoQuery;
}
else
{
allInstancesPlacementGroupInfoQuery = allInstancesPlacementGroupInfoQuery.Union(instancePlacementGroupInfoQuery);
}
}
}
if (allInstancesPlacementGroupInfoQuery == null)
{
throw new ArgumentNullException("Registration Instance(s) must be specified");
}
// select in a way to avoid lazy loading
var registrationRegistrantPlacementQuery = registrationRegistrantQuery.Select(r => new
{
Registrant = r,
r.PersonAlias.Person,
r.Registration.RegistrationInstance,
// marked as AlreadyPlacedInGroup if the Registrant is a member of any of the registrant template placement group or the registration instance placement groups
AlreadyPlacedInGroup =
registrationTemplatePlacementGroupsPersonIdQuery.Contains(r.PersonAlias.PersonId) ||
allInstancesPlacementGroupInfoQuery.Any(x => x.RegistrationInstanceId == r.Registration.RegistrationInstanceId && x.PersonId == r.PersonAlias.PersonId)
});
var registrationRegistrantPlacementList = registrationRegistrantPlacementQuery.AsNoTracking().ToList();
var groupPlacementRegistrantList = registrationRegistrantPlacementList
.Select(x => new GroupPlacementRegistrant(x.Registrant, x.Person, x.AlreadyPlacedInGroup, x.RegistrationInstance, options))
.ToList();
return(groupPlacementRegistrantList.ToList());
}
public static MvcHtmlString SemanticDropDownListMultipleFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, IList <SelectListItemVm> selectList = null, string optionLabel = "Selecione...", object htmlAttributes = null)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("div");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.AddCssClass("ui fluid multiple search selection dropdown");
var value = selectList?
.Where(s => s.Selected)
.Aggregate(string.Empty, (current, item) => $"{(string.IsNullOrWhiteSpace(current) ? "" : $"{current},")}{item.Value}");
public static MvcHtmlString SemanticEnumDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel, object htmlAttributes)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("select");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.Attributes.Add("name", fullBindingName);
tag.AddCssClass("ui search dropdown");
tag.InnerHtml += $"<option value=''>{optionLabel}</option>";
foreach (var item in selectList)
{
tag.InnerHtml += $"<option value='{item.Value}' {(item.Selected ? "selected" : string.Empty)}>{item.Text}</option>";
}
return(new MvcHtmlString(tag.ToString()));
}
public static MvcHtmlString SemanticTextDateFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, dynamic htmlAttributes)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("input");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("type", "text");
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.Attributes.Add("name", fullBindingName);
tag.Attributes.Add("data-gtmask", "datetime");
var valorInput = metadata.Model?.ToString();
if (string.IsNullOrWhiteSpace(valorInput))
{
tag.Attributes.Add("value", string.Empty);
}
else
{
tag.Attributes.Add("value", DateTime.Parse(valorInput) != DateTime.MinValue ? Convert.ToDateTime(valorInput).ToShortDateString() : string.Empty);
}
return(new MvcHtmlString(tag.ToString(TagRenderMode.SelfClosing)));
}
public static MvcHtmlString ValueFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, string format)
{
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
return(ValueForHelper(html, ExpressionHelper.GetExpressionText(expression), metadata.Model, format, useViewData: false));
}
private void TranslateParameterizedVariableExpression(Expression variableExpression, ConstantExpression constantExpression, string methodName, out string column, out string parameter)
{
TranslateVariableExpression(variableExpression, out column, out var columnAlias);
if (string.IsNullOrEmpty(column))
{
parameter = null;
return;
}
// In cases where the same property is being used multiple times in an expression, we need to generate
// an alias for that property
// For example:
// x => x.Id == 1 || x.Id > 2
// should translate to
// x => x.Id == @Id || x.Id > @Id1
if (_parameters.ContainsKey($"@{columnAlias}"))
{
var columnAliasCount = System.Text.RegularExpressions.Regex.Match(columnAlias, @"\d+").Value;
if (!string.IsNullOrEmpty(columnAliasCount))
{
columnAlias = columnAlias.TrimEnd(columnAliasCount.ToCharArray());
columnAlias = $"{columnAlias}{int.Parse(columnAliasCount) + 1}";
}
else
{
columnAlias = $"{columnAlias}{1}";
}
}
parameter = $"@{columnAlias}";
var value = ExpressionHelper.GetExpressionValue(constantExpression);
if (!string.IsNullOrEmpty(methodName))
{
switch (methodName)
{
case "Equals":
break;
case "StartsWith":
value = $"{value}%";
break;
case "EndsWith":
value = $"%{value}";
break;
case "Contains":
value = $"%{value}%";
break;
default:
throw new NotSupportedException(methodName + " isn't supported");
}
}
_parameters.Add(parameter, value);
}
private void TranslateComparison(BinaryExpression node, StringBuilder sb)
{
if (node.NodeType == ExpressionType.And ||
node.NodeType == ExpressionType.AndAlso ||
node.NodeType == ExpressionType.Or ||
node.NodeType == ExpressionType.OrElse)
{
var temp = new StringBuilder();
Visit(node, node.Left, temp);
if (temp.Length > 0)
{
switch (node.NodeType)
{
case ExpressionType.And:
case ExpressionType.AndAlso:
temp.Append(" AND ");
break;
case ExpressionType.Or:
case ExpressionType.OrElse:
temp.Append(" OR ");
break;
}
}
Visit(node, node.Right, temp);
sb.Append(temp);
}
else
{
var leftConstantExpression = node.Left.AsConstantExpression();
var rightConstantExpression = node.Right.AsConstantExpression();
string left;
string right;
if (leftConstantExpression != null && rightConstantExpression != null)
{
left = ExpressionHelper.GetExpressionValue(leftConstantExpression).ToString();
right = ExpressionHelper.GetExpressionValue(rightConstantExpression).ToString();
}
else if (leftConstantExpression == null && rightConstantExpression == null)
{
TranslateVariableExpression(node.Left, out left);
TranslateVariableExpression(node.Right, out right);
}
else
{
if (leftConstantExpression != null)
{
TranslateParameterizedVariableExpression(node.Right, leftConstantExpression, out right, out left);
}
else
{
TranslateParameterizedVariableExpression(node.Left, rightConstantExpression, out left, out right);
}
}
if (string.IsNullOrEmpty(left) || string.IsNullOrEmpty(right))
{
return;
}
sb.Append(left);
switch (node.NodeType)
{
case ExpressionType.Equal:
sb.Append(IsNullConstant(rightConstantExpression) ? " IS " : " = ");
break;
case ExpressionType.NotEqual:
sb.Append(IsNullConstant(rightConstantExpression) ? " IS NOT " : " <> ");
break;
case ExpressionType.LessThan:
sb.Append(" < ");
break;
case ExpressionType.LessThanOrEqual:
sb.Append(" <= ");
break;
case ExpressionType.GreaterThan:
sb.Append(" > ");
break;
case ExpressionType.GreaterThanOrEqual:
sb.Append(" >= ");
break;
default:
throw new NotSupportedException($"The binary operator '{node.NodeType}' is not supported");
}
sb.Append(right);
}
}
private void TranslateMethodCall(MethodCallExpression node, StringBuilder sb)
{
var arguments = node.Arguments.ToArray();
// assume that static and instance Equals mean the same thing for all classes (i.e. an equality test)
Expression firstExpression = null;
Expression secondExpression = null;
if (node.Object == null)
{
// static Equals method
if (arguments.Length == 2)
{
firstExpression = arguments[0];
secondExpression = arguments[1];
}
}
else
{
// instance Equals method
if (arguments.Length == 1)
{
firstExpression = node.Object;
secondExpression = arguments[0];
}
}
if (firstExpression != null && secondExpression != null)
{
var leftConstantExpression = firstExpression.AsConstantExpression();
var rightConstantExpression = secondExpression.AsConstantExpression();
string left;
string right;
if (leftConstantExpression != null && rightConstantExpression != null)
{
left = ExpressionHelper.GetExpressionValue(leftConstantExpression).ToString();
right = ExpressionHelper.GetExpressionValue(rightConstantExpression).ToString();
}
else if (leftConstantExpression == null && rightConstantExpression == null)
{
TranslateVariableExpression(firstExpression, out left);
TranslateVariableExpression(secondExpression, out right);
}
else
{
if (leftConstantExpression != null)
{
TranslateParameterizedVariableExpression(secondExpression, leftConstantExpression, node.Method.Name, out right, out left);
}
else
{
TranslateParameterizedVariableExpression(firstExpression, rightConstantExpression, node.Method.Name, out left, out right);
}
}
sb.Append(left);
switch (node.Method.Name)
{
case "Equals":
sb.Append(" = ");
break;
case "StartsWith":
case "EndsWith":
case "Contains":
sb.Append(" LIKE ");
break;
default:
throw new NotSupportedException(node.Method.Name + " isn't supported");
}
sb.Append(right);
}
}
/// <summary>
/// Initializes a new instance of the DesignTimeRepository class.
/// </summary>
/// <param name="getPrimaryKeyExpression">A lambda-expression that returns the entity primary key.</param>
/// <param name="setPrimaryKeyAction">An action that provides a way to set an entity primary key in case the primary key is a nullable type, otherwise this parameter can be ommited.</param>
public DesignTimeRepository(Expression <Func <TEntity, TPrimaryKey> > getPrimaryKeyExpression, Action <TEntity, TPrimaryKey> setPrimaryKeyAction = null)
{
this.getPrimaryKeyExpression = getPrimaryKeyExpression;
this.entityTraits = ExpressionHelper.GetEntityTraits(this, getPrimaryKeyExpression, setPrimaryKeyAction);
}
public static MvcHtmlString ExtMultiSelectFor <TModel, TValue>(this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, IEnumerable <TValue> > > expression, IEnumerable <SelectListItem> values,
IEnumerable <TValue> selectedIds, string controlId, object htmlAttributes = null)
{
var isDisabled = false;
var html = htmlAttributes == null
? new RouteValueDictionary()
: new RouteValueDictionary(htmlAttributes);
if (html["disabled"] != null && html["disabled"].ToString() == "disabled")
{
isDisabled = true;
}
var selectListItems = values.ToList();
var leftListBuilder = new TagBuilder("select");
leftListBuilder.AddCssClass("form-control");
leftListBuilder.MergeAttribute("name", "leftList" + CustomControlHelper.GetControlCount("leftList"));
leftListBuilder.MergeAttribute("id", controlId + "_from");
leftListBuilder.MergeAttribute("size", "8");
leftListBuilder.MergeAttribute("multiple", "multiple");
if (isDisabled)
{
leftListBuilder.MergeAttribute("disabled", "disabled");
}
foreach (var selectListItem in selectListItems)
{
var optionBuilder = new TagBuilder("option");
optionBuilder.MergeAttribute("value", selectListItem.Value);
optionBuilder.SetInnerText(selectListItem.Text);
leftListBuilder.InnerHtml += optionBuilder.ToString();
}
var leftColumnBuilder = new TagBuilder("div");
leftColumnBuilder.AddCssClass("col-xs-5");
leftColumnBuilder.InnerHtml = leftListBuilder.ToString();
var rightAllIconBuilder = new TagBuilder("i");
rightAllIconBuilder.AddCssClass("glyphicon");
rightAllIconBuilder.AddCssClass("glyphicon-forward");
var rightAllButtonBuilder = new TagBuilder("button");
rightAllButtonBuilder.MergeAttribute("type", "button");
rightAllButtonBuilder.MergeAttribute("id", controlId + "_rightAll");
rightAllButtonBuilder.AddCssClass("btn");
rightAllButtonBuilder.AddCssClass("btn-block");
rightAllButtonBuilder.InnerHtml = rightAllIconBuilder.ToString();
var rightSelectedIconBuilder = new TagBuilder("i");
rightSelectedIconBuilder.AddCssClass("glyphicon");
rightSelectedIconBuilder.AddCssClass("glyphicon-chevron-right");
var rightSelectedButtonBuilder = new TagBuilder("button");
rightSelectedButtonBuilder.MergeAttribute("type", "button");
rightSelectedButtonBuilder.MergeAttribute("id", controlId + "_rightSelected");
rightSelectedButtonBuilder.AddCssClass("btn");
rightSelectedButtonBuilder.AddCssClass("btn-block");
rightSelectedButtonBuilder.InnerHtml = rightSelectedIconBuilder.ToString();
var leftSelectedIconBuilder = new TagBuilder("i");
leftSelectedIconBuilder.AddCssClass("glyphicon");
leftSelectedIconBuilder.AddCssClass("glyphicon-chevron-left");
var leftSelectedButtonBuilder = new TagBuilder("button");
leftSelectedButtonBuilder.MergeAttribute("type", "button");
leftSelectedButtonBuilder.MergeAttribute("id", controlId + "_leftSelected");
leftSelectedButtonBuilder.AddCssClass("btn");
leftSelectedButtonBuilder.AddCssClass("btn-block");
leftSelectedButtonBuilder.InnerHtml = leftSelectedIconBuilder.ToString();
var leftAllIconBuilder = new TagBuilder("i");
leftAllIconBuilder.AddCssClass("glyphicon");
leftAllIconBuilder.AddCssClass("glyphicon-backward");
var leftAllButtonBuilder = new TagBuilder("button");
leftAllButtonBuilder.MergeAttribute("type", "button");
leftAllButtonBuilder.MergeAttribute("id", controlId + "_leftAll");
leftAllButtonBuilder.AddCssClass("btn");
leftAllButtonBuilder.AddCssClass("btn-block");
leftAllButtonBuilder.InnerHtml = leftAllIconBuilder.ToString();
if (isDisabled)
{
rightAllButtonBuilder.AddCssClass("disabled");
rightSelectedButtonBuilder.AddCssClass("disabled");
leftSelectedButtonBuilder.AddCssClass("disabled");
leftAllButtonBuilder.AddCssClass("disabled");
rightAllButtonBuilder.MergeAttribute("disabled", "disabled");
rightSelectedButtonBuilder.MergeAttribute("disabled", "disabled");
leftSelectedButtonBuilder.MergeAttribute("disabled", "disabled");
leftAllButtonBuilder.MergeAttribute("disabled", "disabled");
}
var middleColumnBuilder = new TagBuilder("div");
middleColumnBuilder.AddCssClass("col-xs-2");
middleColumnBuilder.InnerHtml += rightAllButtonBuilder.ToString();
middleColumnBuilder.InnerHtml += rightSelectedButtonBuilder.ToString();
middleColumnBuilder.InnerHtml += leftSelectedButtonBuilder.ToString();
middleColumnBuilder.InnerHtml += leftAllButtonBuilder.ToString();
var variableName = ExpressionHelper.GetExpressionText(expression);
var itemName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(variableName);
var rightListBuilder = new TagBuilder("select");
rightListBuilder.AddCssClass("form-control");
rightListBuilder.MergeAttribute("name", itemName);
rightListBuilder.MergeAttribute("id", controlId + "_to");
rightListBuilder.MergeAttribute("size", "8");
rightListBuilder.MergeAttribute("multiple", "multiple");
if (isDisabled)
{
rightListBuilder.MergeAttribute("disabled", "disabled");
}
foreach (var selectedId in selectedIds)
{
var selectedItem = selectListItems.FirstOrDefault(x => x.Value == selectedId.ToString());
if (selectedItem == null)
{
continue;
}
var optionBuilder = new TagBuilder("option");
optionBuilder.MergeAttribute("value", selectedItem.Value);
optionBuilder.SetInnerText(selectedItem.Text);
rightListBuilder.InnerHtml += optionBuilder.ToString();
}
var rightColumnBuilder = new TagBuilder("div");
rightColumnBuilder.AddCssClass("col-xs-5");
rightColumnBuilder.InnerHtml = rightListBuilder.ToString();
var rowBuilder = new TagBuilder("div");
rowBuilder.AddCssClass("row");
rowBuilder.InnerHtml = leftColumnBuilder.ToString();
rowBuilder.InnerHtml += middleColumnBuilder.ToString();
rowBuilder.InnerHtml += rightColumnBuilder.ToString();
var scriptBuilder = new TagBuilder("script");
scriptBuilder.MergeAttribute("type", "text/javascript");
scriptBuilder.InnerHtml = "jQuery(document).ready(function($) { $('#" + controlId + "').multiselect(); });";
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(rowBuilder.ToString());
stringBuilder.AppendLine(scriptBuilder.ToString());
return(CustomControlHelper.GenerateWithValidationMessage(htmlHelper, stringBuilder.ToString(), expression));
}
/// <summary>
/// Removes the ModelState entry corresponding to the specified property on the model. Call this when changing
/// Model values on the server after a postback, to prevent ModelState entries from taking precedence.
/// </summary>
/// <param name="modelState">The Model State to which the extension method is attached to</param>
/// <param name="model">The viewmodel that was passed in from a view, and which will be returned to a view</param>
/// <param name="propertyFetcher">A lambda expression that selects a property from the viewmodel in which to clear the ModelState information</param>
/// <remarks>
/// Code from Tobi J at http://stackoverflow.com/questions/1775170/asp-net-mvc-modelstate-clear
/// Also see comments by Peter Gluck, Metro Smurf and Proviste
/// Finally, see Bradwils http://forums.asp.net/p/1527149/3687407.aspx.
/// </remarks>
public static void RemoveStateFor <TModel, TProperty>(this ModelStateDictionary modelState, TModel model, Expression <Func <TModel, TProperty> > propertyFetcher)
{
var key = ExpressionHelper.GetExpressionText(propertyFetcher);
modelState.Remove(key);
}
public void TestQuotedStringValue()
{
LanguageGrammar<string> g = new LanguageGrammar<string>();
g.StringLiteralRule.Action = (s) => s;
// Spin up a parser for our language.
// TODO: Package this up and simplify it.
var expressionHelper = new ExpressionHelper();
//var classifierGen = new TerminalClassifier<char>();
var classifierSession = new TerminalClassifierSession<char, ParserState, int>()
.AddSkipTerminal(new Terminal<char> { Name = "Whitespace", InitialState = RegexCharNFABuilder.RegexCompiler(@"\s+") })
.CurrentCharExprIs(x => x.CurrentChar())
.GetFromMarkExprIs(x => x.GetFromMarkedPos())
.HasCurrentCharExprIs(x => x.HasCurrentChar())
.MarkPosExprIs(x => x.MarkPos())
.MoveNextCharExprIs(x => x.MoveNextChar())
.UnmarkPosExprIs(x => x.UnmarkPos());
var parserGen = new ParserGenerator<char>(expressionHelper);
var parseTableBuilder = new LRParseTableBuilder();
var parseTable = parseTableBuilder.BuildParseTable(g);
var session = parserGen.NewSession<ParserState>()
.NonTerminalValueExprIs<object>(x => x.NonTerminalValue)
.TerminalValueExprIs<string>(x => x.TerminalStringValue)
.TerminalValueExprIs<int>(x => x.TerminalIntValue)
.TerminalValueExprIs<double>(x => x.TerminalDoubleValue)
.TerminalIs(x => x.Terminal)
.NonTerminalIs(x => x.NonTerminal)
.IncludeSymbols(true)
.UseDefaultValue(true)
.DebugOutputIs(x => Debug.WriteLine(x))
.Generate("LanguageParser", parseTable, classifierSession);
// At this point, session is an Expression<ParserState,int> representing our parser.
// We can compile it into a delegate or a MethodBuilder. For the examples, we'll use a delegate.
var compiler = session.Compile();
ParserState ps = new ParserState("\"This is a quoted string\"");
Assert.AreEqual(0, compiler(ps));
Assert.AreEqual("This is a quoted string", ps.NonTerminalValue);
ps = new ParserState("\"Here are some \\t escape characters\\r\\netc...\"");
Assert.AreEqual(0, compiler(ps));
Assert.AreEqual("Here are some \t escape characters\r\netc...", ps.NonTerminalValue);
ps = new ParserState("\"And more \\\\ escape \\\" characters\"");
Assert.AreEqual(0, compiler(ps));
Assert.AreEqual("And more \\ escape \" characters", ps.NonTerminalValue);
}
/// <summary>
/// Initializes a new instance of DbRepository class.
/// </summary>
/// <param name="unitOfWork">Owner unit of work that provides context for repository entities.</param>
/// <param name="dbSetAccessor">Function that returns DbSet entities from Entity Framework DbContext.</param>
/// <param name="getPrimaryKeyExpression">Lambda-expression that returns entity primary key.</param>
public DbRepository(DbUnitOfWork <TDbContext> unitOfWork, Func <TDbContext, DbSet <TEntity> > dbSetAccessor, Expression <Func <TEntity, TPrimaryKey> > getPrimaryKeyExpression)
: base(unitOfWork, dbSetAccessor)
{
this.getPrimaryKeyExpression = getPrimaryKeyExpression;
this.entityTraits = ExpressionHelper.GetEntityTraits(this, getPrimaryKeyExpression);
}
public static MvcHtmlString SemanticEnumDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, string optionLabel = "Selecione...", object htmlAttributes = null)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("select");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
if (tag.Attributes.ContainsKey("class"))
{
tag.Attributes["class"] = $"ui fluid search dropdown {tag.Attributes["class"]}";
}
else
{
tag.Attributes.Add("class", "ui fluid search dropdown");
}
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.Attributes.Add("name", fullBindingName);
tag.InnerHtml += $"<option value=''>{optionLabel}</option>";
foreach (Enum item in Enum.GetValues(Nullable.GetUnderlyingType(typeof(TProperty)) ?? typeof(TProperty)))
{
tag.InnerHtml += $"<option value='{item}' {(Equals(item, metadata.Model) ? "selected" : string.Empty)}>{EnumDescription.Get(item)}</option>";
}
return(new MvcHtmlString(tag.ToString()));
}
public static MvcHtmlString CustomLabelFor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression, string labelText, object htmlAttributes = null)
{
TagBuilder lbl = new TagBuilder("label");
var metadata = ModelMetadata.FromLambdaExpression <TModel, TValue>(expression, html.ViewData);
if (string.IsNullOrEmpty(labelText))
{
labelText = metadata.DisplayName;
}
lbl.Attributes.Add("for", html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldId(ExpressionHelper.GetExpressionText(expression)));
lbl.SetInnerText(labelText);
// adiciona os atributos
if (htmlAttributes != null)
{
var type = htmlAttributes.GetType();
var props = type.GetProperties();
foreach (var item in props)
{
lbl.MergeAttribute(item.Name, item.GetValue(htmlAttributes, null).ToString());
}
}
return(MvcHtmlString.Create(lbl.ToString()));
}
public static MvcHtmlString SemanticDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel = "Selecione...", object htmlAttributes = null)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("div");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.AddCssClass("ui selection dropdown");
var selectListItems = selectList as SelectListItem[] ?? selectList.ToArray();
tag.InnerHtml = $"<input name='{fullBindingName}' type='hidden' value='{selectListItems.FirstOrDefault(f => f.Selected)?.Value}'>";
tag.InnerHtml += $"<div class='default text'>{optionLabel}</div>";
tag.InnerHtml += "<div class='menu'>";
foreach (var item in selectListItems)
{
tag.InnerHtml += $"<div class='item' data-value='{item.Value}' {(item.Selected ? "selected" : string.Empty)}>{item.Text}</div>";
}
tag.InnerHtml += "</div>";//close menu div
return(new MvcHtmlString(tag.ToString()));
}
public static MvcHtmlString ClientIdFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression)
{
return(MvcHtmlString.Create(htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldId(ExpressionHelper.GetExpressionText(expression))));
}
public static MvcHtmlString SemanticTextAreaFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, dynamic htmlAttributes = null)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("textarea");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.Attributes.Add("name", fullBindingName);
tag.SetInnerText(metadata.Model?.ToString() ?? string.Empty);
return(new MvcHtmlString(tag.ToString()));
}
public string GetNameFor <M, P>(M model, Expression <Func <M, P> > ex)
{
return(ExpressionHelper.GetExpressionText(ex));
}
public EntityMemberInfo GetMember <TEntity>(Expression <Func <TEntity, object> > propertySelector)
{
var propName = ExpressionHelper.GetSelectedProperty(propertySelector);
return(GetMember(propName, throwIfNotFound: true));
}
internal MemberAccessor(TypeAccessor typeAccessor, string memberName, EntityDescriptor?ed)
{
TypeAccessor = typeAccessor;
if (memberName.IndexOf('.') < 0)
{
SetSimple(ExpressionHelper.PropertyOrField(Expression.Constant(null, typeAccessor.Type), memberName).Member, ed);
}
else
{
IsComplex = true;
HasGetter = true;
HasSetter = true;
var members = memberName.Split('.');
var objParam = Expression.Parameter(TypeAccessor.Type, "obj");
var expr = (Expression)objParam;
var infos = members.Select(m =>
{
expr = ExpressionHelper.PropertyOrField(expr, m);
return(new
{
member = ((MemberExpression)expr).Member,
type = expr.Type,
});
}).ToArray();
var lastInfo = infos[infos.Length - 1];
MemberInfo = lastInfo.member;
Type = lastInfo.type;
var checkNull = infos.Take(infos.Length - 1).Any(info => info.type.IsClass || info.type.IsNullable());
// Build getter.
//
{
if (checkNull)
{
var ret = Expression.Variable(Type, "ret");
Expression MakeGetter(Expression ex, int i)
{
var info = infos[i];
var next = Expression.MakeMemberAccess(ex, info.member);
if (i == infos.Length - 1)
{
return(Expression.Assign(ret, next));
}
if (next.Type.IsClass || next.Type.IsNullable())
{
var local = Expression.Variable(next.Type);
return(Expression.Block(
new[] { local },
Expression.Assign(local, next) as Expression,
Expression.IfThen(
Expression.NotEqual(local, Expression.Constant(null)),
MakeGetter(local, i + 1))));
}
return(MakeGetter(next, i + 1));
}
expr = Expression.Block(
new[] { ret },
Expression.Assign(ret, new DefaultValueExpression(ed?.MappingSchema ?? MappingSchema.Default, Type)),
MakeGetter(objParam, 0),
ret);
}
else
{
expr = objParam;
foreach (var info in infos)
{
expr = Expression.MakeMemberAccess(expr, info.member);
}
}
GetterExpression = Expression.Lambda(expr, objParam);
}
// Build setter.
//
{
HasSetter = !infos.Any(info => info.member is PropertyInfo && ((PropertyInfo)info.member).GetSetMethod(true) == null);
var valueParam = Expression.Parameter(Type, "value");
if (HasSetter)
{
if (checkNull)
{
var vars = new List <ParameterExpression>();
var exprs = new List <Expression>();
void MakeSetter(Expression ex, int i)
{
var info = infos[i];
var next = Expression.MakeMemberAccess(ex, info.member);
if (i == infos.Length - 1)
{
exprs.Add(Expression.Assign(next, valueParam));
}
else
{
if (next.Type.IsClass || next.Type.IsNullable())
{
var local = Expression.Variable(next.Type);
vars.Add(local);
exprs.Add(Expression.Assign(local, next));
exprs.Add(
Expression.IfThen(
Expression.Equal(local, Expression.Constant(null)),
Expression.Block(
Expression.Assign(local, Expression.New(local.Type)),
Expression.Assign(next, local))));
MakeSetter(local, i + 1);
}
else
{
MakeSetter(next, i + 1);
}
}
}
MakeSetter(objParam, 0);
expr = Expression.Block(vars, exprs);
}
else
{
expr = objParam;
foreach (var info in infos)
{
expr = Expression.MakeMemberAccess(expr, info.member);
}
expr = Expression.Assign(expr, valueParam);
}
SetterExpression = Expression.Lambda(expr, objParam, valueParam);
}
else
{
var fakeParam = Expression.Parameter(typeof(int));
SetterExpression = Expression.Lambda(
Expression.Block(
new[] { fakeParam },
Expression.Assign(fakeParam, Expression.Constant(0))),
objParam,
valueParam);
}
}
}
SetExpressions();
}
/// <summary>
/// 输出设置标题图的标签（多选）
/// </summary>
/// <param name="htmlHelper">被扩展的htmlHelper实例</param>
/// <param name="expression">选择实体中类别属性的lamda表达式</param>
/// <param name="tenantTypeId">租户类型Id</param>
/// <param name="associateId">附件关联Id （默认为0）</param>
/// <param name="isMultiSelect"></param>
/// <returns>MvcHtmlString</returns>
public static MvcHtmlString SetTitleImageFor <TModel>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, string> > expression, string tenantTypeId, long associateId = 0, int maxSelect = 5)
{
if (string.IsNullOrEmpty(tenantTypeId))
{
throw new ExceptionFacade("租户类型Id不能为空");
}
string htmlFieldName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
AttachmentService <Attachment> attachementService = new AttachmentService <Attachment>(tenantTypeId);
var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
string featuredImageIds = (string)metadata.Model;
List <Attachment> attachments = new List <Attachment>();
if (!string.IsNullOrEmpty(featuredImageIds))
{
string[] attachmentIds = featuredImageIds.TrimEnd(',').Split(',');
foreach (var attachmentId in attachmentIds)
{
var attachment = attachementService.Get(long.Parse(attachmentId));
if (attachment != null)
{
attachments.Add(attachment);
}
}
}
return(htmlHelper.EditorForModel("SetTitleImage", new
{
tenantTypeId = tenantTypeId,
associateId = associateId,
htmlFieldName = htmlFieldName,
attachments = attachments,
isMultiSelect = true,
maxSelect = maxSelect
}));
}
private ValueKind AnalyzeCall(MethodCallExpression node)
{
var objValueKind = AnalyzeNode(node.Object);
var method = node.Method;
if (method.DeclaringType == typeof(EntityQueryExtensions))
{
switch (method.Name)
{
case "Include":
// Note: we do not add method name to cache key, or any args; so queries with different includes have the same key
// - and can be reused - which is what we want
var lambda = ExpressionHelper.UnwrapLambda(node.Arguments[1]);
Util.Check(lambda != null, "Invalid Include argument: {0}.", node.Arguments[1]);
_includes.Add(lambda);
return(AnalyzeNode(node.Arguments[0]));
case "WithOptions":
AddCacheKey(method.Name);
var options = (QueryOptions)ExpressionHelper.Evaluate(node.Arguments[1]);
_options |= options;
bool matches = method.GetGenericMethodDefinition() == EntityQueryExtensions.WithOptionsMethod;
return(AnalyzeNode(node.Arguments[0]));
}//switch
}
//For all other cases method.Name is included in cache key
AddCacheKey(method.Name);
//Analyze child nodes
if (method.DeclaringType == typeof(Queryable))
{
//read QueryOptions and included queries from first argument (query)
// One special case: Skip(n), Take(n). In LINQ expression they represented as int constants (not expressions)
// - we will translate them into parameters, so we can use the same query for different pages.
// This means that values of arguments should be excluded from cache key - we do it by not analyzing them.
switch (method.Name)
{
case "Take":
case "Skip":
AnalyzeNode(node.Arguments[0]); // analyze only the first arg (query), but not const value
_locals.Add(node.Arguments[1]); // int arg is turned into parameter - here we save the value to use when executing cached query definition
return(ValueKind.Db);
}
} //if
if (method.DeclaringType == typeof(NativeSqlFunctionStubs))
{
foreach (var arg in node.Arguments)
{
AnalyzeNode(arg);
}
return(ValueKind.Db);
}
if (method.IsEntitySetMethod())
{
//Add type of entity set
AddCacheKey(method.ReturnType.GetGenericArguments()[0].Name);
return(ValueKind.Db);
}
//General case
//analyze arguments
var argKinds = AnalyzeNodes(node.Arguments);
//result is max of obj and args
var result = Max(objValueKind, argKinds);
return(result);
}
public static DB2ProviderAdapter GetInstance()
{
if (_instance == null)
{
lock (_syncRoot)
if (_instance == null)
{
var assembly = Common.Tools.TryLoadAssembly(AssemblyName, ProviderFactoryName);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {AssemblyName}");
}
var connectionType = assembly.GetType($"{ClientNamespace}.DB2Connection", true) !;
var parameterType = assembly.GetType($"{ClientNamespace}.DB2Parameter", true) !;
var dataReaderType = assembly.GetType($"{ClientNamespace}.DB2DataReader", true) !;
var transactionType = assembly.GetType($"{ClientNamespace}.DB2Transaction", true) !;
var commandType = assembly.GetType($"{ClientNamespace}.DB2Command", true) !;
var dbType = assembly.GetType($"{ClientNamespace}.DB2Type", true) !;
var serverTypesType = assembly.GetType($"{ClientNamespace}.DB2ServerTypes", true) !;
var bulkCopyType = assembly.GetType($"{ClientNamespace}.DB2BulkCopy", true) !;
var bulkCopyOptionsType = assembly.GetType($"{ClientNamespace}.DB2BulkCopyOptions", true) !;
var bulkCopyColumnMappingType = assembly.GetType($"{ClientNamespace}.DB2BulkCopyColumnMapping", true) !;
var rowsCopiedEventHandlerType = assembly.GetType($"{ClientNamespace}.DB2RowsCopiedEventHandler", true) !;
var rowsCopiedEventArgs = assembly.GetType($"{ClientNamespace}.DB2RowsCopiedEventArgs", true) !;
var bulkCopyColumnMappingCollection = assembly.GetType($"{ClientNamespace}.DB2BulkCopyColumnMappingCollection", true) !;
var mappingSchema = new MappingSchema();
var db2BinaryType = loadType("DB2Binary", DataType.VarBinary) !;
var db2BlobType = loadType("DB2Blob", DataType.Blob) !;
var db2ClobType = loadType("DB2Clob", DataType.NText) !;
var db2DateType = loadType("DB2Date", DataType.Date) !;
var db2DateTimeType = loadType("DB2DateTime", DataType.DateTime, true);
var db2DecimalType = loadType("DB2Decimal", DataType.Decimal) !;
var db2DecimalFloatType = loadType("DB2DecimalFloat", DataType.Decimal) !;
var db2DoubleType = loadType("DB2Double", DataType.Double) !;
var db2Int16Type = loadType("DB2Int16", DataType.Int16) !;
var db2Int32Type = loadType("DB2Int32", DataType.Int32) !;
var db2Int64Type = loadType("DB2Int64", DataType.Int64) !;
var db2RealType = loadType("DB2Real", DataType.Single) !;
var db2Real370Type = loadType("DB2Real370", DataType.Single) !;
var db2RowIdType = loadType("DB2RowId", DataType.VarBinary) !;
var db2StringType = loadType("DB2String", DataType.NVarChar) !;
var db2TimeType = loadType("DB2Time", DataType.Time) !;
var db2TimeStampType = loadType("DB2TimeStamp", DataType.DateTime2) !;
var db2XmlType = loadType("DB2Xml", DataType.Xml) !;
var db2TimeSpanType = loadType("DB2TimeSpan", DataType.Timestamp, true, true);
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <DB2ServerTypes>(serverTypesType);
typeMapper.RegisterTypeWrapper <DB2Connection>(connectionType);
typeMapper.RegisterTypeWrapper <DB2Parameter>(parameterType);
typeMapper.RegisterTypeWrapper <DB2Type>(dbType);
typeMapper.RegisterTypeWrapper <DB2Transaction>(transactionType);
typeMapper.RegisterTypeWrapper <DB2Binary>(db2BinaryType);
// bulk copy types
typeMapper.RegisterTypeWrapper <DB2BulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <DB2RowsCopiedEventArgs>(rowsCopiedEventArgs);
typeMapper.RegisterTypeWrapper <DB2RowsCopiedEventHandler>(rowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <DB2BulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollection);
typeMapper.RegisterTypeWrapper <DB2BulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <DB2BulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.FinalizeMappings();
var db2BinaryBuilder = typeMapper.Type <DB2Binary>().Member(p => p.IsNull);
var isDB2BinaryNull = db2BinaryBuilder.BuildGetter <object>();
var dbTypeBuilder = typeMapper.Type <DB2Parameter>().Member(p => p.DB2Type);
var typeSetter = dbTypeBuilder.BuildSetter <IDbDataParameter>();
var typeGetter = dbTypeBuilder.BuildGetter <IDbDataParameter>();
var bulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((IDbConnection connection, DB2BulkCopyOptions options) => new DB2BulkCopy((DB2Connection)connection, options)),
typeMapper.BuildWrappedFactory((int source, string destination) => new DB2BulkCopyColumnMapping(source, destination)));
_instance = new DB2ProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
db2DateTimeType,
db2BinaryType,
db2BlobType,
db2ClobType,
db2DateType,
db2DecimalType,
db2DecimalFloatType,
db2DoubleType,
db2Int16Type,
db2Int32Type,
db2Int64Type,
db2RealType,
db2Real370Type,
db2RowIdType,
db2StringType,
db2TimeType,
db2TimeStampType,
db2XmlType,
db2TimeSpanType,
mappingSchema,
typeSetter,
typeGetter,
typeMapper.BuildWrappedFactory((string connectionString) => new DB2Connection(connectionString)),
isDB2BinaryNull,
bulkCopy);
Type?loadType(string typeName, DataType dataType, bool optional = false, bool obsolete = false, bool register = true)
{
var type = assembly !.GetType($"{TypesNamespace}.{typeName}", !optional);
if (type == null)
{
return(null);
}
if (obsolete && type.GetCustomAttributes(typeof(ObsoleteAttribute), false).Length > 0)
{
return(null);
}
if (register)
{
var getNullValue = Expression.Lambda <Func <object> >(Expression.Convert(ExpressionHelper.Field(type, "Null"), typeof(object))).Compile();
mappingSchema.AddScalarType(type, getNullValue(), true, dataType);
}
return(type);
}
}
}
return(_instance);
}
/// <summary>
/// Execute Join query
/// </summary>
protected virtual IEnumerable <TEntity> ExecuteJoinQuery <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(
SqlQuery sqlQuery,
IDbTransaction transaction,
params Expression <Func <TEntity, object> >[] includes)
{
if (!SqlGenerator.KeySqlProperties.Any())
{
throw new NotSupportedException("Join doesn't support without [Key] attribute");
}
var type = typeof(TEntity);
var childPropertyNames = new List <string>();
var childProperties = new List <PropertyInfo>();
var childKeyProperties = new List <PropertyInfo>();
var keyProperties = SqlGenerator.KeySqlProperties.Select(q => q.PropertyInfo).ToArray();
foreach (var s in includes)
{
var prop = ExpressionHelper.GetPropertyName(s);
childPropertyNames.Add(prop);
var childProp = type.GetProperty(prop);
if (childProp == null)
{
continue;
}
childProperties.Add(childProp);
var childType = childProp.PropertyType.IsGenericType ? childProp.PropertyType.GenericTypeArguments[0] : childProp.PropertyType;
var properties = childType.FindClassProperties().Where(ExpressionHelper.GetPrimitivePropertiesPredicate());
childKeyProperties.AddRange(properties.Where(p => p.GetCustomAttributes <KeyAttribute>().Any()));
}
if (!childKeyProperties.Any())
{
throw new NotSupportedException("Join doesn't support without [Key] attribute");
}
var lookup = new Dictionary <object, TEntity>();
const bool buffered = true;
var spiltOn = string.Join(",", childKeyProperties.Select(q => q.Name));
switch (includes.Length)
{
case 1:
Connection.Query <TEntity, TChild1, TEntity>(sqlQuery.GetSql(), (entity, child1) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
case 2:
Connection.Query <TEntity, TChild1, TChild2, TEntity>(sqlQuery.GetSql(), (entity, child1, child2) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1, child2),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
case 3:
Connection.Query <TEntity, TChild1, TChild2, TChild3, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1, child2, child3),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
case 4:
Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3, child4) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1, child2, child3, child4),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
case 5:
Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TChild5, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3, child4, child5) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1, child2, child3, child4, child5),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
case 6:
Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TChild5, TChild6, TEntity>(sqlQuery.GetSql(),
(entity, child1, child2, child3, child4, child5, child6) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames,
type, entity, child1, child2, child3, child4, child5, child6),
sqlQuery.Param, transaction, buffered, spiltOn);
break;
default:
throw new NotSupportedException();
}
return(lookup.Values);
}
public GridColumn(Expression <Func <T, TDataType> > expression, Grid <T> grid)
{
#region Setup defaults
EncodeEnabled = true;
SortEnabled = false;
SanitizeEnabled = true;
_filterWidgetTypeName = PropertiesHelper.GetUnderlyingType(typeof(TDataType)).FullName;
_grid = grid;
_cellRenderer = new GridCellRenderer();
#endregion
if (expression != null)
{
var expr = expression.Body as MemberExpression;
if (expr == null)
{
throw new ArgumentException(
string.Format("Expression '{0}' must be a member expression", expression),
"expression");
}
_constraint = expression.Compile();
_orderers.Insert(0, new OrderByGridOrderer <T, TDataType>(expression));
_filter = new DefaultColumnFilter <T, TDataType>(expression);
//Generate unique column name:
Name = PropertiesHelper.BuildColumnNameFromMemberExpression(expr);
Title = DisplayNameHelper(ModelMetadata.FromLambdaExpression <T, TDataType>(expression, new ViewDataDictionary <T>()), ExpressionHelper.GetExpressionText(expression));
}
}
public static MvcHtmlString SemanticTextCpfFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, dynamic htmlAttributes)
{
var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var validations = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
var tag = new TagBuilder("input");
InsertValidateAttribute(tag, validations);
if (htmlAttributes != null)
{
tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
}
tag.Attributes.Add("type", "text");
tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
tag.Attributes.Add("name", fullBindingName);
tag.Attributes.Add("data-gtmask", "cpf");
//tag.Attributes.Add("placeholder", "Ex.: 123.456.789-00");
tag.Attributes.Add("value", metadata.Model?.ToString() ?? string.Empty);
return(new MvcHtmlString(tag.ToString(TagRenderMode.SelfClosing)));
}
/// <summary>
/// Subtract value
/// </summary>
/// <param name="field">Field</param>
/// <param name="value">Value</param>
/// <returns>Return the newest modify object</returns>
public IModify Subtract <T>(Expression <Func <T, dynamic> > field, dynamic value)
{
return(Subtract(ExpressionHelper.GetExpressionPropertyName(field.Body), value));
}
public void TestParserSucceedsWithoutAValue()
{
LanguageGrammar<Expression> g = new LanguageGrammar<Expression>();
// Spin up a parser for our language.
// TODO: Package this up and simplify it.
var expressionHelper = new ExpressionHelper();
//var classifierGen = new TerminalClassifier<char>();
var classifierSession = new TerminalClassifierSession<char, ParserState, int>()
.CurrentCharExprIs(x => x.CurrentChar())
.GetFromMarkExprIs(x => x.GetFromMarkedPos())
.HasCurrentCharExprIs(x => x.HasCurrentChar())
.MarkPosExprIs(x => x.MarkPos())
.MoveNextCharExprIs(x => x.MoveNextChar())
.UnmarkPosExprIs(x => x.UnmarkPos());
var parserGen = new ParserGenerator<char>(expressionHelper);
var parseTableBuilder = new LRParseTableBuilder();
var parseTable = parseTableBuilder.BuildParseTable(g);
var session = parserGen.NewSession<ParserState>()
.NonTerminalValueExprIs<object>(x => x.NonTerminalValue)
.TerminalValueExprIs<string>(x => x.TerminalStringValue)
.TerminalValueExprIs<int>(x => x.TerminalIntValue)
.TerminalValueExprIs<double>(x => x.TerminalDoubleValue)
.TerminalIs(x => x.Terminal)
.NonTerminalIs(x => x.NonTerminal)
.IncludeSymbols(true)
.UseDefaultValue(true)
.DebugOutputIs(x => Debug.WriteLine(x))
.Generate("LanguageParser", parseTable, classifierSession);
// At this point, session is an Expression<ParserState,int> representing our parser.
// We can compile it into a delegate or a MethodBuilder. For the examples, we'll use a delegate.
var compiler = session.Compile();
// Create a parser state object and initialize it.
ParserState ps = new ParserState("x*y+2.0");
Assert.AreEqual(0, compiler(ps));
}
