public override LambdaQuery <T> OrderBy <TResult>(System.Linq.Expressions.Expression <Func <T, TResult> > expression, bool desc = true)
{
//var sortBuild = Builders<T>.Sort;
var field = GetSelectField(false, expression.Body, false, typeof(T)).First();
if (desc)
{
_MongoDBSort = _MongoDBSort.Descending(field.MemberName);
}
else
{
_MongoDBSort = _MongoDBSort.Ascending(field.MemberName);
}
return(this);
}
public static SortDefinition <T> getSortDefinition(Dictionary <string, int> sortfields)
{
SortDefinition <T> sd = null;
foreach (var item in sortfields)
{
if (sd == null)
{
if (item.Value == 1)
{
sd = Builders <T> .Sort.Ascending(item.Key);
}
else
{
sd = Builders <T> .Sort.Descending(item.Key);
}
}
else
{
if (item.Value == 1)
{
sd.Ascending(item.Key);
}
else
{
sd.Descending(item.Key);
}
}
}
return(sd);
}
/// <summary>
/// 构造排序
/// </summary>
/// <param name="interfaceSortId"></param>
/// <returns></returns>
private SortDefinition <BsonDocument> StructureSortDefinition(Guid interfaceSortId)
{
var builder = new SortDefinitionBuilder <BsonDocument>();
SortDefinition <BsonDocument> sort = null;
if (interfaceSortId == Guid.Empty)
{
return(builder.Ascending("_id"));
}
var sorts = _interfaceSortRepository.GetInterfaceSortByParentId(interfaceSortId) ?? new List <InterfaceSort>(0);
foreach (var item in sorts)
{
switch (item.GetSortType())
{
case SortTypeEnum.DESC:
sort = sort?.Descending(item.MetaFieldShortCode) ?? builder.Descending(item.MetaFieldShortCode);
break;
case SortTypeEnum.ASC:
sort = sort?.Ascending(item.MetaFieldShortCode) ?? builder.Ascending(item.MetaFieldShortCode);
break;
default:
break;
}
}
return(sort);
}
/// <summary>
/// Creates a SortDefintiion for the sort order
/// </summary>
/// <remarks>Error codes follow the format DAL-SM-5XX</remarks>
/// <typeparam name="T">The document type</typeparam>
/// <param name="sort">The sort string</param>
/// <returns>A generated Sort Definition</returns>
public static SortDefinition <T> CreateSort <T>(string sort)
{
var builder = Builders <T> .Sort;
SortDefinition <T> sortDef = null;
if (String.IsNullOrEmpty(sort))
{
return(sortDef);
}
foreach (string s in sort.Split(','))
{
string[] sortItemParts = s.Trim().Split(' ');
string sortItemDirection = sortItemParts.Length > 1 ? sortItemParts[1] : "asc";
var sortField = ConvertCase <T>(sortItemParts[0]);
if (sortItemDirection.ToLower() == "desc")
{
sortDef = (sortDef == null) ? builder.Descending(sortField) : sortDef.Descending(sortField);
}
else
{
sortDef = (sortDef == null) ? builder.Ascending(sortField) : sortDef.Ascending(sortField);
}
}
return(sortDef);
}
public override LambdaQuery <T> OrderBy <TResult>(System.Linq.Expressions.Expression <Func <T, TResult> > expression, bool desc = true)
{
//var sortBuild = Builders<T>.Sort;
var parameters = expression.Parameters.Select(b => b.Type).ToArray();
var field = GetSelectField(false, expression.Body, false, parameters).mapping.First();
if (desc)
{
_MongoDBSort = _MongoDBSort.Descending(field.ResultName);
}
else
{
_MongoDBSort = _MongoDBSort.Ascending(field.ResultName);
}
return(this);
}
SortDefinition <TEntity> BuildSortDefinitionFromFilterOptions(FilterOptions <TEntity> filterOptions)
{
if (filterOptions?.SortFields == null)
{
return(null);
}
var builder = new SortDefinitionBuilder <TEntity>();
SortDefinition <TEntity> sortDefinition = null;
foreach (var sortField in filterOptions.SortFields)
{
switch (sortField.Order)
{
case FilterOptions <TEntity> .SortOrderEnum.Ascending:
sortDefinition = sortDefinition?.Ascending(sortField.Field)
?? builder.Ascending(sortField.Field);
break;
case FilterOptions <TEntity> .SortOrderEnum.Descending:
sortDefinition = sortDefinition?.Descending(sortField.Field)
?? builder.Descending(sortField.Field);
break;
}
}
return(sortDefinition);
}
private static SortDefinition <BsonDocument> CreateSortBy(IList <Tuple <string, SortOrder> > sortItems)
{
if (sortItems.Any() == false)
{
return(null);
}
SortDefinition <BsonDocument> sortDefinition = null;
var first = sortItems.FirstOrDefault();
if (first.Item2 == SortOrder.Ascending)
{
sortDefinition = Builders <BsonDocument> .Sort.Ascending(first.Item1);
}
else
{
sortDefinition = Builders <BsonDocument> .Sort.Descending(first.Item1);
}
sortItems.Remove(first);
foreach (Tuple <string, SortOrder> sortItem in sortItems)
{
if (sortItem.Item2 == SortOrder.Ascending)
{
sortDefinition = sortDefinition.Ascending(sortItem.Item1);
}
else
{
sortDefinition = sortDefinition.Descending(sortItem.Item1);
}
}
return(sortDefinition);
}
/// <summary>
/// 初始化排序条件 主要当条件为空时 会默认以ObjectId递增的一个排序
/// </summary>
/// <param name="sortBy"></param>
/// <returns></returns>
private SortDefinition <BsonDocument> InitSortBy(string sortBy, params string[] fields)
{
SortDefinitionBuilder <BsonDocument> sortBuilder = Builders <BsonDocument> .Sort;
SortDefinition <BsonDocument> sortFilter = null;
if (sortBy == null)
{
//默认ObjectId 递增
sortFilter = Builders <BsonDocument> .Sort.Descending(OBJECTID_KEY); // new BsonDocument(OBJECTID_KEY, 1);
}
else
{
if (sortBy.ToLower() == "asc")
{
foreach (var item in fields)
{
if (sortFilter == null)
{
sortFilter = sortBuilder.Ascending(item);
}
else
{
sortFilter = sortFilter.Ascending(item);
}
}
}
else if (sortBy.ToLower() == "desc")
{
foreach (var item in fields)
{
if (sortFilter == null)
{
sortFilter = sortBuilder.Descending(item);
}
else
{
sortFilter = sortFilter.Descending(item);
}
}
}
else
{
sortFilter = sortFilter.Descending(OBJECTID_KEY);
}
}
return(sortFilter);
}
public ItemList Query(string collection, DataQuery query)
{
FilterDefinition <BsonDocument> filter = FilterDefinition <BsonDocument> .Empty;
var dataContext = new Dictionary <string, object>();
dataContext["expando"] = query.Expando;
if (query.RawQuery != null)
{
filter = new JsonFilterDefinition <BsonDocument>(query.RawQuery);
}
InvokeAlterQuery(collection, filter);
IFindFluent <BsonDocument, BsonDocument> results = _mongoService
.GetCollection <BsonDocument>(collection).Find <BsonDocument>(filter)
.Skip((query.PageNumber - 1) * query.PageSize)
.Limit(query.PageSize);
if (query.Sort != null)
{
var sort = new SortDefinitionBuilder <BsonDocument>();
SortDefinition <BsonDocument> sortDef = null;
foreach (var sortable in query.Sort)
{
FieldDefinition <BsonDocument> field = sortable.Field;
if (sortable.Ascending)
{
sortDef = (sortDef == null) ? sort.Ascending(field) : sortDef.Ascending(field);
}
else
{
sortDef = (sortDef == null) ? sort.Descending(field) : sortDef.Descending(field);
}
}
results = results.Sort(sortDef);
}
long count = Count(collection, filter);
List <BsonDocument> list = results.ToList();
//sanitize id format
foreach (BsonDocument item in list)
{
item["_id"] = item["_id"].ToString();
}
string json = list.ToJson(js);
var result = JArray.Parse(json);
for (int i = 0; i < result.Count; i++)
{
var node = (JObject)result[i];
InvokeProcess(collection, ref node, PipelineStage.PostOperation, DataOperation.Read, dataContext);
}
return(new ItemList(result, (int)count, query.PageNumber, query.PageSize));
}
public async Task <BaseResultModel <T> > GetPageListAsync(int pageIndex, int pageSize, Dictionary <string, string> sortDic, Expression <Func <T, bool> > expression)
{
BaseResultModel <T> baseResultModel = new BaseResultModel <T>();
string msg = string.Empty;
try
{
var filters = new List <FilterDefinition <T> >();
filters.Add(GetAction(expression));
FilterDefinition <T> filter = Builders <T> .Filter.And(filters);
baseResultModel.total = await collection.CountDocumentsAsync(filter);
var sort = Builders <T> .Sort;
SortDefinition <T> sortDefinition = null;
foreach (var item in sortDic)
{
if (null == sortDefinition)
{
if (item.Value == "d")
{
sortDefinition = sort.Descending(item.Key);
}
else
{
sortDefinition = sort.Ascending(item.Key);
}
}
else
{
if (item.Value == "d")
{
sortDefinition = sortDefinition.Descending(item.Key);
}
else
{
sortDefinition = sortDefinition.Ascending(item.Key);
}
}
}
FindOptions <T, T> findOptions = new FindOptions <T, T>();
findOptions.Limit = pageSize;
findOptions.Skip = (pageIndex - 1) * pageSize;
findOptions.Sort = sortDefinition;
//Pageable pageable = PageRequest.of(pageNUmber, pageSize);
var fullCollectioin = await collection.FindAsync(filter, findOptions);
baseResultModel.rows = await fullCollectioin.ToListAsync();
baseResultModel.success = true;
}
catch (Exception ex)
{
baseResultModel.success = false;
baseResultModel.msg = ex.Message;
}
return(baseResultModel);
}
/// <summary>
/// 获取Top多少条数据
/// </summary>
/// <param name="limit">条数</param>
/// <param name="sortDic">排序字典</param>
/// <param name="expression">条件</param>
/// <returns></returns>
public async Task <List <T> > GetListAsync(int limit, Dictionary <string, string> sortDic, Expression <Func <T, bool> > expression)
{
List <T> list = new List <T>();
try
{
var filters = new List <FilterDefinition <T> >();
filters.Add(GetAction(expression));
FilterDefinition <T> filter = Builders <T> .Filter.And(filters);
var sort = Builders <T> .Sort;
SortDefinition <T> sortDefinition = null;
foreach (var item in sortDic)
{
if (null == sortDefinition)
{
if (item.Value == "d")
{
sortDefinition = sort.Descending(item.Key);
}
else
{
sortDefinition = sort.Ascending(item.Key);
}
}
else
{
if (item.Value == "d")
{
sortDefinition = sortDefinition.Descending(item.Key);
}
else
{
sortDefinition = sortDefinition.Ascending(item.Key);
}
}
}
FindOptions <T, T> findOptions = new FindOptions <T, T>();
findOptions.Limit = limit;
findOptions.Sort = sortDefinition;
//Pageable pageable = PageRequest.of(pageNUmber, pageSize);
var fullCollectioin = await collection.FindAsync(filter, findOptions);
list = await fullCollectioin.ToListAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(list);
}
public SortDefinition <BsonDocument> GetSortDefinitionBySortFields(int metaObjectId, SortField[] sortFields)
{
var builder = new SortDefinitionBuilder <BsonDocument>();
if (sortFields == null || !sortFields.Any())
{
//默认给更新时间倒序排列
sortFields = new[] { new SortField {
Column = "ModifyTime", IsDesc = true
} };
}
//获取全部字段
var metaFieldDic = GetMetaFieldDicUnDeleted(metaObjectId);
SortDefinition <BsonDocument> sort = null;
foreach (var item in sortFields)
{
if (!metaFieldDic.ContainsKey(item.Column))
{
throw new ArgumentNullException(item.Column, $"field of {item.Column} is not exist in current MetaObject");
}
if (item.IsDesc)
{
if (sort == null)
{
sort = builder.Descending(item.Column);
}
else
{
sort = sort.Descending(item.Column);
}
}
else
{
if (sort == null)
{
sort = builder.Ascending(item.Column);
}
else
{
sort = sort.Ascending(item.Column);
}
}
}
return(sort);
}
private static SortDefinition <T> CreateODataSort <T>(IODataQuery query, bool check = false)
{
var orderby = query.Order;
SortDefinitionBuilder <T> sortBuilder = Builders <T> .Sort;
SortDefinition <T> sortDefinition = null;
SortDefinition <T> defaultSortDefinition = sortBuilder.Descending("CreateDate");
if (String.IsNullOrEmpty(orderby))
{
return(defaultSortDefinition);
}
var sections = orderby.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (var section in sections)
{
var order = section.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
var field = order.FirstOrDefault();
var direction = "asc";
if (check && !typeof(T).HasField(field))
{
continue;
}
if (order.LastOrDefault().ToLower() == "desc")
{
direction = "desc";
}
if (sortDefinition == null)
{
sortDefinition = direction == "asc"
? sortBuilder.Ascending(field)
: sortBuilder.Descending(field);
}
sortDefinition = direction == "asc"
? sortDefinition.Ascending(field)
: sortDefinition.Descending(field);
}
return(sortDefinition ?? defaultSortDefinition);
}
public SortDefinition <BsonDocument> GetSortDefinitionBySortFields(QueryPiplineContext queryPiplineContext, SortField[] sortFields)
{
var builder = new SortDefinitionBuilder <BsonDocument>();
if (sortFields == null || !sortFields.Any())
{
return(builder.Ascending("_id"));
}
//获取全部字段
SortDefinition <BsonDocument> sort = null;
var metaFieldDic = queryPiplineContext.MetaFieldsUnDeletedCodeDic;
foreach (var item in sortFields)
{
if (!metaFieldDic.ContainsKey(item.Column))
{
throw new ArgumentNullException(item.Column, $"field of {item.Column} is not exist in current MetaObject");
}
if (item.IsDesc)
{
if (sort == null)
{
sort = builder.Descending(item.Column);
}
else
{
sort = sort.Descending(item.Column);
}
}
else
{
if (sort == null)
{
sort = builder.Ascending(item.Column);
}
else
{
sort = sort.Ascending(item.Column);
}
}
}
return(sort);
}
public IList <TEntity> GetSelected(string query, int pageNo, int pageSize, string sortBy, string sortDirection, out long totalCount)
{
try
{
SortDefinition <TEntity> sortDefinition = null;
SortDefinitionBuilder <TEntity> sortDefinitionBuilder = Builders <TEntity> .Sort;
switch (sortDirection)
{
case "asc":
if (sortDefinition == null)
{
sortDefinition = sortDefinitionBuilder.Ascending(sortBy);
}
else
{
sortDefinition = sortDefinition.Ascending(sortBy);
}
break;
case "desc":
if (sortDefinition == null)
{
sortDefinition = sortDefinitionBuilder.Descending(sortBy);
}
else
{
sortDefinition = sortDefinition.Descending(sortBy);
}
break;
}
var result = collection.Find(query).ToList();
totalCount = result.Count();
return(collection.Find(query).Sort(sortDefinition).Skip(pageSize * (pageNo - 1)).Limit(pageSize).ToList());
}
catch (Exception ex)
{
totalCount = 0;
return(new List <TEntity>());
}
}
private SortDefinition <T> BuildSort()
{
SortDefinition <T> sort = null;
if (_sorts != null)
{
foreach (var oneSort in _sorts)
{
if (oneSort.Order == SortOrder.Ascending)
{
sort.Ascending(oneSort.SortKey.Name.UppercaseFirstLetter());
}
else
{
sort.Descending(oneSort.SortKey.Name.UppercaseFirstLetter());
}
}
}
return(sort);
}
/// <summary>
/// Converts sorting parameters to MongoDB sort definition.
/// </summary>
/// <param name="sorting">The sorting parameters to convert.</param>
/// <returns>The converted MongoDB sorting parameters.</returns>
public static SortDefinition <BsonDocument> ToSortDefinition(this SortingParameters sorting)
{
if (sorting == null)
{
return(null);
}
var builder = Builders <BsonDocument> .Sort;
SortDefinition <BsonDocument> result = null;
foreach (var sort in sorting.Sorts)
{
if (result == null)
{
if (sort.Direction == SortingDirection.Ascending)
{
result = builder.Ascending(sort.Attribute);
}
else
{
result = builder.Descending(sort.Attribute);
}
}
else
{
if (sort.Direction == SortingDirection.Ascending)
{
result = result.Ascending(sort.Attribute);
}
else
{
result = result.Descending(sort.Attribute);
}
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="E"></typeparam>
public void Apply <T, E>()
where T : class, IDto <E, T>, new()
where E : class, IDocumentEntity, IEntity, new()
{
FilterDefinition <E> filter = (CreateFilter == null) ? null : (FilterDefinition <E>)CreateFilter?.Invoke();
ProjectionDefinition <E> projection = (CreateProjection == null) ? null : (ProjectionDefinition <E>)CreateProjection?.Invoke();
filter = CreateFilters <E>(Filter, filter);
if (IsAggregate)
{
var query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Aggregate().Match(filter).Group(projection);
}
else
{
IFindFluent <E, E> query = null;
if (filter != null)
{
query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Find(filter);
}
else
{
query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Find(x => true);
}
if (projection != null)
{
query.Project(projection);
}
var sortB = Builders <E> .Sort;
SortDefinition <E> sort = null;
foreach (var item in Order)
{
switch (item.Direction.ToString())
{
case "-":
{
if (sort == null)
{
sort = sortB.Descending(item.Property);
}
else
{
sort = sort.Descending(item.Property);
}
break;
}
case "+":
{
if (sort == null)
{
sort = sortB.Ascending(item.Property);
}
else
{
sort = sort.Ascending(item.Property);
}
break;
}
}
}
if (sort != null)
{
query.Sort(sort);
}
PageSize = PageSize ?? 1;
RecordCount = query.Count();
PageCount = (RecordCount / PageSize);
PageCount += (PageCount < ((float)RecordCount / (float)PageSize)) ? 1 : 0;
Data = new T().SetEntity(query.Skip((PageIndex - 1) * PageSize).Limit(PageSize).ToList <E>());
}
}
public IList <TEntity> SearchFor(PagingFiltering criteria, int pageNo, int pageSize, out long totalCount)
{
try
{
var resultItems = new List <TEntity>();
FilterDefinition <TEntity> filter = null;
SortDefinition <TEntity> sortDefinition = null;
SortDefinitionBuilder <TEntity> sortDefinitionBuilder = Builders <TEntity> .Sort;
int searchval;
if (null != criteria.filter)
{
// TODO: Need expand query filter base on datatype.
if (criteria.filter.Filters != null)
{
foreach (var item in criteria.filter.Filters)
{
switch (item.Operator)
{
case "startswith":
if (int.TryParse(item.Value, out searchval))
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + searchval)));
}
else
{
filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + searchval)));
}
}
else
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + item.Value)));
}
else
{
filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + item.Value)));
}
}
break;
case "eq":
if (item.DataType == "int")
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Eq(item.Field, item.intValue);
}
else
{
filter = filter & Builders <TEntity> .Filter.Eq(item.Field, item.intValue);
}
}
else
{
if (int.TryParse(item.Value, out searchval))
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Eq(item.Field, searchval);
}
else
{
filter = filter & Builders <TEntity> .Filter.Eq(item.Field, searchval);
}
}
else
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Eq(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Eq(item.Field, item.Value);
}
}
}
break;
case "neq":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Ne(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Ne(item.Field, item.Value);
}
break;
case "contains":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Regex(item.Field, "/" + item.Value + "/i");
}
else
{
filter = (filter | Builders <TEntity> .Filter.Regex(item.Field, "/" + item.Value + "/i"));
}
int result = 0;
//As we are not getting DataType of field in search cases so checking that the given search value is a integer. If yes adding it as a number filter as well.
if ((!string.IsNullOrEmpty(item.Value)) && int.TryParse(item.Value, out result))
{
filter = (filter | Builders <TEntity> .Filter.Eq(item.Field, result));
}
break;
case "endswith":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex(item.Value + "$")));
}
else
{
filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex(item.Value + "$")));
}
break;
case "lt":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Lt(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Lt(item.Field, item.Value);
}
break;
case "gt":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Gt(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Gt(item.Field, item.Value);
}
break;
case "lte":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Lte(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Lte(item.Field, item.Value);
}
break;
case "gte":
if (filter == null)
{
filter = Builders <TEntity> .Filter.Gte(item.Field, item.Value);
}
else
{
filter = filter & Builders <TEntity> .Filter.Gte(item.Field, item.Value);
}
break;
default:
break;
}
}
}
}
//Added new sort block
if (null != criteria.Sort)
{
foreach (var sort in criteria.Sort)
{
if (!string.IsNullOrEmpty(sort.Field))
{
switch (sort.Dir)
{
case "asc":
if (sortDefinition == null)
{
sortDefinition = sortDefinitionBuilder.Ascending(sort.Field);
}
else
{
sortDefinition = sortDefinition.Ascending(sort.Field);
}
break;
case "desc":
if (sortDefinition == null)
{
sortDefinition = sortDefinitionBuilder.Descending(sort.Field);
}
else
{
sortDefinition = sortDefinition.Descending(sort.Field);
}
break;
}
}
}
}
FilterDefinition <TEntity> filterCriteria;
if (filter == null)
{
filterCriteria = Builders <TEntity> .Filter.Empty;
}
else
{
filterCriteria = filter;
}
IFindFluent <TEntity, TEntity> cursor;
if (sortDefinition == null)
{
cursor = collection.Find(filterCriteria);
}
else
{
cursor = collection.Find(filterCriteria).Sort(sortDefinition);
}
totalCount = cursor.Count();
cursor = cursor.Skip(pageSize * (pageNo - 1));
if (pageSize >= 0)
{
cursor = cursor.Limit(pageSize);
}
resultItems.AddRange(cursor.ToList());
return(resultItems);
}
catch (Exception ex)
{
logManager.LogMessage("Message: " + ex.Message + Environment.NewLine + "StackTrace: " + ex.StackTrace + Environment.NewLine + "InnerException: " + ex.InnerException, "", "", LogLevel.Error);
totalCount = 0;
return(new List <TEntity>());
}
}
public ResponseObject <List <ToDoMgModel> > GetToDoModel(RequestGet requestObject, CurrentUser currentUser)
{
ResponseObject <List <ToDoMgModel> > responseObject = new ResponseObject <List <ToDoMgModel> >();
responseObject.Code = 0;
try
{
List <ToDoMgModel> result = new List <ToDoMgModel>();
Expression <Func <ToDoMgModel, bool> > queryConditionLam = (x) => x.To == currentUser.UserID && x.CompanyID == currentUser.CompanyID;
if (requestObject.QueryConditions != null && requestObject.QueryConditions.Count > 0)
{
var conditionals = SqlSugarUtil.GetConditionalFull(requestObject.QueryConditions).Where(p => !string.IsNullOrWhiteSpace(p.FieldValue)).ToList();
var whereConditional = ConditionalModelToExpression.BuildExpression <ToDoMgModel>(conditionals);
queryConditionLam = queryConditionLam.And(whereConditional);
}
SortDefinition <ToDoMgModel> sort = null;
//排序条件
if (requestObject.OrderByConditions != null && requestObject.OrderByConditions.Count > 0)
{
foreach (var item in requestObject.OrderByConditions)
{
var exp = SqlSugarUtil.GetExpression <ToDoMgModel>(item.Column);
if (exp == null)
{
continue;
}
if (item.Condition.ToLower() == "asc")
{
if (sort == null)
{
sort = Builders <ToDoMgModel> .Sort.Ascending(exp);
}
else
{
sort = sort.Ascending(exp);
}
}
else if (item.Condition.ToLower() == "desc")
{
if (sort == null)
{
sort = Builders <ToDoMgModel> .Sort.Descending(exp);
}
else
{
sort = sort.Descending(exp);
}
}
}
}
long totalNum = 0;
if (requestObject.IsPaging == true)
{
result = MongoDbUtil.GetDoc <ToDoMgModel>(queryConditionLam, requestObject.PageIndex, requestObject.PageSize, sort, ref totalNum);
}
else
{
result = MongoDbUtil.GetDoc <ToDoMgModel>(queryConditionLam, sort).ToList();
}
return(ResponseUtil <List <ToDoMgModel> > .SuccessResult(result, totalNum));
}
catch (Exception ex)
{
return(ResponseUtil <List <ToDoMgModel> > .FailResult(null, ex.Message));
}
}
private async Task <IEnumerable <T> > Find <T>(ObjectSerializer Serializer, IMongoCollection <BsonDocument> Collection,
int Offset, int MaxCount, FilterDefinition <BsonDocument> BsonFilter, params string[] SortOrder)
{
IFindFluent <BsonDocument, BsonDocument> ResultSet = Collection.Find <BsonDocument>(BsonFilter);
if (SortOrder.Length > 0)
{
SortDefinition <BsonDocument> SortDefinition = null;
foreach (string SortBy in SortOrder)
{
if (SortDefinition == null)
{
if (SortBy.StartsWith("-"))
{
SortDefinition = Builders <BsonDocument> .Sort.Descending(Serializer.ToShortName(SortBy.Substring(1)));
}
else
{
SortDefinition = Builders <BsonDocument> .Sort.Ascending(Serializer.ToShortName(SortBy));
}
}
else
{
if (SortBy.StartsWith("-"))
{
SortDefinition = SortDefinition.Descending(Serializer.ToShortName(SortBy.Substring(1)));
}
else
{
SortDefinition = SortDefinition.Ascending(Serializer.ToShortName(SortBy));
}
}
}
ResultSet = ResultSet.Sort(SortDefinition);
}
if (Offset > 0)
{
ResultSet = ResultSet.Skip(Offset);
}
if (MaxCount < int.MaxValue)
{
ResultSet = ResultSet.Limit(MaxCount);
}
IAsyncCursor <BsonDocument> Cursor = await ResultSet.ToCursorAsync();
LinkedList <T> Result = new LinkedList <T>();
BsonDeserializationArgs Args = new BsonDeserializationArgs()
{
NominalType = typeof(T)
};
while (await Cursor.MoveNextAsync())
{
foreach (BsonDocument Document in Cursor.Current)
{
BsonDocumentReader Reader = new BsonDocumentReader(Document);
BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
T Obj = (T)Serializer.Deserialize(Context, Args);
Result.AddLast(Obj);
}
}
return(Result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="filter"></param>
/// <param name="projection"></param>
private void Apply <T>(IMongoCollection <T> collection, FilterDefinition <T> filter, ProjectionDefinition <T> projection)
{
filter = CreateFilters <T>(Filter, filter);
if (IsAggregate)
{
var sortB = Builders <T> .Sort;
SortDefinition <T> sort = null;
foreach (var item in Order)
{
switch (item.Direction.ToString())
{
case "-":
{
if (sort == null)
{
sort = sortB.Descending(item.Property);
}
else
{
sort = sort.Descending(item.Property);
}
break;
}
case "+":
{
if (sort == null)
{
sort = sortB.Ascending(item.Property);
}
else
{
sort = sort.Ascending(item.Property);
}
break;
}
}
}
var Group = BsonDocumentWrapper.Parse(JsonConvert.SerializeObject(GroupBy));
IAggregateFluent <T> query = null;
var options = new AggregateOptions();
if (sort != null)
{
query = collection.Aggregate().Match(filter).Sort(sort).Group <T>(Group).Project <T>(BsonDocumentWrapper.Parse("{'id':'$_id','count':'$count'}"));
}
else
{
query = collection.Aggregate().Match(filter).Group <T>(Group).Project <T>(BsonDocumentWrapper.Parse("{'id':'$_id','count':'$count'}"));
}
Data = query.ToList <T>();
}
else
{
IFindFluent <T, T> query = null;
if (filter != null)
{
query = collection.Find(filter);
}
else
{
query = collection.Find(x => true);
}
if (projection != null)
{
query = query.Project <T>(projection);
}
var sortB = Builders <T> .Sort;
SortDefinition <T> sort = null;
foreach (var item in Order)
{
switch (item.Direction.ToString())
{
case "-":
{
if (sort == null)
{
sort = sortB.Descending(item.Property);
}
else
{
sort = sort.Descending(item.Property);
}
break;
}
case "+":
{
if (sort == null)
{
sort = sortB.Ascending(item.Property);
}
else
{
sort = sort.Ascending(item.Property);
}
break;
}
}
}
if (sort != null)
{
query.Sort(sort);
}
PageSize = PageSize ?? 1;
RecordCount = query.Count();
if (PageSize != int.MaxValue)
{
PageCount = (RecordCount / PageSize);
PageCount += (PageCount < ((float)RecordCount / (float)PageSize)) ? 1 : 0;
Data = query.Skip((PageIndex - 1) * PageSize).Limit(PageSize).ToList <T>();
}
else
{
PageCount = 1;
Data = query.ToList <T>();
}
}
}
/// <summary>
/// Generate a sort definition from a Query Information
/// </summary>
/// <returns>MongoDB Filter definition for T</returns>
internal SortDefinition <T> buildSortingDefinition()
{
SortDefinition <T> sortDef = null;
if (SortFields.Count > 0)
{
var sortBuilder = Builders <T> .Sort;
foreach (var sortField in SortFields)
{
if (sortDef == null)
{
sortDef = (sortField.Ascending) ? sortBuilder.Ascending(sortField.Field) : sortBuilder.Descending(sortField.Field);
}
else
{
sortDef = (sortField.Ascending) ? sortDef.Ascending(sortField.Field) : sortDef.Descending(sortField.Field);
}
}
}
return(sortDef);
}
