/// <summary>
/// 消费首页
/// </summary>
/// <param name="classify"></param>
/// <param name="UserId"></param>
/// <returns></returns>
public async Task <IActionResult> Index(string title, Classify?classify, DateTime?startDate, DateTime?endDate)
{
var selectList = Common.Common.ToSelectListItems(typeof(Classify), (int?)classify);
var where = ExpressionExtension.True <ConsumeEntity>().And(x => x.UserId == CurrentUser().UserId);
if (classify.HasValue)
{
where = where.And(x => x.Classify == classify.Value);
}
if (!title.IsEmpty())
{
where = where.And(x => x.ConsumeName.Contains(title));
}
if (startDate.HasValue)
{
where = where.And(x => x.LogTime >= startDate.Value);
}
if (endDate.HasValue)
{
where = where.And(x => x.LogTime < endDate.Value);
}
var datas = await _customer.GetListAsync(where);
ComsumeModel model = new ComsumeModel()
{
Consumes = datas,
StartDate = startDate,
EndDate = endDate,
SelectListItems = selectList,
Title = title
};
return(View(model));
}
private void BindList()
{
try
{
var where = ExpressionExtension.CreateExpression <TNAPPLYFORInfo>();
if (!string.IsNullOrEmpty(txtName.Text.Trim()))
{
where = where.And(c => c.TNJOB.CN_NAME.Contains(txtName.Text.Trim()));
}
if (ddlState.SelectedValue.ToString() != "-1")
{
if (ddlState.SelectedValue.ToString() == "1")
{
where = where.And(c => c.CN_IS_LOOK == true);
}
else
{
where = where.And(c => c.CN_IS_LOOK == false);
}
}
int count = 0;
var lst = bllApplyFor.GetListByPage(AspNetPager.CurrentPageIndex, AspNetPager.PageSize, where, "CN_CREATE_DATE DESC,CR_JOB_ID DESC", out count).ToList();
rep.DataSource = lst;
rep.DataBind();
AspNetPager.RecordCount = count;
}
catch (Exception ex)
{
LogHelper.WriteErrorLog("绑定数据失败：" + ex.Message);
}
}
public GroupExpression(LambdaExpression expression, string prefix, SqlProvider provider) : base(provider)
{
this._sqlCmd = new StringBuilder();
this.Param = new DynamicParameters();
//当前定义的查询返回对象
EntityObject entity = EntityCache.QueryEntity(expression.Body.Type);
var newExpression = expression.Body as NewExpression;
foreach (var argument in newExpression.Arguments)
{
base.SpliceField.Clear();
base.Param = new DynamicParameters();
if (_sqlCmd.Length != 0)
{
_sqlCmd.Append(",");
}
//返回类型
var returnProperty = entity.Properties[base.Index];
//实体类型
Type entityType;
//验证是实体类或者是泛型
if (ExpressionExtension.IsAnyBaseEntity(returnProperty.PropertyType, out entityType))
{
throw new DapperExtensionException("GroupBy不支持导航属性!");
}
else
{
//值对象
Visit(argument);
_sqlCmd.Append($" {base.SpliceField} ");
Param.AddDynamicParams(base.Param);
}
base.Index++;
}
}
public IQueryable <TModel> ApplyQuery <TModel>(IQueryable <TModel> query, string defaultSort, string defaultOrder = "asc")
{
IQueryable <TModel> rQuery = query;
var funcType = typeof(Func <,>).MakeGenericType(typeof(TModel), typeof(TModel).GetProperty(defaultSort).PropertyType);
var expType = typeof(System.Linq.Expressions.Expression <>).MakeGenericType(funcType);
var expSort = ExpressionExtension.CreateKeySelector(typeof(TModel), Sort ?? defaultSort);
if (Order == "desc" || string.IsNullOrEmpty(Order) && defaultOrder == "desc")
{
var orderMethod = typeof(Queryable).GetMethods().FirstOrDefault(m => m.Name == "OrderByDescending" && m.GetParameters().Length == 2);
orderMethod = orderMethod.MakeGenericMethod(typeof(TModel), typeof(TModel).GetProperty(defaultSort).PropertyType);
rQuery = (IQueryable <TModel>)orderMethod.Invoke(null, new object[] { query, expSort });
}
else
{
var orderMethod = typeof(Queryable).GetMethods().FirstOrDefault(m => m.Name == "OrderBy" && m.GetParameters().Length == 2);
orderMethod = orderMethod.MakeGenericMethod(typeof(TModel), typeof(TModel).GetProperty(defaultSort).PropertyType);
rQuery = (IQueryable <TModel>)orderMethod.Invoke(null, new object[] { query, expSort });
}
if (Page.HasValue && Page.Value > 1 && Rows.HasValue && Rows.Value > 1)
{
rQuery = rQuery.Skip((Page.Value - 1) * Rows.Value).Take(Rows.Value);
}
else if (Rows.HasValue && Rows.Value > 1)
{
rQuery = rQuery.Take(Rows.Value);
}
return(rQuery);
}
// 处理 a.XX==XXX 其中 a.XX.Type 为 bool
DbExpression VisitBinary_Equal_Boolean(BinaryExpression exp)
{
var left = exp.Left;
var right = exp.Right;
ConstantExpression c = right as ConstantExpression;
if (c != null) //只处理 XXX==true 或 XXX==false XXX.Type 为 Bool
{
return(VisitBinary_Specific(left, (bool)c.Value));
}
else if ((c = left as ConstantExpression) != null) //只处理 true==XXX 或 false==XXX 其中XXX.Type 为 Bool
{
return(VisitBinary_Specific(left, (bool)c.Value));
}
else if (((ExpressionExtension.StripConvert(left)).NodeType == ExpressionType.MemberAccess && (ExpressionExtension.StripConvert(right)).NodeType == ExpressionType.MemberAccess))
{
//left right 都为 MemberExpression
return(DbExpression.Equal(this.Visit(left), this.Visit(right)));
}
else
{
// 将 left == right 转 (left==true && right==true) || (left==false && right==false)
return(BuildExpForWhenBooleanEqual(left, right, false));
}
}
public PagingResultModel <ArticleResultModel> GetArticles(ArticleQueryModel query)
{
Expression <Func <Article, bool> > where = ExpressionExtension.TrueExpression <Article>()
.AndIfHaveValue(query.Title, a => a.Title.Contains(query.Title))
.AndIfHaveValue(query.Tag, u => u.Tags.Contains(query.Tag))
.AndIfHaveValue(query.ColumnId?.ToString(), u => u.ColumnId == query.ColumnId);
var articleQuery = from article in _articleRepository.Get().Where(@where)
join column in _columnRepository.Get() on article.ColumnId equals column.Id into columnInfo
from c in columnInfo.DefaultIfEmpty()
orderby article.CreateTime descending
select new ArticleResultModel
{
Id = article.Id,
Title = article.Title,
SubTitle = article.SubTitle,
ColumnId = article.ColumnId,
ColumnName = c.Name,
Source = article.Source,
Sort = article.Sort,
Tags = article.Tags,
Content = article.Content,
CreateTime = article.CreateTime
};
var skip = query.Size * (query.Page - 1);
return(new PagingResultModel <ArticleResultModel>
{
Data = articleQuery.Skip(skip).Take(query.Size).ToList(),
Count = articleQuery.Count()
});
}
/// <summary>
/// 根据当前Http请求创建PagingQuery对象
/// </summary>
/// <returns></returns>
public void MakePagingQueryModel()
{
#region 数据验证
if (!_httpContext.Request.Form.ContainsKey(FILTER_CONDITION_LIST_KEY))
{
throw new Exception($"PagingQueryModelBuild 在请求数据中未找到{FILTER_CONDITION_LIST_KEY}");
}
if (!_httpContext.Request.Form.ContainsKey(OFFSET))
{
throw new Exception($"PagingQueryModelBuild 在请求数据中未找到{OFFSET}");
}
if (!_httpContext.Request.Form.ContainsKey(LIMIT))
{
throw new Exception($"PagingQueryModelBuild 在请求数据中未找到{LIMIT}");
}
#endregion
string filterConditionList = _httpContext.Request.Form[FILTER_CONDITION_LIST_KEY];
int offset = int.Parse(_httpContext.Request.Form[OFFSET]);
int limit = int.Parse(_httpContext.Request.Form[LIMIT]);
pagingQueryModel.Limit = limit;
pagingQueryModel.Offset = offset;
pagingQueryModel.FilterConditionList = jsonSerializer.Deserialize <List <FilterModel> >(filterConditionList);
pagingQueryModel.FilterExpression = ExpressionExtension.GetFilterExpression <TEntity>(pagingQueryModel.FilterConditionList);
}
public async Task <IDataResponse <IEnumerable <CustomerModel> > > ReadAsync(Expression <Func <CustomerModel, bool> > predicate)
{
if (_sqliteManager.DataBase == null)
{
return(null);
}
List <CustomerModelDto> resultDto = null;
IEnumerable <CustomerModel> result;
if (predicate == null)
{
resultDto = await _sqliteManager.DataBase.Table <CustomerModelDto>().ToListAsync();
result = resultDto.ToModel();
return(new DataResponse <IEnumerable <CustomerModel> >(result, true));
}
var afterParameter = Expression.Parameter(typeof(CustomerModelDto), predicate.Name);
var visitor = new ExpressionExtension(predicate, afterParameter);;
var newPredicate = Expression.Lambda <Func <CustomerModelDto, bool> >(visitor.Visit(predicate.Body), afterParameter);
resultDto = await _sqliteManager.DataBase.Table <CustomerModelDto>()
.Where(newPredicate)
.ToListAsync();
result = resultDto.ToModel();
return(new DataResponse <IEnumerable <CustomerModel> >(result, true));
}
public override string ResolveSelect(int?topNum)
{
//添加需要连接的导航表
var masterEntity = EntityCache.QueryEntity(abstractSet.TableType);
var navigationList = masterEntity.Navigations;
if (navigationList.Any())
{
provider.JoinList.AddRange(ExpressionExtension.Clone(navigationList));
}
var selectFormat = " SELECT {0} ";
var selectSql = "";
if (provider.Context.Set.SelectExpression == null)
{
var propertyBuilder = GetTableField(masterEntity);
selectSql = string.Format(selectFormat, propertyBuilder);
}
else
{
var selectExp = new SelectExpression(provider.Context.Set.SelectExpression, "", provider);
selectSql = string.Format(selectFormat, selectExp.SqlCmd);
provider.Params.AddDynamicParams(selectExp.Param);
}
return(selectSql);
}
public Pagination <MovieWithRatingViewModel> GetMovies(MovieFilterViewModel viewModel, int pageNumber, int pageSize)
{
Expression <Func <Movie, bool> > predicate = ExpressionExtension.Query <Movie>();
if (viewModel == null)
{
if (viewModel.Genre.HasValue)
{
predicate = predicate.And(it => it.Genre == viewModel.Genre);
}
if (!string.IsNullOrWhiteSpace(viewModel.Title))
{
predicate = predicate.And(it => it.Title.ToLower().Equals(viewModel.Title.ToLower()));
}
if (viewModel.CastIds != null && viewModel.CastIds.Any())
{
predicate = predicate.And(it => it.CastOfMovies.Any(x => viewModel.CastIds.Contains(x.Cast.Id)));
}
}
var moviesPagination = _movieRepository.GetMoviesWithPagination(predicate, pageNumber, pageSize);
var map = _mapper.Map <Pagination <MovieWithRatingViewModel> >(moviesPagination);
return(map);
}
public override string ResolveSelect(int?topNum)
{
//添加需要连接的导航表
var masterEntity = EntityCache.QueryEntity(abstractSet.TableType);
var navigationList = masterEntity.Navigations;
if (navigationList.Any())
{
provider.JoinList.AddRange(ExpressionExtension.Clone(navigationList));
}
//查询字段解析
StringBuilder selectSql = new StringBuilder(" SELECT ");
//去重
if (abstractSet.IsDistinct)
{
selectSql.Append(" DISTINCT ");
}
//不是自定义返回视图则显示所有字段
if (provider.Context.Set.SelectExpression == null)
{
var propertyBuilder = GetTableField(masterEntity);
selectSql.Append(propertyBuilder);
}
else //自定义查询字段
{
var selectExp = new SelectExpression(provider.Context.Set.SelectExpression, "", provider);
selectSql.Append(selectExp.SqlCmd);
provider.Params.AddDynamicParams(selectExp.Param);
}
return(selectSql.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="fieldsLambdaExpression">a => new object[] { a.Name, a.Age }</param>
/// <returns></returns>
public static List <string> Resolve(LambdaExpression fieldsLambdaExpression)
{
ParameterExpression parameterExpression = fieldsLambdaExpression.Parameters[0];
NewArrayExpression newArrayExpression = fieldsLambdaExpression.Body as NewArrayExpression;
if (newArrayExpression == null)
{
throw new NotSupportedException(fieldsLambdaExpression.ToString());
}
Type entityType = parameterExpression.Type;
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entityType);
List <string> fields = new List <string>(newArrayExpression.Expressions.Count);
foreach (var item in newArrayExpression.Expressions)
{
MemberExpression memberExp = ExpressionExtension.StripConvert(item) as MemberExpression;
if (memberExp == null)
{
throw new NotSupportedException(item.ToString());
}
if (memberExp.Expression != parameterExpression)
{
throw new NotSupportedException(item.ToString());
}
fields.Add(memberExp.Member.Name);
}
return(fields);
}
// GET: DeptController/Create
public async Task <IActionResult> Create()
{
var depts = await _deptService.GetList(ExpressionExtension.True <DepartmentEntity>());
ViewBag.Depts = depts;
return(View());
}
public DbExpression GetDbExpression(MemberExpression memberExpressionDeriveParameter)
{
Stack <MemberExpression> memberExpressions = ExpressionExtension.Reverse(memberExpressionDeriveParameter);
DbExpression ret = null;
IMappingObjectExpression moe = this;
foreach (MemberExpression memberExpression in memberExpressions)
{
MemberInfo member = memberExpression.Member;
if (moe == null && ret != null)
{
/* a.F_DateTime.Value.Date */
ret = DbExpression.MemberAccess(member, ret);
continue;
}
DbExpression e = moe.GetMemberExpression(member);
if (e == null)
{
moe = moe.GetNavMemberExpression(member);
if (moe == null)
{
if (ret == null)
{
throw new Exception();
}
else
{
ret = DbExpression.MemberAccess(member, ret);
continue;
}
}
if (ret != null)
{
throw new NotSupportedException(memberExpressionDeriveParameter.ToString());
}
}
else
{
if (ret != null)
{
throw new NotSupportedException(memberExpressionDeriveParameter.ToString());
}
ret = e;
}
}
if (ret == null)
{
throw new Exception(memberExpressionDeriveParameter.ToString());
}
return(ret);
}
static public void AddModelError <TModel>(this ModelStateDictionary modelState,
Expression <Func <TModel, Object> > expression,
string errorMessage)
{
string key = ExpressionExtension.GetExpressionText(expression);
string message = String.Format(errorMessage, key);
modelState.AddModelError(key, message);
}
/// <summary>
/// 确认缴费并分配角色
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public string CheckPayment(Guid Id)
{
var exp = ExpressionExtension.GetExpression <CookRoleAuthor>("AuthorName", "基本", ExpressionEnum.NotLike);
CookRoleAuthor author = Kily.Set <CookRoleAuthor>().Where(exp).Where(t => t.IsDelete == false).AsNoTracking().FirstOrDefault();
CookVip vip = Kily.Set <CookVip>().Where(t => t.Id == Id).FirstOrDefault();
vip.RoleId = author.Id;
return(UpdateField(vip, "RoleId") ? ServiceMessage.UPDATESUCCESS : ServiceMessage.UPDATEFAIL);
}
public long Count(TenantQueryModel query)
{
Expression <Func <Tenant, bool> > where = ExpressionExtension.TrueExpression <Tenant>()
.AndIfHaveValue(query.Name, t => t.Name.Contains(query.Name));
var queryExpress = _tenantRepository.Get(where);
return(_tenantRepository.CountAsync(queryExpress).Result);
}
/// <summary>
/// 查询带聚合导航属性的对象集合
/// </summary>
/// <typeparam name="TFirst"></typeparam>
/// <typeparam name="TSecond"></typeparam>
/// <param name="cnn"></param>
/// <param name="provider"></param>
/// <param name="transaction"></param>
/// <param name="splitOn"></param>
/// <returns></returns>
public static IEnumerable <TFirst> Query <TFirst, TSecond, TThird, TFourth, TFifth, TSixth>(this IDbConnection cnn, SqlProvider provider, IDbTransaction transaction = null)
where TFirst : IBaseEntity
where TSecond : IBaseEntity
where TThird : IBaseEntity
where TFourth : IBaseEntity
where TFifth : IBaseEntity
where TSixth : IBaseEntity
{
EntityObject firstEntity = EntityCache.QueryEntity(typeof(TFirst));
string splitOn = GetSplitOn <TFirst>(provider);
if (!string.IsNullOrEmpty(splitOn))
{
//导航属性列表
var navigationList = provider.JoinList.Where(x => x.Action == JoinAction.Navigation && x.IsMapperField).ToList();
//把所有实体的信息存下做导航关联索引
var firsts = new List <TFirst>();
cnn.Query <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TFirst>(provider.SqlString, (first, second, third, fourth, fifth, sixth) =>
{
var masterData = firsts.Find(x => x.GetId().Equals(first.GetId()));
//不存在的主表数据才添加进来，防止重复
if (masterData == null)
{
firsts.Add(first);
masterData = first;
}
//开始索引导航属性和之前实体的关系
if (second != null)
{
ExpressionExtension.SetProperValue(masterData, second, navigationList, 0);
}
if (third != null)
{
ExpressionExtension.SetProperValue(masterData, third, navigationList, 1);
}
if (fourth != null)
{
ExpressionExtension.SetProperValue(masterData, fourth, navigationList, 2);
}
if (fifth != null)
{
ExpressionExtension.SetProperValue(masterData, fifth, navigationList, 3);
}
if (sixth != null)
{
ExpressionExtension.SetProperValue(masterData, sixth, navigationList, 4);
}
return(default(TFirst));
}, provider.Params, transaction, true, splitOn);
return(firsts);
}
else
{
return(cnn.Query <TFirst>(provider.SqlString, provider.Params, transaction));
}
}
/// <summary>
/// 同步整体实体结构
/// </summary>
public void SyncStructure()
{
foreach (var entity in EntityCache.GetEntities())
{
Type type;
if (ExpressionExtension.IsAnyBaseEntity(entity.Type, out type))
{
SyncTable(entity);
}
}
}
public Pagination <UserViewModel> GetNonActiveCommonUsers(int pageNumber, int pageSize)
{
Expression <Func <User, bool> > predicate = ExpressionExtension.Query <User>();
predicate = predicate.And(user => user.RoleId == RoleIdentify.Common.Value)
.And(user => user.Status);
var usersPagination = _userRepository.GetUsersWithPagination(predicate, pageNumber, pageSize);
return(_mapper.Map <Pagination <User>, Pagination <UserViewModel> >(usersPagination));
}
/// <summary>
/// Gets the values of the property of the data entities (via expression).
/// </summary>
/// <typeparam name="TEntity">The type of the data entities.</typeparam>
/// <typeparam name="TResult">The result type of the extracted property.</typeparam>
/// <param name="entities">The list of the data entities.</param>
/// <param name="expression">The expression to be parsed.</param>
/// <returns>The values of the property of the data entities.</returns>
public static IEnumerable <TResult> GetEntitiesPropertyValues <TEntity, TResult>(IEnumerable <TEntity> entities,
Expression <Func <TEntity, object> > expression)
where TEntity : class
{
var property = ExpressionExtension.GetProperty <TEntity>(expression);
var propertyCache = PropertyCache.Get <TEntity>()
.Where(p => p.PropertyInfo == property || string.Equals(p.PropertyInfo.Name, property.Name, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
return(GetEntitiesPropertyValues <TEntity, TResult>(entities, propertyCache));
}
/// <summary>
/// 删除菜单
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public string RemoveMenu(Guid Id)
{
if (Delete <RepastMenu>(ExpressionExtension.GetExpression <RepastMenu>("Id", Id, ExpressionEnum.Equals)))
{
return(ServiceMessage.REMOVESUCCESS);
}
else
{
return(ServiceMessage.REMOVEFAIL);
}
}
public Expression <Func <EPRTA_MOVIMIENTO_DETALLE, Boolean> > AppendExpression(Expression <Func <EPRTA_MOVIMIENTO_DETALLE, Boolean> > left, Expression <Func <EPRTA_MOVIMIENTO_DETALLE, Boolean> > right)
{
Expression <Func <EPRTA_MOVIMIENTO_DETALLE, Boolean> > result;
if (left == null)
{
left = model => true;
}
result = ExpressionExtension <EPRTA_MOVIMIENTO_DETALLE> .AndAlso(left, right);
return(result);
}
public async Task <JsonResult> SelcetTwoAsync(string q, int page, int pageSize)
{
var trueExp = ExpressionExtension.True <SysDepartment>();
if (!Equals(q, null))
{
trueExp = trueExp.And(d => d.Name.Contains(q));
}
var result = await _service.GetAllPageListAsync(page, pageSize, trueExp, d => d.Name);
return(this.JsonSuccess(result));
}
public PagingResultModel <EmployeeResultModel> GetEmployees(EmployeeQueryModel query)
{
var where = ExpressionExtension.TrueExpression <SystemUser>()
.AndIfHaveValue(query.Name, u => u.Name.Contains(query.Name))
.AndIfHaveValue(query.PhoneNumber, u => u.PhoneNumber.Contains(query.PhoneNumber));
var userQuery = _userRepository.GetUsers().Where(@where);
if (query.DepartmentId != null)
{
userQuery = from u in userQuery
join uc in _userRepository.GetUserClaims() on u.Id equals uc.UserId
where uc.ClaimType == CustomClaimTypes.UserDepartment &&
uc.ClaimValue == query.DepartmentId.ToString()
select u;
}
if (query.PositionId != null)
{
userQuery = from u in userQuery
join uc in _userRepository.GetUserClaims() on u.Id equals uc.UserId
where uc.ClaimType == CustomClaimTypes.UserPosition &&
uc.ClaimValue == query.PositionId.ToString()
select u;
}
var users = from u in userQuery
let pquery = from uc in _userRepository.GetUserClaims()
where u.Id == uc.UserId && uc.ClaimType == CustomClaimTypes.UserPosition
select uc.ClaimValue
let dquery = from uc in _userRepository.GetUserClaims()
where u.Id == uc.UserId && uc.ClaimType == CustomClaimTypes.UserDepartment
select uc.ClaimValue
orderby u.Id descending
select new EmployeeResultModel
{
Id = u.Id,
PhoneNumber = u.PhoneNumber,
Avatar = u.Avatar,
Name = u.Name,
Sex = (int)u.Sex,
DepartmentId = dquery.FirstOrDefault(),
PositionIds = string.Join(',', pquery)
};
var skip = query.Size * (query.Page - 1);
return(new PagingResultModel <EmployeeResultModel>
{
Data = users.Skip(skip).Take(query.Size).ToList(),
Count = users.Count()
});
}
//处理 a.XX==XXX 其中 a.XX.Type 为 Nullable<bool>
DbExpression VisitBinary_Equal_NullableBoolean(BinaryExpression exp)
{
var left = exp.Left;
var right = exp.Right;
if (((ExpressionExtension.StripConvert(left)).NodeType == ExpressionType.MemberAccess && (ExpressionExtension.StripConvert(right)).NodeType == ExpressionType.MemberAccess))
{
//left right 都为 MemberExpression
return(DbExpression.Equal(this.Visit(left), this.Visit(right)));
}
ConstantExpression cLeft = left as ConstantExpression;
ConstantExpression cRight = right as ConstantExpression;
ConstantExpression c = null;
// left right 其中一边为常量，并且为null
if ((cLeft != null && cLeft.Value == null) || (cRight != null && cRight.Value == null))
{
// 限定只能是 a.XX == null 其中 a.XX 是 Nullable<bool> 类型，如 (bool?)(a.X>0) == null 的情况则抛出异常
if ((ExpressionExtension.StripConvert(left)).NodeType != ExpressionType.MemberAccess && (ExpressionExtension.StripConvert(right)).NodeType != ExpressionType.MemberAccess)
{
throw new Exception("无效的表达式：" + exp.ToString());
}
return(DbExpression.Equal(this.Visit(left), this.Visit(right)));
}
if (right.NodeType == ExpressionType.Convert)//只处理隐士转换情况 XXX==Convert(true) 或 XXX==Convert(false) XXX.Type 为 Nullable
{
c = ((UnaryExpression)right).Operand as ConstantExpression;
if (c != null)
{
return(VisitBinary_Specific(left, (bool)c.Value));
}
}
if (left.NodeType == ExpressionType.Convert)//只处理隐士转换情况 XXX==Convert(true) 或 XXX==Convert(false) XXX.Type 为 Nullable
{
c = ((UnaryExpression)left).Operand as ConstantExpression;
if (c != null)
{
return(VisitBinary_Specific(right, (bool)c.Value));
}
}
// a.BoolField == (a.ID > 0) 类写法
// 将 left == right 转 (left==true && right==true) || (left==false && right==false)
// 如有需要将转成 (left==true && right==true) || (left==false && right==false) || (left is null && right is null)
return(BuildExpForWhenBooleanEqual(left, right, true));
}
IObjectModel ResolveComplexMember(MemberExpression exp)
{
ParameterExpression p;
if (ExpressionExtension.IsDerivedFromParameter(exp, out p))
{
IObjectModel model = this.FindModel(p);
return(model.GetComplexMember(exp));
}
else
{
throw new Exception();
}
}
IMappingObjectExpression ResolveComplexMember(MemberExpression exp)
{
ParameterExpression p;
if (ExpressionExtension.IsDerivedFromParameter(exp, out p))
{
IMappingObjectExpression moe = this.FindMoe(p);
return(moe.GetComplexMemberExpression(exp));
}
else
{
throw new Exception();
}
}
public QjResponse <Sys_ConfigResponse> GetList(int Index = 1, int Size = 15)
{
return(Excute(() =>
{
Expression <Func <Qj.Models.Sys_Config, bool> > queryWhere = ExpressionExtension.True <Qj.Models.Sys_Config>();
int Datacount = 0;
var Listdata = new Sys_ConfigDoMain().GetPagedList(Index, Size, ref Datacount, queryWhere, (e => e.InDate), true);
var list = (from m in Listdata
select Sys_ConfigResponse.FromEntity(m)).ToList();
return Success(list, Datacount);
}));
}
protected override Expression VisitParameter(ParameterExpression parameter)
{
Expression ret = parameter;
if (parameter == this._lambda.Parameters[1])
{
if (this._expToReplace == null)
{
this._expToReplace = ExpressionExtension.MakeWrapperAccess(this._replaceObj, parameter.Type);
}
ret = this._expToReplace;
}
return(ret);
}
