public SortDefinition <T> FilterConditionToSort <T>(List <FilterCondition> filter)
{
SortDefinitionBuilder <T> sort = Builders <T> .Sort;
SortDefinition <T> sd = null;
if (filter == null)
{
return(sd);
}
foreach (FilterCondition s in filter)
{
if (!s.OrderType.HasValue)
{
continue;
}
if (s.OrderType == TableOrderType.DESCENDING)
{
sd = sort.Combine(sort.Descending(s.Key));
}
else
{
sd = sort.Combine(sort.Ascending(s.Key));
}
}
return(sd);
}
public DbQuery <TEntity> Ascending(Expression <Func <TEntity, object> > expression)
{
if (SortDefenition == null)
{
SortDefenition = _sortBuilder.Ascending(expression);
}
else
{
SortDefenition = _sortBuilder.Combine(SortDefenition, _sortBuilder.Ascending(expression));
}
return(this);
}
public static SortDefinition <MongoContentEntity> BuildSort(ODataUriParser query, Schema schema)
{
var orderBy = query.ParseOrderBy();
if (orderBy != null)
{
var sorts = new List <SortDefinition <MongoContentEntity> >();
while (orderBy != null)
{
sorts.Add(OrderBy(orderBy, schema));
orderBy = orderBy.ThenBy;
}
if (sorts.Count > 1)
{
return(Sort.Combine(sorts));
}
else
{
return(sorts[0]);
}
}
else
{
return(Sort.Descending(x => x.LastModified));
}
}
public SortDefinition <TSort> GetSortDefinition <TSort>(Expression <Func <IEnumerable <TSort>, dynamic> > orderBy)
{
var stackMember = new Stack <string>();
var stackSortMethod = new Stack <int>();
new SortExpressionParser().Parsing <TSort>(orderBy, stackMember, stackSortMethod);
if (stackMember.Any() && stackSortMethod.Any() && stackMember.Count == stackSortMethod.Count)
{
var length = stackMember.Count;
SortDefinitionBuilder <TSort> builder = new SortDefinitionBuilder <TSort>();
List <SortDefinition <TSort> > list = new List <SortDefinition <TSort> >();
for (var i = 0; i < length; i++)
{
var name = stackMember.Pop();
var way = stackSortMethod.Pop();
if (way == 1)
{
list.Add(builder.Ascending(name));
}
else
{
list.Add(builder.Descending(name));
}
}
var definition = builder.Combine(list);
return(definition);
}
return(null);
}
public static SortDefinition <BsonDocument> GetCustomerSortDefinition()
{
var sortBuilder = new SortDefinitionBuilder <BsonDocument>();
var daySortDefinition = sortBuilder.Ascending("Day");
var monthSortDefinition = sortBuilder.Ascending("Month");
var netWorthSortDefinition = sortBuilder.Descending("NetWorth");
var yearSortDefinition = sortBuilder.Ascending("Year");
var sortDefinition = sortBuilder.Combine(daySortDefinition, monthSortDefinition, netWorthSortDefinition, yearSortDefinition);
return(sortDefinition);
}
protected virtual async Task <IEnumerable <object> > GetCollection(Expression <Func <T, bool> > filter,
PagingSettings paging,
IEnumerable <SortingField> sortings,
Expression <Func <T, object> > projection,
CancellationToken token = default(CancellationToken))
{
if (!CollectionExist)
{
return(new List <object>());
}
try
{
var collection = filter == null?Collection.Find(_ => true) : Collection.Find(filter);
var sortingBuilder = new SortDefinitionBuilder <T>();
var sorts = new List <SortDefinition <T> >();
if (sortings != null)
{
sorts.AddRange(from sf in sortings
where !sf.IsNull
select sf.SortingMode == SortingModes.Ascending
? sortingBuilder.Ascending(sf.FieldName)
: sortingBuilder.Descending(sf.FieldName));
}
collection.Sort(sortingBuilder.Combine(sorts));
if (projection != null)
{
collection.Project(projection);
}
if (paging == null)
{
return((IEnumerable <object>) await collection.ToListAsync(CancellationToken.None));
}
if (paging.Skip != null)
{
collection = collection.Skip(paging.Skip);
}
if (paging.Limit != null)
{
collection = collection.Limit(paging.Limit);
}
return((IEnumerable <object>) await collection.ToListAsync(token));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public virtual async Task <IEnumerable <T> > GetAsync(
Expression <Func <T, bool> > filter,
PagingOptions pagingOptions,
IList <SortingOptions> sortingOptions,
CancellationToken token)
{
try
{
if (!this.IsCollectionsExists)
{
return(Enumerable.Empty <T>());
}
var sortDefinitionBuilder = new SortDefinitionBuilder <T>();
var sortDefinitions = new List <SortDefinition <T> >();
if (sortingOptions.Any())
{
sortDefinitions.AddRange(
sortingOptions.Select(
sortingOption => sortingOption.SortingMode == SortingMode.Ascending
? sortDefinitionBuilder.Ascending(sortingOption.FieldName)
: sortDefinitionBuilder.Descending(sortingOption.FieldName)));
}
var sourceCollection = filter == null?Collection.Find(_ => true) : Collection.Find(filter);
sourceCollection.Sort(sortDefinitionBuilder.Combine(sortDefinitions));
if (pagingOptions != null && pagingOptions.Skip != null)
{
sourceCollection = sourceCollection.Skip(pagingOptions.Skip);
}
if (pagingOptions != null && pagingOptions.Limit != null)
{
sourceCollection = sourceCollection.Limit(pagingOptions.Limit);
}
return(await sourceCollection.ToListAsync(token));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public List <BsonDocument> FindByKVPair(string set_name, FilterDefinition <BsonDocument> filterDef, object sort_list = null, int limit = 0, int skip = 0)
{
SortDefinition <BsonDocument> sorts = null;
if (sort_list != null)
{
SortDefinitionBuilder <BsonDocument> builderSort = Builders <BsonDocument> .Sort;
List <SortDefinition <BsonDocument> > sort = new List <SortDefinition <BsonDocument> >();
foreach (KeyValuePair <string, string> kvp in sort_list as Dictionary <string, string> )
{
if (kvp.Value == "ASC")
{
sort.Add(builderSort.Ascending(kvp.Key));
}
else
{
sort.Add(builderSort.Descending(kvp.Key));
}
}
sorts = builderSort.Combine(sort.ToList());
}
IFindFluent <BsonDocument, BsonDocument> find_op = mdb.GetCollection <BsonDocument>(set_name).Find(filterDef);
if (sorts != null)
{
find_op = find_op.Sort(sorts);
}
if (skip > 0)
{
find_op = find_op.Skip(skip);
}
if (limit > 0)
{
find_op = find_op.Limit(limit);
}
return(find_op.ToList());
}
private async Task <IEnumerable <T> > FetchEntities <T>
(
string metaPhrase,
ProjectionDefinition <T> projection,
IMongoCollection <T> collection,
double daysTolerance,
int limit,
GeoJsonPoint <GeoJson3DGeographicCoordinates> targetPosition = null
) where T : IIdentifiable <ObjectId>, ILocatable, IMetaScored
{
var referenceDate = DateTime.UtcNow;
var filterBuilder = new FilterDefinitionBuilder <T>();
var filter = filterBuilder.And
(
filterBuilder.Gt
(
post => post._id,
new ObjectId(referenceDate.Subtract(TimeSpan.FromDays(daysTolerance)), 0, 0, 0)
),
filterBuilder.Or
(
filterBuilder.Text(metaPhrase, new TextSearchOptions
{
CaseSensitive = false,
DiacriticSensitive = false,
})
,
filterBuilder.Exists(p => p._id)
)
);
var sortBuilder = new SortDefinitionBuilder <T>();
var sort = sortBuilder.Combine
(
sortBuilder.MetaTextScore("metaScore"),
sortBuilder.Descending(p => p._id)
);
var cursor = await collection.FindAsync(filter, new FindOptions <T>
{
AllowPartialResults = true,
Limit = limit,
Sort = sort,
Projection = projection
});
var enumerable = cursor.ToEnumerable();
if (targetPosition != null)
{
enumerable = enumerable.OrderBy
(
item =>
item.Position.Coordinates.ToGeoCoordinate().GetDistanceTo(targetPosition.Coordinates.ToGeoCoordinate())
-
Math.Pow(item.MetaScore, 2)
);
}
return(enumerable);
}
