/// <summary>
/// 根据主键获取Entity
/// </summary>
/// <param name="Id">主键Id</param>
/// <returns>Entity</returns>
protected virtual TModel GetById(object Id)
{
TModel rv = null;
//建立基础查询
var query = DC.Set <TModel>().AsQueryable();
//循环添加其他设定的Include
if (_toInclude != null)
{
foreach (var item in _toInclude)
{
query = query.Include(item);
}
}
if (typeof(TModel).IsSubclassOf(typeof(PersistPoco)))
{
var mod = new IsValidModifier();
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <TModel>(newExp) as IOrderedQueryable <TModel>;
}
//获取数据
rv = query.CheckID(Id).AsNoTracking().SingleOrDefault();
if (rv == null)
{
return(rv);
//throw new Exception("数据不存在");
}
//如果TopBasePoco有关联的附件，则自动Include 附件名称
var fa = typeof(TModel).GetAllProperties().Where(x => x.PropertyType == typeof(FileAttachment)).ToList();
foreach (var f in fa)
{
var fname = DC.GetFKName2 <TModel>(f.Name);
var fid = typeof(TModel).GetSingleProperty(fname).GetValue(rv);
if (fid != null)
{
var fp = KnifeVirgo.HttpContext.RequestServices.GetRequiredService <VirgoFileProvider>();
var file = fp.GetFile(fid?.ToString(), false, DC);
rv.SetPropertyValue(f.Name, file);
}
}
return(rv);
}
/// <summary>
/// 进行搜索
/// </summary>
public virtual void DoSearch()
{
var cmd = GetSearchCommand();
if (cmd == null)
{
IOrderedQueryable <TModel> query = null;
//根据搜索模式调用不同的函数
switch (SearcherMode)
{
case ListVMSearchModeEnum.Search:
query = GetSearchQuery();
break;
case ListVMSearchModeEnum.Export:
query = GetExportQuery();
break;
case ListVMSearchModeEnum.Batch:
query = GetBatchQuery();
break;
case ListVMSearchModeEnum.MasterDetail:
query = GetMasterDetailsQuery();
break;
case ListVMSearchModeEnum.CheckExport:
query = GetCheckedExportQuery();
break;
case ListVMSearchModeEnum.Selector:
query = GetSelectorQuery();
break;
default:
query = GetSearchQuery();
break;
}
//如果设定了替换条件，则使用替换条件替换Query中的Where语句
if (ReplaceWhere != null)
{
var mod = new WhereReplaceModifier <TopBasePoco>(ReplaceWhere);
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <TModel>(newExp) as IOrderedQueryable <TModel>;
}
if (Searcher.SortInfo != null)
{
var mod = new OrderReplaceModifier(Searcher.SortInfo);
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <TModel>(newExp) as IOrderedQueryable <TModel>;
}
if (typeof(TModel).IsSubclassOf(typeof(PersistPoco)))
{
var mod = new IsValidModifier();
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <TModel>(newExp) as IOrderedQueryable <TModel>;
}
if (PassSearch == false)
{
//如果需要分页，则添加分页语句
if (NeedPage && Searcher.Limit != -1)
{
//获取返回数据的数量
var count = query.Count();
if (count < 0)
{
count = 0;
}
if (Searcher.Limit == 0)
{
Searcher.Limit = GlobalConstants.DEFAULT_PAGESIZE;
}
//根据返回数据的数量，以及预先设定的每页行数来设定数据量和总页数
Searcher.Count = count;
Searcher.PageCount = (int)Math.Ceiling((1.0 * Searcher.Count / Searcher.Limit));
if (Searcher.Page <= 0)
{
Searcher.Page = 1;
}
if (Searcher.PageCount > 0 && Searcher.Page > Searcher.PageCount)
{
Searcher.Page = Searcher.PageCount;
}
EntityList = query.Skip((Searcher.Page - 1) * Searcher.Limit).Take(Searcher.Limit).AsNoTracking().ToList();
}
else //如果不需要分页则直接获取数据
{
EntityList = query.AsNoTracking().ToList();
Searcher.Count = EntityList.Count;
Searcher.Limit = EntityList.Count;
Searcher.PageCount = 1;
Searcher.Page = 1;
}
}
else
{
EntityList = query.AsNoTracking().ToList();
}
}
else
{
ProcessCommand(cmd);
}
IsSearched = true;
//调用AfterDoSearch函数来处理自定义的后续操作
AfterDoSearcher();
}
/// <summary>
/// 查询数据源，并转化成SelectListItem列表
/// </summary>
/// <typeparam name="T">数据源类型</typeparam>
/// <param name="baseQuery">基础查询</param>
/// <param name="dps">数据权限</param>
/// <param name="whereCondition">条件语句</param>
/// <param name="textField">SelectListItem中Text字段对应的值</param>
/// <param name="valueField">SelectListItem中Value字段对应的值，默认为Id列</param>
/// <param name="ignorDataPrivilege">忽略数据权限判断</param>
/// <param name="SortByName">是否根据Text字段排序，默认为是</param>
/// <returns>SelectListItem列表</returns>
public static List <ComboSelectListItem> GetSelectListItems <T>(this IQueryable <T> baseQuery
, List <DataPrivilege> dps
, Expression <Func <T, bool> > whereCondition
, Expression <Func <T, string> > textField
, Expression <Func <T, string> > valueField = null
, bool ignorDataPrivilege = false
, bool SortByName = true)
where T : TopBasePoco
{
var query = baseQuery;
//如果条件不为空，则拼上条件
if (whereCondition != null)
{
query = query.Where(whereCondition);
}
//如果value字段为空，则默认使用Id字段作为value值
if (valueField == null)
{
valueField = x => x.GetID().ToString().ToLower();
}
//如果没有指定忽略权限，则拼接权限过滤的where条件
if (ignorDataPrivilege == false || dps != null)
{
query = AppendSelfDPWhere(query, dps);
}
if (typeof(T).IsSubclassOf(typeof(PersistPoco)))
{
var mod = new IsValidModifier();
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <T>(newExp) as IOrderedQueryable <T>;
}
//定义PE
ParameterExpression pe = Expression.Parameter(typeof(T));
ChangePara cp = new ChangePara();
//创建新类，形成类似 new SimpleTextAndValue() 的表达式
NewExpression newItem = Expression.New(typeof(ComboSelectListItem));
//绑定Text字段，形成类似 Text = textField 的表达式
var textMI = typeof(ComboSelectListItem).GetMember("Text")[0];
MemberBinding textBind = Expression.Bind(textMI, cp.Change(textField.Body, pe));
//绑定Value字段，形成类似 Value = valueField 的表达式
var valueMI = typeof(ComboSelectListItem).GetMember("Value")[0];
MemberBinding valueBind = Expression.Bind(valueMI, cp.Change(valueField.Body, pe));
//如果是树形结构，给ParentId赋值
MemberBinding parentBind = null;
var parentMI = typeof(ComboSelectListItem).GetMember("ParentId")[0];
if (typeof(ITreeData <T>).IsAssignableFrom(typeof(T)))
{
var parentMember = Expression.MakeMemberAccess(pe, typeof(ITreeData).GetProperty("ParentId"));
var p = Expression.Call(parentMember, "ToString", new Type[] { });
var p1 = Expression.Call(p, "ToLower", new Type[] { });
parentBind = Expression.Bind(parentMI, p1);
}
else
{
parentBind = Expression.Bind(parentMI, Expression.Constant(string.Empty));
}
//合并创建新类和绑定字段的表达式，形成类似 new SimpleTextAndValue{ Text = textField, Value = valueField} 的表达式
MemberInitExpression init = Expression.MemberInit(newItem, textBind, valueBind, parentBind);
//将最终形成的表达式转化为Lambda，形成类似 x=> new SimpleTextAndValue { Text = x.textField, Value = x.valueField} 的表达式
var lambda = Expression.Lambda <Func <T, ComboSelectListItem> >(init, pe);
List <ComboSelectListItem> rv = new List <ComboSelectListItem>();
//根据Text对下拉菜单数据排序
if (SortByName == true)
{
rv = query.Select(lambda).OrderBy(x => x.Text).ToList();
}
else
{
rv = query.Select(lambda).ToList();
}
return(rv);
}
/// <summary>
/// 查询数据源，并转化成TreeSelectListItem列表
/// </summary>
/// <typeparam name="T">数据源类型</typeparam>
/// <param name="baseQuery">基础查询</param>
/// <param name="knifeVirgo">context</param>
/// <param name="whereCondition">条件语句</param>
/// <param name="textField">表达式用来获取Text字段对应的值</param>
/// <param name="valueField">表达式用来获取Value字段对应的值，不指定则默认使用Id字段</param>
/// <param name="iconField">表达式用来获取icon字段对应的值</param>
/// <param name="urlField">表达式用来获取Url字段对应的值</param>
/// <param name="tagField">表达式用来获取Tag字段对应的值</param>
/// <param name="expandField">表达式用来获取Expanded字段对应的值，指示节点是否展开</param>
/// <param name="ignorDataPrivilege">忽略数据权限判断</param>
/// <param name="SortByName">是否根据Text字段排序，默认为是</param>
/// <returns>SelectListItem列表</returns>
public static List <TreeSelectListItem> GetTreeSelectListItems <T>(this IQueryable <T> baseQuery
, VirgoContext knifeVirgo
, Expression <Func <T, string> > textField
, Expression <Func <T, string> > valueField = null
, Expression <Func <T, string> > iconField = null
, Expression <Func <T, string> > urlField = null
, Expression <Func <T, string> > tagField = null
, Expression <Func <T, bool> > expandField = null
, bool ignorDataPrivilege = false
, bool SortByName = true)
where T : TreePoco
{
var dps = knifeVirgo?.LoginUserInfo?.DataPrivileges;
var query = baseQuery.AsNoTracking();
//如果没有指定忽略权限，则拼接权限过滤的where条件
if (ignorDataPrivilege == false)
{
query = AppendSelfDPWhere(query, knifeVirgo, dps);
}
if (typeof(IPersistPoco).IsAssignableFrom(typeof(T)))
{
var mod = new IsValidModifier();
var newExp = mod.Modify(query.Expression);
query = query.Provider.CreateQuery <T>(newExp) as IOrderedQueryable <T>;
}
//处理后面要使用的expression
//if (valueField == null)
//{
valueField = x => x.GetID().ToString().ToLower();
//}
Expression <Func <T, string> > parentField = x => x.ParentId.ToString().ToLower();
//定义PE
ParameterExpression pe = Expression.Parameter(typeof(T));
ChangePara cp = new ChangePara();
//创建新类，形成类似 new SimpleTreeTextAndValue() 的表达式
NewExpression newItem = Expression.New(typeof(TreeSelectListItem));
//绑定Text字段，形成类似 Text = textField 的表达式
var textMI = typeof(TreeSelectListItem).GetMember("Text")[0];
MemberBinding textBind = Expression.Bind(textMI, cp.Change(textField.Body, pe));
//绑定Value字段，形成类似 Value = valueField 的表达式
var valueMI = typeof(TreeSelectListItem).GetMember("Id")[0];
MemberBinding valueBind = Expression.Bind(valueMI, cp.Change(valueField.Body, pe));
//绑定ParentId字段，形成类似 Value = valueField 的表达式
var parentMI = typeof(TreeSelectListItem).GetMember("ParentId")[0];
MemberBinding parentBind = Expression.Bind(parentMI, cp.Change(parentField.Body, pe));
//绑定Url字段，形成类似 Value = valueField 的表达式
MemberBinding urlBind = null;
var urlMI = typeof(TreeSelectListItem).GetMember("Url")[0];
if (urlField != null)
{
urlBind = Expression.Bind(urlMI, cp.Change(urlField.Body, pe));
}
else
{
urlBind = Expression.Bind(urlMI, Expression.Constant(string.Empty));
}
//绑定icon字段，形成类似 ICon = iconField 的表达式
MemberBinding iconBind = null;
var iconMI = typeof(TreeSelectListItem).GetMember("ICon")[0];
if (iconField != null)
{
iconBind = Expression.Bind(iconMI, cp.Change(iconField.Body, pe));
}
else
{
iconBind = Expression.Bind(iconMI, Expression.Constant(string.Empty));
}
//绑定Tag字段，形成类似 Value = valueField 的表达式
MemberBinding tagBind = null;
var tagMI = typeof(TreeSelectListItem).GetMember("Tag")[0];
if (tagField != null)
{
tagBind = Expression.Bind(tagMI, cp.Change(tagField.Body, pe));
}
else
{
tagBind = Expression.Bind(tagMI, Expression.Constant(""));
}
//绑定Tag字段，形成类似 Value = valueField 的表达式
MemberBinding expandBind = null;
var expandMI = typeof(TreeSelectListItem).GetMember("Expended")[0];
if (expandField != null)
{
expandBind = Expression.Bind(expandMI, cp.Change(expandField.Body, pe));
}
else
{
expandBind = Expression.Bind(expandMI, Expression.Constant(false));
}
//合并创建新类和绑定字段的表达式，形成类似 new SimpleTextAndValue{ Text = textField, Value = valueField} 的表达式
MemberInitExpression init = Expression.MemberInit(newItem, textBind, valueBind, iconBind, parentBind, urlBind, tagBind, expandBind);
//将最终形成的表达式转化为Lambda，形成类似 x=> new SimpleTextAndValue { Text = x.textField, Value = x.valueField} 的表达式
var lambda = Expression.Lambda <Func <T, TreeSelectListItem> >(init, pe);
List <TreeSelectListItem> rv = null;
//根据Text对下拉菜单数据排序
if (SortByName == true)
{
rv = query.Select(lambda).OrderBy(x => x.Text).ToList();
}
else
{
rv = query.Select(lambda).ToList();
}
rv.ForEach(x =>
{
x.Children = rv.Where(y => y.ParentId == x.Id).ToList();
});
return(rv.Where(x => string.IsNullOrEmpty(x.ParentId)).ToList());
}
