/// <summary>
/// 获得排序
/// </summary>
/// <returns></returns>
public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> FieldItemLst)
{
var sort = new SortByBuilder();
List <String> ascendingList = new List <String>();
List <String> descendingList = new List <String>();
//_id将以文字的形式排序，所以不要排序_id!!
foreach (var item in FieldItemLst)
{
switch (item.sortType)
{
case DataFilter.SortType.NoSort:
break;
case DataFilter.SortType.Ascending:
ascendingList.Add(item.ColName);
break;
case DataFilter.SortType.Descending:
descendingList.Add(item.ColName);
break;
default:
break;
}
}
sort.Ascending(ascendingList.ToArray());
sort.Descending(descendingList.ToArray());
return(sort);
}
/// <summary>
/// 获得排序
/// </summary>
/// <returns></returns>
public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> fieldItemLst)
{
var sort = new SortByBuilder();
//排序
fieldItemLst.Sort((x, y) => { return(x.SortOrder - y.SortOrder); });
foreach (var item in fieldItemLst)
{
if (item.SortOrder == 0)
{
continue;
}
switch (item.SortType)
{
case DataFilter.SortType.NoSort:
break;
case DataFilter.SortType.Ascending:
sort.Ascending(item.ColName);
break;
case DataFilter.SortType.Descending:
sort.Descending(item.ColName);
break;
}
}
return(sort);
}
public static SortByBuilder BuildSortByBuilder(string sortbyExpression)
{
try
{
// create sort order builder
SortByBuilder builder = new SortByBuilder();
string[] splitSortExpr = sortbyExpression.Split(',');
foreach (string s in splitSortExpr)
{
string[] splitSort = s.Split(':');
if (splitSort[1].Equals("1"))
{
builder.Ascending(new string[] { splitSort[0].ToString() });
}
else
{
builder.Descending(new string[] { splitSort[0].ToString() });
}
}
return(builder);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// </summary>
/// <returns></returns>
public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> fieldItemLst)
{
var sort = new SortByBuilder();
var ascendingList = new List <string>();
var descendingList = new List <string>();
foreach (var item in fieldItemLst)
{
switch (item.SortType)
{
case DataFilter.SortType.NoSort:
break;
case DataFilter.SortType.Ascending:
ascendingList.Add(item.ColName);
break;
case DataFilter.SortType.Descending:
descendingList.Add(item.ColName);
break;
}
}
sort.Ascending(ascendingList.ToArray());
sort.Descending(descendingList.ToArray());
return(sort);
}
/// <summary>
/// Converts PS objects to a SortBy object.
/// </summary>
/// <param name="values">Strings or @{Name=Boolean}. Null and empty is allowed.</param>
/// <returns>SortBy object, may be empty but not null.</returns>
public static IMongoSortBy ObjectsToSortBy(IEnumerable values)
{
if (values == null)
{
return(SortBy.Null);
}
var builder = new SortByBuilder();
foreach (var it in values)
{
var name = it as string;
if (name != null)
{
builder.Ascending(name);
continue;
}
var hash = it as IDictionary;
if (hash == null)
{
throw new ArgumentException("SortBy: Invalid size object type.");
}
if (hash.Count != 1)
{
throw new ArgumentException("SortBy: Expected a dictionary with one entry.");
}
foreach (DictionaryEntry kv in hash)
{
name = kv.Key.ToString();
if (LanguagePrimitives.IsTrue(kv.Value))
{
builder.Ascending(name);
}
else
{
builder.Descending(name);
}
}
}
return(builder);
}
public MongoSortWarpper Asc(params string[] keys)
{
if (MongoSortBy == null)
{
MongoSortBy = SortBy.Ascending(keys);
}
else
{
MongoSortBy = MongoSortBy.Ascending(keys);
}
return(this);
}
public IEnumerable <IEnumerable <KeyValuePair <string, object> > > Find(string entityName, QueryObject query, QuerySortObject[] sort, int?skip, int?limit)
{
var mongoCollection = MongoStaticContext.Context.GetBsonCollection(RECORD_COLLECTION_PREFIX + entityName);
var mongoQuery = ConvertQuery(query);
var cursor = mongoCollection.Find(mongoQuery);
if (sort != null && sort.Length > 0)
{
SortByBuilder sortBy = null;
foreach (var s in sort)
{
if (s.SortType == QuerySortType.Ascending)
{
sortBy = sortBy == null?SortBy.Ascending(s.FieldName) : sortBy.Ascending(s.FieldName);
}
else
{
sortBy = sortBy == null?SortBy.Descending(s.FieldName) : sortBy.Descending(s.FieldName);
}
}
cursor.SetSortOrder(sortBy);
}
if (skip.HasValue)
{
cursor.SetSkip(skip.Value);
}
if (limit.HasValue)
{
cursor.SetLimit(limit.Value);
}
List <List <KeyValuePair <string, object> > > result = new List <List <KeyValuePair <string, object> > >();
foreach (BsonDocument doc in cursor)
{
List <KeyValuePair <string, object> > record = new List <KeyValuePair <string, object> >();
foreach (var fieldName in doc.Names)
{
if (fieldName == "_id")
{
record.Add(new KeyValuePair <string, object>("id", BsonTypeMapper.MapToDotNetValue(doc["_id"])));
}
else
{
record.Add(new KeyValuePair <string, object>(fieldName, ConvertBsonValueToObject(doc[fieldName])));
}
}
result.Add(record);
}
return(result);
}
private static SortByBuilder AddSorting(SortByBuilder sortBy, string sortDirection, string dbSortField)
{
//SortByBuilder sortBy;
switch (sortDirection)
{
case "+":
{
sortBy = sortBy.Ascending(dbSortField);
}
break;
case "-":
{
sortBy = sortBy.Descending(dbSortField);
}
break;
default:
sortBy = sortBy.Ascending(dbSortField);
break;
}
return(sortBy);
}
protected virtual IMongoSortBy BuildSortExpression(TFilter filter)
{
IMongoSortBy sort = SortBy.Null;
if (filter.Ordering.Any())
{
var builder = new SortByBuilder();
foreach (var order in filter.Ordering)
{
builder = order.Desc ? builder.Descending(order.Key) : builder.Ascending(order.Key);
}
sort = builder;
}
return(sort);
}
private static SortByBuilder GetSortOrder(IEnumerable <string> sortBy)
{
var builder = new SortByBuilder();
foreach (var field in sortBy)
{
if (field[0] == '-')
{
builder.Descending(field.Substring(1));
}
else
{
builder.Ascending(field);
}
}
return(builder);
}
public static SortByBuilder GetSort(TaskQueue.TQItemSelector selector)
{
SortByBuilder sb = new SortByBuilder();
foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
{
switch (kv.Value.ValueSet)
{
case TaskQueue.TQItemSelectorSet.Ascending:
sb = sb.Ascending(kv.Key);
break;
case TaskQueue.TQItemSelectorSet.Descending:
sb = sb.Descending(kv.Key);
break;
}
}
return(sb);
}
public List <T> Page <T>(DbQueryParams qParams) where T : class, new()
{
// First query part consists of search params with specified operator between
List <IMongoQuery> queries = new List <IMongoQuery>();
foreach (var item in qParams.QueryParams)
{
queries.Add(Query.Matches(item.Key, new BsonRegularExpression(String.Format("(?:{0})", item.Value), "is")));
}
var query = qParams.Operator == QueryOperator.AND ? Query.And(queries) : Query.Or(queries);
MongoCursor <T> cursor = mongoDb.GetCollection <T>(GetTypeName(typeof(T))).Find(query);
cursor.SetSkip(qParams.SkipRecords).SetLimit(qParams.Count);
// Setting the Sort params
if (qParams.SortParams != null && qParams.SortParams.Count > 0)
{
SortByBuilder sbb = new SortByBuilder();
foreach (KeyValuePair <string, bool> sortItem in qParams.SortParams)
{
if (sortItem.Value)
{
sbb.Ascending(sortItem.Key);
}
else
{
sbb.Descending(sortItem.Key);
}
}
cursor.SetSortOrder(sbb);
}
return(cursor.ToList());
}
private void ApplySorting(MongoCursor <BsonDocument> cursor, IEnumerable <SimpleOrderByItem> orderings)
{
if (orderings == null || !orderings.Any())
{
return;
}
var sortBuilder = new SortByBuilder();
foreach (var ordering in orderings)
{
var name = ExpressionFormatter.GetFullName(ordering.Reference);
if (ordering.Direction == OrderByDirection.Ascending)
{
sortBuilder.Ascending(name);
}
else
{
sortBuilder.Descending(name);
}
}
cursor.SetSortOrder(sortBuilder);
}
public virtual object Execute()
{
var visitor = new MongoDBVisitor();
visitor.Visite(ContentQuery.Expression);
var mongoCursor = Query(visitor);
if (mongoCursor == null)
{
return(DefaultValueExecute(visitor.CallType));
}
if (visitor.Skip != 0)
{
mongoCursor.Skip = visitor.Skip;
}
SortByBuilder sortBuilder = new SortByBuilder();
foreach (var item in visitor.OrderFields)
{
if (item.Descending)
{
sortBuilder.Descending(item.FieldName);
}
else
{
sortBuilder.Ascending(item.FieldName);
}
}
mongoCursor = mongoCursor.SetSortOrder(sortBuilder);
object result = null;
switch (visitor.CallType)
{
case Kooboo.CMS.Content.Query.Expressions.CallType.Count:
result = Convert.ToInt32(mongoCursor.Count());
break;
case Kooboo.CMS.Content.Query.Expressions.CallType.First:
result = mongoCursor.First().ToContent();
break;
case Kooboo.CMS.Content.Query.Expressions.CallType.Last:
result = mongoCursor.Last().ToContent();
break;
case Kooboo.CMS.Content.Query.Expressions.CallType.LastOrDefault:
result = mongoCursor.Last().ToContent();
break;
case Kooboo.CMS.Content.Query.Expressions.CallType.FirstOrDefault:
result = mongoCursor.FirstOrDefault().ToContent();
break;
case Kooboo.CMS.Content.Query.Expressions.CallType.Unspecified:
default:
if (visitor.Take != 0)
{
result = mongoCursor.Take(visitor.Take).Select(it => it.ToContent());
}
else
{
result = mongoCursor.Select(it => it.ToContent());
}
break;
}
if (mongoCursor.Database.Server.State != MongoServerState.Disconnected)
{
mongoCursor.Database.Server.Disconnect();
}
return(result);
}
