private static string GetKey <TEntity, TResult>(IQueryable <TEntity> source,
Expression <Func <TEntity, bool> > predicate,
PageCondition pageCondition,
Expression <Func <TEntity, TResult> > selector, params object[] keyParams)
{
if (!typeof(TEntity).IsEntityType())
{
throw new InvalidOperationException(Resources.QueryCacheExtensions_TypeNotEntityType.FormatWith(typeof(TEntity).FullName));
}
source = source.Where(predicate);
SortCondition[] sortConditions = pageCondition.SortConditions;
if (sortConditions == null || sortConditions.Length == 0)
{
source = source.OrderBy("Id");
}
else
{
int count = 0;
IOrderedQueryable <TEntity> orderSource = null;
foreach (SortCondition sortCondition in sortConditions)
{
orderSource = count == 0
? CollectionPropertySorter <TEntity> .OrderBy(source, sortCondition.SortField, sortCondition.ListSortDirection)
: CollectionPropertySorter <TEntity> .ThenBy(orderSource, sortCondition.SortField, sortCondition.ListSortDirection);
count++;
}
source = orderSource;
}
int pageIndex = pageCondition.PageIndex, pageSize = pageCondition.PageSize;
source = source != null
? source.Skip((pageIndex - 1) *pageSize).Take(pageSize)
: Enumerable.Empty <TEntity>().AsQueryable();
IQueryable <TResult> query = source.Select(selector);
return(GetKey(query.Expression, keyParams));
}
public override List <T> GetList <T>(Expression <Func <ImageInfo, bool> > predicate,
int pageIndex,
int pageSize,
ref int total,
List <SortCondition> sortConditions = null)
{
if (total <= 0)
{
total = Repository.Entities.Count(predicate);
}
var source = Repository.Entities.Where(predicate);
if (sortConditions == null || sortConditions.Count == 0)
{
source = source.OrderByDescending(m => m.Id);
}
else
{
int count = 0;
IOrderedQueryable <ImageInfo> orderSource = null;
foreach (SortCondition sortCondition in sortConditions)
{
orderSource = count == 0
? CollectionPropertySorter <ImageInfo> .OrderBy(source, sortCondition.SortField, sortCondition.ListSortDirection)
: CollectionPropertySorter <ImageInfo> .ThenBy(orderSource, sortCondition.SortField, sortCondition.ListSortDirection);
count++;
}
source = orderSource;
}
var lst = source != null
? source.Skip((pageIndex - 1) *pageSize).Take(pageSize)
: Enumerable.Empty <ImageInfo>();
return(lst.ToList().Select(n => (T)(new T().ConvertAPIModel(n))).ToList());
// var lst = this.Entities.Where(predicate).Take(iTop).ToList().Select(n => (T)(new T().ConvertAPIModel(n))).ToList();
// return lst;
}
/// <summary>
/// 把排序条件集合转成排序查询
/// </summary>
/// <typeparam name="TEntity">要排序实体</typeparam>
/// <param name="source">源</param>
/// <param name="orderConditions">排序条件集合</param>
/// <returns></returns>
public static IOrderedQueryable <TEntity> OrderBy <TEntity>(this IQueryable <TEntity> source, OrderCondition[] orderConditions)
{
IOrderedQueryable <TEntity> orderSource = null;
if (orderConditions == null || orderConditions.Length == 0)
{
orderSource = CollectionPropertySorter <TEntity> .OrderBy(source, "Id", SortDirection.Ascending);
}
int count = 0;
foreach (OrderCondition orderCondition in orderConditions)
{
orderSource = count == 0
? CollectionPropertySorter <TEntity> .OrderBy(source, orderCondition.SortField, orderCondition.SortDirection)
: CollectionPropertySorter <TEntity> .ThenBy(orderSource, orderCondition.SortField, orderCondition.SortDirection);
count++;
}
return(orderSource);
}
public void OrderByTest()
{
IEnumerable <TestEntity> list1 = Entities.ToList();
IEnumerable <TestEntity> list2 = CollectionPropertySorter <TestEntity> .OrderBy(list1, "AddDate", ListSortDirection.Ascending);
Assert.False(list2.SequenceEqual(list1));
IOrderedEnumerable <TestEntity> temp1 = CollectionPropertySorter <TestEntity> .OrderBy(list1, "AddDate", ListSortDirection.Ascending);
IEnumerable <TestEntity> list3 = CollectionPropertySorter <TestEntity> .ThenBy(temp1, "IsDeleted", ListSortDirection.Descending);
Assert.False(list1.SequenceEqual(list3));
IQueryable <TestEntity> query1 = Entities.AsQueryable();
IQueryable <TestEntity> query2 = CollectionPropertySorter <TestEntity> .OrderBy(query1, "AddDate", ListSortDirection.Ascending);
Assert.False(query2.SequenceEqual(query1));
IOrderedQueryable <TestEntity> temp2 = CollectionPropertySorter <TestEntity> .OrderBy(query1, "AddDate", ListSortDirection.Ascending);
IEnumerable <TestEntity> query3 = CollectionPropertySorter <TestEntity> .ThenBy(temp2, "IsDeleted", ListSortDirection.Descending);
Assert.False(query1.SequenceEqual(query3));
}
/// <summary>
/// 从指定<see cref="IQueryable{T}"/>集合 中查询指定分页条件的子数据集
/// </summary>
/// <typeparam name="TEntity">动态实体类型</typeparam>
/// <typeparam name="TKey">实体主键类型</typeparam>
/// <param name="source">要查询的数据集</param>
/// <param name="predicate">查询条件谓语表达式</param>
/// <param name="pageIndex">分页索引</param>
/// <param name="pageSize">分页大小</param>
/// <param name="total">输出符合条件的总记录数</param>
/// <param name="sortConditions">排序条件集合</param>
/// <returns></returns>
public static IQueryable <TEntity> Where <TEntity, TKey>(this IQueryable <TEntity> source,
Expression <Func <TEntity, bool> > predicate,
int pageIndex,
int pageSize,
out int total,
List <SortCondition> sortConditions = null) where TEntity : EntityBase <TKey>
{
source.CheckNotNull("source");
predicate.CheckNotNull("predicate");
pageIndex.CheckGreaterThan("pageIndex", 0);
pageSize.CheckGreaterThan("pageSize", 0);
total = source.Count(predicate);
source = source.Where(predicate);
if (sortConditions == null || sortConditions.Count == 0)
{
source = source.OrderBy(m => m.Id);
}
else
{
int count = 0;
IOrderedQueryable <TEntity> orderSource = null;
foreach (SortCondition sortCondition in sortConditions)
{
orderSource = count == 0
? CollectionPropertySorter <TEntity> .OrderBy(source, sortCondition.SortField, sortCondition.ListSortDirection)
: CollectionPropertySorter <TEntity> .ThenBy(orderSource, sortCondition.SortField, sortCondition.ListSortDirection);
count++;
}
source = orderSource;
}
return(source != null
? source.Skip((pageIndex - 1) *pageSize).Take(pageSize)
: Enumerable.Empty <TEntity>().AsQueryable());
}
/// <summary>
/// 把<see cref="IOrderedQueryable{T}"/>集合继续按指定字段排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <returns></returns>
public static IOrderedQueryable <T> ThenBy <T>(this IOrderedQueryable <T> source,
string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
return(CollectionPropertySorter <T> .ThenBy(source, propertyName, sortDirection));
}
public IList <HseMessageView> GetHseStatus(RequestMessage requestMessage, PageCondition pageCondition, bool dataExport = false)
{
var before30Days = DateTime.Now.AddDays(-MonthRange);
var startDate = new DateTime(before30Days.Year, before30Days.Month, before30Days.Day);
var expression = GetExpression(requestMessage, startDate);
//expression = expression.And(x => x.CreatedDate >= startDate);
var allQuery = GetDistinctQueryable(expression);
var totalFutureQuery = allQuery.FutureCount();
var query = allQuery;
if (pageCondition.SortConditions == null || !pageCondition.SortConditions.Any())
{
query = query.OrderByDescending(x => x.Id);
}
else
{
var count = 0;
IOrderedQueryable <HseReceiverUserEntity> orderSource = null;
foreach (var sortCondition in pageCondition.SortConditions)
{
orderSource = count == 0
? CollectionPropertySorter <HseReceiverUserEntity> .OrderBy(query, sortCondition.SortField, sortCondition.ListSortDirection)
: CollectionPropertySorter <HseReceiverUserEntity> .ThenBy(orderSource, sortCondition.SortField, sortCondition.ListSortDirection);
count++;
}
query = orderSource;
}
FutureQuery <HseReceiverUserEntity> listFutureQuery;
if (pageCondition.PageSize <= 0)
{
listFutureQuery = query.Future();
}
else
{
listFutureQuery = (query != null ? query.Skip((pageCondition.PageIndex - 1) * pageCondition.PageSize).Take(pageCondition.PageSize) : Enumerable.Empty <HseReceiverUserEntity>()).AsQueryable().Future();
}
List <HseReceiverUserEntity> list;
using (var trans = new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadUncommitted
}))
{
list = listFutureQuery.ToList();
pageCondition.RowCount = totalFutureQuery.Value;
trans.Complete();
}
if (!list.Any())
{
return(new List <HseMessageView>());
}
var repliedMessages = Repository.Entities.Where(
x => x.RepliedDate >= startDate).Select(x => new { x.LillyId, x.Tel, x.Content, x.RepliedDate, x.Id, x.Origin, x.Status }).OrderByDescending(x => x.Id).ToList().Select(x => new HseReplyMessage {
LillyId = x.LillyId, Tel = x.Tel, Content = x.Content, RepliedDate = x.RepliedDate, Status = x.Status, Origin = (Origin)Enum.Parse(typeof(Origin), x.Origin, true)
}).ToList();
var repliedGroup = repliedMessages.GroupBy(x => x.LillyId);
return(list.AsParallel().Select(x =>
{
var items = repliedGroup.Where(y => y.Key.Equals(x.LillyId, StringComparison.OrdinalIgnoreCase)).SelectMany(y => y).ToList();
if (dataExport == false)
{
items.ForEach(t =>
{ t.Content = ConvertEmotion(t.Content); }
);
}
HseReplyMessage latestItem = null;
if (items.Any())
{
latestItem = items[0];
}
return new HseMessageView
{
LillyId = x.LillyId,
Name = x.Name,
Tel = x.Tel,
OneDepartment = x.FristLevelDepartmentName,
TwoDepartment = x.SecondLevelDepartmentName,
ThreeDepartment = x.ThirdLevelDepartmentName,
Location = x.Location,
EmergencyContact = x.EmergencyContact,
EmergencyName = x.EmergencyName,
ReplyMessages = items,
LatestRepliedDate = latestItem != null ? (DateTime?)latestItem.RepliedDate : null,
Status = x.Status,
LatestRepliedContent = latestItem != null ? latestItem.Content : null,
};
}).ToList());
}
/// <summary>
/// 把<see cref="IEnumerable{T}"/>集合按指定字段与排序方式进行排序
/// </summary>
/// <typeparam name="T">集合项类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <returns>排序后的数据集</returns>
public static IOrderedEnumerable <T> OrderBy <T>(this IEnumerable <T> source,
string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
return(CollectionPropertySorter <T> .OrderBy(source, propertyName, sortDirection));
}
