/// <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 descending order.
/// </summary>
/// <param name="memberExpressions">The member expressions.</param>
/// <returns>The builder.</returns>
public PushEachOptionsBuilder <TValue> SortDescending(params Expression <Func <TValue, object> >[] memberExpressions)
{
if (_sortBy == null)
{
_sortBy = new SortByBuilder <TValue>(_serializationInfoHelper);
}
_sortBy.Descending(memberExpressions);
return(this);
}
public IList<Character> ListCharactersOnServerByPoints(string region, string server, int start, int limit)
{
QueryDocument query = new QueryDocument();
query.Add("Server", server);
query.Add("Region", region);
SortByBuilder sortBy = new SortByBuilder();
sortBy.Descending("CurrentPoints");
return Collection.Find(query).SetSortOrder(sortBy).SetSkip(start).SetLimit(limit).OrderByDescending(c => c.CurrentPoints).ToList();
}
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 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);
}
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;
}
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;
}
private List<MonthlyUserStatisticData> GetItemsByFilterCM(BaseFilter filter, SortByBuilder sort, int month, int year)
{
var resultItems = new List<MonthlyUserStatisticData>();
var query = Query.And(Query.EQ("month", month), Query.EQ("year", year));
var cursor = _monthlyStatsRepository.Collection.FindAs<MonthlyUserStatisticData>(query);
cursor.SetSortOrder(sort);
if (filter.IsNeedPaging)
{
cursor.SetSkip(filter.Skip).SetLimit(filter.Take);
filter.TotalCount = (int)cursor.Count();
}
resultItems.AddRange(cursor);
return resultItems;
}
/// <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;
}
public void BufferedLogsRecordedTest()
{
Log.Info("a log 1");
Log.Info("a log 2");
Log.Info("a log 3");
Log.Info("a log 4");
Log.Info("a log 5");
SortByBuilder sbb = new SortByBuilder();
sbb.Descending("_id");
var allDocs = this.collection.FindAllAs<BsonDocument>().SetSortOrder(sbb).SetLimit(5);
BsonDocument doc = allDocs.First();
Assert.AreEqual(doc.GetElement("message").Value.AsString, "a log 5");
}
public void LogExceptionRecorded()
{
try
{
throw new ApplicationException("BOOM");
}
catch (Exception e)
{
Log.Fatal("a log", e);
}
SortByBuilder sbb = new SortByBuilder();
sbb.Descending("_id");
var allDocs = this.collection.FindAllAs<BsonDocument>().SetSortOrder(sbb).SetLimit(1);
BsonDocument doc = allDocs.First();
doc.GetElement("exception").Value.Should().Be.OfType<BsonString>();
doc.GetElement("exception").Value.AsString.Should().Contain("BOOM");
}
private List<UserStatisticData> GetItemsByFilterAT(BaseFilter filter, SortByBuilder sort)
{
var resultItems = new List<UserStatisticData>();
var cursor = _allTimeStatsRepository.Collection.FindAllAs<UserStatisticData>();
cursor.SetSortOrder(sort);
if (filter.IsNeedPaging)
{
cursor.SetSkip(filter.Skip).SetLimit(filter.Take);
filter.TotalCount = (int)cursor.Count();
}
resultItems.AddRange(cursor);
return resultItems;
}
/// <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;
}
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;
}
public List<CounterSeriesData> GetCounterData(DateTime beginDate, DateTime endDate, int counterCategoryId,
int counterNameId, int counterSourceId, int counterInstanceId,
int counterExtDataId, List<string> seriesFilter)
{
List<CounterSeriesData> resultData = new List<CounterSeriesData>();
if (seriesFilter.Count == 0)
return resultData;
bool getAllSeries = seriesFilter.Contains("*");
List<string> seriesNames = new List<string>();
MongoCollection<BsonDocument> items = Database.GetCollection("countersData");
string mappedCategoryName = CountersMapper.GetMappedCategoryName(counterCategoryId);
string mappedCounterName = CountersMapper.GetMappedCounterName(counterCategoryId, counterNameId);
string mappedCounterInstance = CountersMapper.GetMappedCounterInstanceName(counterCategoryId, counterNameId,
counterInstanceId);
string mappedCounterSource = CountersMapper.GetMappedCounterSourceName(counterCategoryId, counterNameId,
counterSourceId);
string mappedCounterExtData = CountersMapper.GetMappedCounterExtDataName(counterCategoryId, counterNameId,
counterExtDataId);
QueryComplete qb = beginDate == endDate
? Query.EQ("date", beginDate)
: Query.GT("date", beginDate).LTE(endDate);
QueryComplete qb2 = Query.EQ("counterCategory", mappedCategoryName);
QueryComplete qb3 = Query.EQ("counterName", mappedCounterName);
SortByBuilder sortOrder = new SortByBuilder().Ascending("date");
var cursor = items.Find(Query.And(qb, qb2, qb3));
cursor.SetSortOrder(sortOrder);
string counterDescription = counterSourceId + "/" + counterInstanceId + "/" + counterExtDataId;
cursor.SetFields(Fields.Include("type", "date", "data." + counterDescription));
foreach (BsonDocument cnt in cursor)
{
var dateTime = cnt["date"].AsDateTime;
var countersData = cnt["data"].AsBsonDocument;
if (!countersData.Contains(counterDescription))
{
foreach (string seriesName in seriesNames)
if (getAllSeries || seriesFilter.Contains(seriesName))
resultData.Find(f => f.SeriesName == seriesName).AddSeriesPoint(new SeriesPoint(dateTime, null));
continue;
}
var seriesPoints = countersData[counterDescription].AsBsonDocument;
foreach (BsonElement seriesPoint in seriesPoints)
{
string seriesName = seriesPoint.Name;
if (!seriesNames.Contains(seriesName))
seriesNames.Add(seriesName);
if (!getAllSeries && !seriesFilter.Contains(seriesName)) continue;
var value = seriesPoint.Value.IsString
? new UniversalValue(
TimeSpan.Parse(seriesPoint.Value.AsString))
: new UniversalValue(
seriesPoint.Value.ToDouble());
var a = resultData.Find(f => f.SeriesName == seriesName);
if (a == null)
{
a = new CounterSeriesData(seriesName, value.Type, mappedCategoryName, mappedCounterName,
mappedCounterSource, mappedCounterInstance, mappedCounterExtData);
resultData.Add(a);
}
a.AddSeriesPoint(new SeriesPoint(dateTime, value));
}
}
return resultData;
}
/// <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;
}
public MongoDBSort()
{
Builder = new SortByBuilder();
}
