/// <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>();
//_id将以文字的形式排序，所以不要排序_id!!
foreach (DataFilter.QueryFieldItem 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>
/// Sorts the array in ascending order.
/// </summary>
/// <param name="memberExpressions">The member expressions.</param>
/// <returns>The builder.</returns>
public PushEachOptionsBuilder <TValue> SortAscending(params Expression <Func <TValue, object> >[] memberExpressions)
{
if (_sortBy == null)
{
_sortBy = new SortByBuilder <TValue>(_serializationInfoHelper);
}
_sortBy.Ascending(memberExpressions);
return(this);
}
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;
}
private static IMongoSortBy CreateSortBy(IList <Tuple <string, SortOrder> > sortItems)
{
if (sortItems.Any() == false)
{
return(null);
}
M.SortByBuilder builder = new M.SortByBuilder();
foreach (Tuple <string, SortOrder> sortItem in sortItems)
{
if (sortItem.Item2 == SortOrder.Ascending)
{
builder = builder.Ascending(sortItem.Item1);
}
else
{
builder = builder.Descending(sortItem.Item1);
}
}
return(builder);
}
/// <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;
}
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);
}
/// <summary>
/// Finds the list of users that match the criteria.
/// </summary>
/// <param name="filter">Filters the results to only users that match.</param>
/// <param name="tablesorterMetadata">The tablesorter metadata.</param>
/// <returns>
/// The list of users that match the criteria.
/// </returns>
protected override UserList DoFindUsers(UserSearchCriteria filter, TablesorterMetadata tablesorterMetadata = null)
{
MongoCollection<BsonDocument> collection = this.database.GetCollection(iApplyDb.UserAccess._COLLECTION_NAME);
QueryDocument outerQuery = new QueryDocument();
List<IMongoQuery> orQueries = new List<IMongoQuery>();
if (filter.OrganisationIds != null && filter.OrganisationIds.Any())
{
orQueries.AddRange(filter.OrganisationIds.Select(organisationId => Query.Exists(string.Format("{0}.{1}", iApplyDb.UserAccess.ORGANISATIONS, organisationId))));
}
if (filter.IncludeNoOrganisationUsers)
{
orQueries.Add(Query.NotExists(iApplyDb.UserAccess.ORGANISATIONS));
orQueries.Add(Query.EQ(iApplyDb.UserAccess.ORGANISATIONS, new BsonDocument()));
}
if (!filter.IncludeServiceUsers)
{
outerQuery.AddRange(Query.NE(iApplyDb.UserAccess.ACCOUNT_TYPE, new BsonString(AccountType.Service.ToString())).ToBsonDocument());
}
if (filter.RoleIds != null && filter.RoleIds.Any())
{
orQueries.AddRange(filter.RoleIds.Select(roleId => Query.Exists(string.Format("{0}.{1}", iApplyDb.UserAccess.ROLES, roleId))));
}
IMongoQuery subQuery;
if (orQueries.Count > 0)
{
subQuery = Query.Or(orQueries);
outerQuery.AddRange(subQuery.ToBsonDocument());
}
if (filter.UserIds != null && filter.UserIds.Any())
{
BsonArray bsonUserIds = new BsonArray();
bsonUserIds.AddRange(filter.UserIds.Select(u => new BsonObjectId(new ObjectId(u))));
subQuery = Query.In(iApplyDb.UserAccess._ID, bsonUserIds);
outerQuery.AddRange(subQuery.ToBsonDocument());
}
if (filter.Usernames != null && filter.Usernames.Any())
{
BsonArray bsonUserNames = new BsonArray();
bsonUserNames.AddRange(filter.Usernames.Select(u => new BsonString(u)));
subQuery = Query.In(iApplyDb.UserAccess.USERNAME, bsonUserNames);
outerQuery.AddRange(subQuery.ToBsonDocument());
}
if (filter.ExternalIds != null && filter.ExternalIds.Any())
{
BsonArray bsonExternalIds = new BsonArray();
bsonExternalIds.AddRange(filter.ExternalIds.Select(u => new BsonString(u)));
subQuery = Query.In(iApplyDb.UserAccess.EXTERNAL_ID, bsonExternalIds);
outerQuery.AddRange(subQuery.ToBsonDocument());
}
if (tablesorterMetadata != null && tablesorterMetadata.SearchFilters != null)
{
for (int i = 0; i < tablesorterMetadata.SearchFilters.Length; i++)
{
var fieldName = tablesorterMetadata.HeaderList[i];
var searchTerm = tablesorterMetadata.SearchFilters[i];
if (string.IsNullOrWhiteSpace(fieldName) || string.IsNullOrWhiteSpace(searchTerm))
{
continue;
}
subQuery = Query.EQ(fieldName, new BsonRegularExpression(searchTerm.Trim(), "i"));
outerQuery.AddRange(subQuery.ToBsonDocument());
}
}
MongoCursor<BsonDocument> documents = collection.Find(outerQuery);
if (tablesorterMetadata != null)
{
tablesorterMetadata.TotalRows = Convert.ToInt32(collection.Count(outerQuery));
documents.SetSkip(tablesorterMetadata.PageSize * tablesorterMetadata.PageIndex).SetLimit(tablesorterMetadata.PageSize);
if (tablesorterMetadata.SortOrder != null)
{
SortByBuilder newSortByBuilder = new SortByBuilder();
foreach (int[] sortCriteria in tablesorterMetadata.SortOrder)
{
var columnNum = sortCriteria[0];
var sortOrder = sortCriteria[1];
if (sortOrder == 1)
{
newSortByBuilder.Descending(tablesorterMetadata.HeaderList[columnNum]);
}
else
{
newSortByBuilder.Ascending(tablesorterMetadata.HeaderList[columnNum]);
}
}
documents.SetSortOrder(newSortByBuilder);
}
}
UserList users = BsonConverter.ConvertToObjectViaJson<UserList>(documents);
return users;
}
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;
}
/// <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;
}
/// <summary>
/// 获得排序
/// </summary>
/// <returns></returns>
public static SortByBuilder GetSort()
{
var sort = new SortByBuilder();
List<string> ascendingList = new List<string>();
List<string> descendingList = new List<string>();
//_id将以文字的形式排序，所以不要排序_id!!
foreach (var item in QueryFieldList)
{
switch (item.sortType)
{
case SortType.NoSort:
break;
case SortType.Ascending:
ascendingList.Add(item.ColName);
break;
case 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();
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;
}
private MongoCursor<BsonDocument> LoadData()
{
try
{
var db = MongoUtilities.Create(_cnn).GetDatabase(_databaseName);
var col = db.GetCollection(_collectionName);
_pager.TotalItems = (int)col.Count();
if (_pager.TotalItems == 0)
{
return null;
}
var queries = new List<IMongoQuery>();
_filterOn.ToList().ForEach(property =>
{
IMongoQuery subQuery;
BsonValue value;
if (!MongoUtilities.TryConvertStringToBsonType(
_sortFieldsInfo[property.Name], property.Value, out value))
{
value = new BsonString(property.Value);
}
switch (property.Operator)
{
case "!=":
subQuery = Query.NE(property.Name, value);
break;
case ">=":
subQuery = Query.GTE(property.Name, value);
break;
case "<=":
subQuery = Query.LTE(property.Name, value);
break;
case ">":
subQuery = Query.GT(property.Name, value);
break;
case "<":
subQuery = Query.LT(property.Name, value);
break;
case "like":
subQuery = Query.Matches(property.Name, new BsonRegularExpression("(?i)" + property.Value));
break;
case "in":
case "!in":
var values = new List<BsonValue>();
property.Value.Split(',').ToList().ForEach(item =>
{
BsonValue val = null;
if (!MongoUtilities.TryConvertStringToBsonType(_sortFieldsInfo[property.Name], item.Trim(), out val))
{
val = new BsonString(item.Trim());
}
values.Add(val);
});
if (property.Operator == "in")
{
subQuery = Query.In(property.Name, values);
}
else
{
subQuery = Query.NotIn(property.Name, values);
}
break;
default:
subQuery = Query.EQ(property.Name, value);
break;
}
queries.Add(subQuery);
});
IMongoQuery query;
if (queries.Count > 0)
{
query = Query.And(queries);
}
else
{
query = null;
}
var cur = col.Find(query).SetSkip(_pager.FirstItemIndex).SetLimit(_pager.PageSize);
SortByBuilder sort = new SortByBuilder();
_sortOn.ToList().ForEach(property =>
{
if (property.Ascending)
sort = sort.Ascending(property.Name);
else
sort = sort.Descending(property.Name);
});
cur.SetSortOrder(sort);
return cur;
}
catch (Exception ex)
{
Utilities.LogException(ex);
}
return null;
}
