public static FilterDefinition <TelemetryData> CreateFilter(long?timeStampStart = null, long?timeStampStop = null, string deviceId = null)
{
var filterDefinitions = new List <FilterDefinition <TelemetryData> >();
if (timeStampStart != null)
{
filterDefinitions.Add(Builder.Gte(telemetryData => telemetryData.UnixTimeStamp, timeStampStart));
}
if (timeStampStop != null)
{
filterDefinitions.Add(Builder.Lte(telemetryData => telemetryData.UnixTimeStamp, timeStampStop));
}
if (deviceId != null)
{
filterDefinitions.Add(Builder.Eq(telemetryData => telemetryData.DeviceId, deviceId));
}
var filter = Builder.Empty;
foreach (var filterDefinition in filterDefinitions)
{
filter &= filterDefinition;
}
return(filter);
}
public async Task <List <Movie> > GetMovies(int yearLowerBand, int yearUpperBand)
{
var movies = new List <Movie>();
var projectionBuilder = new ProjectionDefinitionBuilder <Movie>();
var projection = projectionBuilder
.Include(x => x.Awards)
.Include(x => x.Genres)
.Include(x => x.Plot)
.Include(x => x.Rated)
.Include(x => x.Title)
.Include(x => x.Year)
.Exclude("_id");
var filterBuilder = new FilterDefinitionBuilder <Movie>();
var filter = filterBuilder.Gte(x => x.Year, yearLowerBand) & filterBuilder.Lte(x => x.Year, yearUpperBand);
using (IAsyncCursor <Movie> documents = await _database.GetCollection <Movie>("movies")
.FindAsync(filter, new FindOptions <Movie, Movie>
{
Projection = projection
}))
{
while (documents.MoveNext())
{
movies.AddRange(documents.Current);
}
}
return(movies);
}
public async Task <string> FilterMovies(int yearLowerBand, int yearUpperBand)
{
var movies = new List <BsonDocument>();
var projectionBuilder = new ProjectionDefinitionBuilder <BsonDocument>();
var projection = projectionBuilder
.Include("awards")
.Include("genres")
.Include("plot")
.Include("rated")
.Include("title")
.Include("year")
.Exclude("_id");
var filterBuilder = new FilterDefinitionBuilder <BsonDocument>();
var filter = filterBuilder.Gte("year", yearLowerBand) & filterBuilder.Lte("year", yearUpperBand);
using (IAsyncCursor <BsonDocument> documents = await _database.GetCollection <BsonDocument>("movies").FindAsync(filter))
{
while (documents.MoveNext())
{
movies.AddRange(documents.Current);
}
}
return(movies.ToJson());
}
public override FilterDefinition <T> VisitIntOp([NotNull] FilterParser.IntOpContext context)
{
string id = context.ID().GetText();
string integer = context.INT().GetText();
var op = context.op.Type;
switch (op)
{
case FilterParser.EQ:
return(_builder.Eq(id, integer));
case FilterParser.NE:
return(_builder.Ne(id, integer));
case FilterParser.GT:
return(_builder.Gt(id, integer));
case FilterParser.GE:
return(_builder.Gte(id, integer));
case FilterParser.LT:
return(_builder.Lt(id, integer));
case FilterParser.LE:
return(_builder.Lte(id, integer));
default:
throw new InvalidOperationException($"Invalid StringOp {context.GetText()}");
}
}
public List <TimedTrainingScore> Get(int user, DateTime?from, DateTime?to, string show)
{
FilterDefinitionBuilder <TimedTrainingScore> builder = Builders <TimedTrainingScore> .Filter;
FilterDefinition <TimedTrainingScore> filter = builder.Eq("owner", user);
if (from.HasValue && to.HasValue)
{
filter &= builder.Lte("dateRecorded", to.Value) & builder.Gte("dateRecorded", from.Value);
}
var found = scoreCollection.Find(filter).ToList();
if (show == "each")
{
return(found);
}
else
{
var groups = found.GroupBy(x => new { x.DateRecordedUtc.Date, x.Type, x.Variant });
if (show == "bestDay")
{
Func <TimedTrainingScore, TimedTrainingScore, TimedTrainingScore> bestOfADayAggregator = (agg, next) => next.Score > agg.Score ? next : agg;
List <TimedTrainingScore> result = groups.Select(x => x.Aggregate(bestOfADayAggregator)).ToList();
for (int i = 0; i < result.Count; i++)
{
result[i].DateRecordedUtc = result[i].DateRecordedUtc.Date;
}
return(result);
}
else // show == "avgDay"
{
return(groups.Select(x => new TimedTrainingScore(x.Average(y => y.Score), x.Key.Type, user, x.Key.Date, x.Key.Variant)).ToList());
}
}
}
private List <FilterDefinition <Flight> > CreateClauses(SearchCriteriaModel criteriaModel, FilterDefinitionBuilder <Flight> filterBuilder)
{
var clauses = new List <FilterDefinition <Flight> >();
if (criteriaModel.FromDate != null)
{
var fromDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.FromDate), DateTimeKind.Utc);
var clause = filterBuilder.Gte(f => f.FlightDate, fromDate);
clauses.Add(clause);
}
if (criteriaModel.ToDate != null)
{
var toDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.ToDate), DateTimeKind.Utc);
var clause = filterBuilder.Lte(f => f.FlightDate, toDate);
clauses.Add(clause);
}
if (criteriaModel.AirlineId != null)
{
var clause = filterBuilder.Eq(f => f.AirlineId, criteriaModel.AirlineId.Value);
clauses.Add(clause);
}
if (criteriaModel.OriginId != null)
{
var clause = filterBuilder.Eq(f => f.OriginAirportId, criteriaModel.OriginId.Value);
clauses.Add(clause);
}
if (criteriaModel.DestinationId != null)
{
var clause = filterBuilder.Eq(f => f.DestinationAirportId, criteriaModel.DestinationId.Value);
clauses.Add(clause);
}
return(clauses);
}
public async Task <List <RatingWithMetadata> > GetAsync(int user, DateTime?from, DateTime?to, string show)
{
FilterDefinitionBuilder <RatingWithMetadata> builder = Builders <RatingWithMetadata> .Filter;
FilterDefinition <RatingWithMetadata> filter = builder.Eq("owner", user);
if (from.HasValue && to.HasValue)
{
filter &= builder.Lte("timestampUtc", to.Value) & builder.Gte("timestampUtc", from.Value);
}
var found = await ratingCollection.Find(filter).ToListAsync();
if (show == "each")
{
return(found);
}
else
{
var groups = found.GroupBy(x => new { timestamp = x.TimestampUtc.Date, variant = x.Variant });
Func <RatingWithMetadata, RatingWithMetadata, RatingWithMetadata> bestOfADayAggregator = (agg, next) => next.Rating.Value > agg.Rating.Value ? next : agg;
Func <RatingWithMetadata, RatingWithMetadata, RatingWithMetadata> endOfTheDayAggregator = (agg, next) => next.TimestampUtc > agg.TimestampUtc ? next : agg;
Func <RatingWithMetadata, RatingWithMetadata, RatingWithMetadata> aggregator = show == "bestDay" ? bestOfADayAggregator : endOfTheDayAggregator;
List <RatingWithMetadata> result = groups.Select(x => x.Aggregate(aggregator)).ToList();
for (int i = 0; i < result.Count; i++)
{
result[i].TimestampUtc = result[i].TimestampUtc.Date;
}
return(result);
}
}
private async Task StoreArchiveEventsAsync(IEnumerable <IDomainEvent> archiveEvents)
{
var filterBuilder = Builders <IDomainEvent> .Filter;
var filter = filterBuilder.And(
filterBuilder.Eq(nameof(IDomainEvent.AggregateId), archiveEvents.First().AggregateId),
filterBuilder.Eq(nameof(IDomainEvent.AggregateType), archiveEvents.First().AggregateType.AssemblyQualifiedName));
switch (_archiveBehavior)
{
case SnapshotEventsArchiveBehavior.StoreToNewDatabase:
var otherDbArchiveCollection = await GetArchiveDatabaseEventCollectionAsync <IDomainEvent>().ConfigureAwait(false);
await otherDbArchiveCollection.InsertManyAsync(archiveEvents).ConfigureAwait(false);
break;
case SnapshotEventsArchiveBehavior.StoreToNewTable:
var archiveCollection = await GetArchiveEventCollectionAsync <IDomainEvent>().ConfigureAwait(false);
await archiveCollection.InsertManyAsync(archiveEvents).ConfigureAwait(false);
break;
}
var deleteFilterBuilder = new FilterDefinitionBuilder <IDomainEvent>();
var deleteFilter = deleteFilterBuilder.And(filter, deleteFilterBuilder.Lte(nameof(IDomainEvent.Sequence), archiveEvents.Max(e => e.Sequence)));
await(await GetEventCollectionAsync <IDomainEvent>().ConfigureAwait(false)).DeleteManyAsync(deleteFilter).ConfigureAwait(false);
}
private FilterDefinition <MessageJournalEntryDocument> BuildFilter(MessageJournalFilter filter, FilterDefinition <MessageJournalEntryDocument> filterDef,
FilterDefinitionBuilder <MessageJournalEntryDocument> fb)
{
if (filter == null)
{
return(filterDef);
}
if (filter.Topics.Any())
{
var topics = filter.Topics.Select(Normalize);
filterDef = filterDef & fb.In(e => e.Topic, topics);
}
if (filter.Categories.Any())
{
var categories = filter.Categories.Select(Normalize);
filterDef = filterDef & fb.In(e => e.Category, categories);
}
if (filter.From != null)
{
filterDef = filterDef & fb.Gte(e => e.Timestamp, filter.From);
}
if (filter.To != null)
{
filterDef = filterDef & fb.Lte(e => e.Timestamp, filter.To);
}
if (filter.Origination != null)
{
var origination = Normalize(filter.Origination);
filterDef = filterDef & fb.Eq(e => e.Origination, origination);
}
if (filter.Destination != null)
{
var destination = Normalize(filter.Destination);
filterDef = filterDef & fb.Eq(e => e.Destination, destination);
}
if (!string.IsNullOrWhiteSpace(filter.MessageName))
{
var partial = Normalize(filter.MessageName);
var pattern = ".*" + Regex.Escape(partial) + ".*";
var regex = new BsonRegularExpression(pattern, "i");
filterDef = filterDef & fb.Regex(e => e.MessageName, regex);
}
if (filter.RelatedTo != null)
{
var relatedTo = Normalize(filter.RelatedTo);
filterDef = filterDef & fb.Eq(e => e.RelatedTo, relatedTo);
}
return(filterDef);
}
public Task <IEnumerable <Product> > GetProductsByPriceAsync(double min, double max, CancellationToken cancellationToken = default(CancellationToken))
{
var filterBuilder = new FilterDefinitionBuilder <Product>();
var filter = filterBuilder.And(
filterBuilder.Gte(p => p.Price, min),
filterBuilder.Lte(p => p.Price, max));
return(products.FindAsync(filter, cancellationToken));
}
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn, None args)
{
var propertyName = nodeIn.Path.ToString();
var value = nodeIn.Value.Value;
switch (nodeIn.Operator)
{
case CompareOperator.Empty:
return(Filter.Or(
Filter.Exists(propertyName, false),
Filter.Eq <object?>(propertyName, null),
Filter.Eq <object?>(propertyName, string.Empty),
Filter.Size(propertyName, 0)));
case CompareOperator.Exists:
return(Filter.And(
Filter.Exists(propertyName, true),
Filter.Ne <object?>(propertyName, null)));
case CompareOperator.Matchs:
return(Filter.Regex(propertyName, BuildMatchRegex(nodeIn)));
case CompareOperator.StartsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s)));
case CompareOperator.Contains:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s)));
case CompareOperator.EndsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$")));
case CompareOperator.Equals:
return(Filter.Eq(propertyName, value));
case CompareOperator.GreaterThan:
return(Filter.Gt(propertyName, value));
case CompareOperator.GreaterThanOrEqual:
return(Filter.Gte(propertyName, value));
case CompareOperator.LessThan:
return(Filter.Lt(propertyName, value));
case CompareOperator.LessThanOrEqual:
return(Filter.Lte(propertyName, value));
case CompareOperator.NotEquals:
return(Filter.Ne(propertyName, value));
case CompareOperator.In:
return(Filter.In(propertyName, ((IList)value !).OfType <object>()));
}
throw new NotSupportedException();
}
/// <summary>
/// Count the past deadline incidents
/// </summary>
/// <returns></returns>
public int CountPastDeadlineIncidents(int userId, bool adminRights)
{
//Select collection
var collection = ConfigDB.GetDatabase().GetCollection <IncidentModel>("Incidents");
//Count documents (select)
DateTime dateTime = DateTime.Now;
var filter1 = Builder.Lte(x => x.DateDeadline, dateTime) & Builder.Eq(x => x.Status, "open");
var filter2 = Builder.Lte(x => x.DateDeadline, dateTime) & Builder.Eq(x => x.Status, "open") & Builder.Eq(x => x.UserId, userId);
double count;
if (adminRights)
{
count = collection.CountDocuments(filter1);
}
else
{
count = collection.CountDocuments(filter2);
}
return(Convert.ToInt32(count));
}
public static IList <BsonDocument> GetDataEngineEventsForLineRange(int workerId, string file, string threadId, int startLine, int endLine, IMongoCollection <BsonDocument> collection)
{
var filter = Query.And(Query.Eq("worker", workerId),
Query.Eq("tid", threadId),
Query.Eq("file", file),
Query.Gte("line", startLine),
Query.Lte("line", endLine));
var sort = Builders <BsonDocument> .Sort.Ascending("line");
return(collection.Find(filter).Sort(sort).ToList());
}
public FilterDefinition <IUser> ConcatenateFilter(List <SearchFilter> filters, FilterDefinitionBuilder <IUser> builder, FilterDefinition <IUser> filter, int i)
{
if (filters[i] is SearchFilter)
{
switch (filters[i].FieldName)
{
case "_id":
filter = filter & builder.Ne("_id", ((ValueSearchFilter <string>)filters[i]).Value);
break;
case "UserType":
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <string>)filters[i]).Value);
break;
case "Gender":
if (((ValueSearchFilter <int>)filters[i]).Value != 2)
{
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <int>)filters[i]).Value);
}
break;
case "Location":
break;
case "Expertise":
//ExpertiseEntityService expertiseService = new ExpertiseEntityService();
//IExpertise expertiseVal = await expertiseService.GetExpertiseById(((ValueSearchFilter<string>)filters[i]).Value);
//expertiseVal.ExpertiseName
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <string>)filters[i]).Value);
break;
case "Reputation":
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <int>)filters[i]).Value);
break;
case "Showers":
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <bool>)filters[i]).Value);
break;
case "ParkingLot":
filter = filter & builder.Eq(filters[i].FieldName, ((ValueSearchFilter <bool>)filters[i]).Value);
break;
}
}
else
{
filter = filter & builder.Lte(filters[i].FieldName, ((RangeSearchFilter)filters[i]).ToValue) &
builder.Gt(filters[i].FieldName, ((RangeSearchFilter)filters[i]).FromValue);
}
return(filter);
}
public static string GetBsonDocumentsLte(string tenantid, string pointid, long endTimestamp)
{
//创建约束生成器
FilterDefinitionBuilder <BsonDocument> builderFilter = Builders <BsonDocument> .Filter;
//约束条件
//FilterDefinition<BsonDocument> filter = builderFilter.Eq("name", "jack36");
FilterDefinition <BsonDocument> filter = builderFilter.Eq("pointid", $"{pointid}") & builderFilter.Eq("tenantid", $"{pointid}");
filter &= builderFilter.Lte("timestampclient", endTimestamp);
//获取数据
var tenantResult = _context.HistoryPointDatasBson($"{tenantid}.datas").Find <BsonDocument>(filter).Sort(Builders <BsonDocument> .Sort.Ascending("timestampclient")).Skip(0).Limit(2000);
return(tenantResult.ToList().ToJson());
}
public IPageList <T> Query <T>(FilterCondition filter) where T : IBaseObject
{
this.CheckType <T>();
IMongoCollection <T> collection = this.GetCollection <T>();
FilterDefinitionBuilder <T> filter2 = Builders <T> .Filter;
SortDefinitionBuilder <T> sort = Builders <T> .Sort;
FilterDefinition <T> filterDefinition = filter2.Empty;
foreach (FilterValue current in filter.Fields)
{
switch (current.FilterType)
{
case FilterType.LTE:
filterDefinition &= filter2.Lte <object>(current.FieldName, current.Value);
break;
case FilterType.GTE:
filterDefinition &= filter2.Gte <object>(current.FieldName, current.Value);
break;
case FilterType.LT:
filterDefinition &= filter2.Lt <object>(current.FieldName, current.Value);
break;
case FilterType.GT:
filterDefinition &= filter2.Gt <object>(current.FieldName, current.Value);
break;
case FilterType.EQ:
goto IL_12E;
case FilterType.Like:
filterDefinition &= filter2.Regex(current.FieldName, new Regex(current.Value.ToString(), RegexOptions.IgnoreCase));
break;
default:
goto IL_12E;
}
continue;
IL_12E:
filterDefinition &= filter2.Eq <object>(current.FieldName, current.Value);
}
Task <long> task = collection.CountAsync(filterDefinition, null, default(CancellationToken));
SortDefinition <T> sort2 = (filter.Direction == OrderDirection.DESC) ? sort.Descending(filter.OrderBy) : sort.Ascending(filter.OrderBy);
Task <List <T> > task2 = collection.Find(filterDefinition, null).Sort(sort2).Limit(new int?(filter.PageSize)).Skip(new int?((filter.PageIndex - 1) * filter.PageSize)).ToListAsync(default(CancellationToken));
return(new PageList <T>(task2.Result, filter.PageIndex, filter.PageSize, (int)task.Result));
}
public Puzzle GetOneRandomly(List <int> excludedIds, string variant, int?userId, double nearRating = 1500)
{
FilterDefinitionBuilder <Puzzle> filterBuilder = Builders <Puzzle> .Filter;
FilterDefinition <Puzzle> filter = filterBuilder.Nin("_id", excludedIds) & filterBuilder.Eq("inReview", false)
& filterBuilder.Eq("approved", true);
if (variant != "Mixed")
{
filter &= filterBuilder.Eq("variant", variant);
}
if (userId.HasValue)
{
filter &= filterBuilder.Ne("author", userId.Value) & filterBuilder.Nin("reviewers", new int[] { userId.Value });
}
FilterDefinition <Puzzle> lteFilter = filter;
FilterDefinition <Puzzle> gtFilter = filter;
bool higherRated = RandomBoolean();
gtFilter &= filterBuilder.Gt("rating.value", nearRating);
lteFilter &= filterBuilder.Lte("rating.value", nearRating);
var foundGt = puzzleCollection.Find(gtFilter);
var foundLte = puzzleCollection.Find(lteFilter);
if (foundGt == null && foundLte == null)
{
return(null);
}
SortDefinitionBuilder <Puzzle> sortBuilder = Builders <Puzzle> .Sort;
foundGt = foundGt.Sort(sortBuilder.Ascending("rating.value")).Limit(1);
foundLte = foundLte.Sort(sortBuilder.Descending("rating.value")).Limit(1);
Puzzle oneGt = foundGt.FirstOrDefault();
Puzzle oneLte = foundLte.FirstOrDefault();
if (oneGt == null)
{
return(oneLte);
}
else if (oneLte == null)
{
return(oneGt);
}
else
{
return(RandomBoolean() ? oneGt : oneLte);
}
}
/// <inheritdoc/>
public async Task <CommittedAggregateEvents> FetchForAggregate(EventSourceId eventSource, ArtifactId aggregateRoot, CancellationToken cancellationToken)
{
try
{
using var session = await _streams.StartSessionAsync(cancellationToken : cancellationToken).ConfigureAwait(false);
return(await session.WithTransactionAsync(
async (transaction, cancel) =>
{
var version = await _aggregateRoots.FetchVersionFor(
transaction,
eventSource,
aggregateRoot,
cancel).ConfigureAwait(false);
if (version > AggregateRootVersion.Initial)
{
var filter = _eventFilter.Eq(_ => _.Aggregate.WasAppliedByAggregate, true)
& _eventFilter.Eq(_ => _.Metadata.EventSource, eventSource.Value)
& _eventFilter.Eq(_ => _.Aggregate.TypeId, aggregateRoot.Value)
& _eventFilter.Lte(_ => _.Aggregate.Version, version.Value);
var events = await _streams.DefaultEventLog
.Find(transaction, filter)
.Sort(Builders <MongoDB.Events.Event> .Sort.Ascending(_ => _.Aggregate.Version))
.Project(_ => _.ToCommittedAggregateEvent())
.ToListAsync(cancel).ConfigureAwait(false);
return new CommittedAggregateEvents(
eventSource,
aggregateRoot,
events);
}
else
{
return new CommittedAggregateEvents(
eventSource,
aggregateRoot,
Array.Empty <CommittedAggregateEvent>());
}
},
cancellationToken : cancellationToken).ConfigureAwait(false));
}
catch (MongoWaitQueueFullException ex)
{
throw new EventStoreUnavailable("Mongo wait queue is full", ex);
}
}
private static void CreateTimeFilter(HeatDataResultRequestDto input, FilterDefinitionBuilder <BsonDocument> builderFilter, List <FilterDefinition <BsonDocument> > filterDefinitions)
{
List <FilterDefinition <BsonDocument> > timeFilterDefinitions = new List <FilterDefinition <BsonDocument> >();
input.Dates.ForEach(x =>
{
var date = x.ToLocalTime();
timeFilterDefinitions.Add(builderFilter.And(new List <FilterDefinition <BsonDocument> >()
{
builderFilter.Gte("updateTimeList.status1", new DateTime(date.Year, date.Month, date.Day, input.Times[0].Hour, input.Times[0].Minute, input.Times[0].Second, DateTimeKind.Local)),
builderFilter.Lte("updateTimeList.status1", new DateTime(date.Year, date.Month, date.Day, input.Times[1].Hour, input.Times[1].Minute, input.Times[1].Second, DateTimeKind.Local)),
}));
});
if (timeFilterDefinitions.Count > 0)
{
filterDefinitions.Add(builderFilter.Or(timeFilterDefinitions));
}
}
async Task <CommittedAggregateEvents> DoFetchForAggregate(
EventSourceId eventSource,
ArtifactId aggregateRoot,
Func <FilterDefinition <MongoDB.Events.Event>, FilterDefinition <MongoDB.Events.Event> > filterCallback,
CancellationToken cancellationToken)
{
try
{
var version = await _aggregateRoots.FetchVersionFor(
eventSource,
aggregateRoot,
cancellationToken).ConfigureAwait(false);
if (version <= AggregateRootVersion.Initial)
{
return(new CommittedAggregateEvents(
eventSource,
aggregateRoot,
Array.Empty <CommittedAggregateEvent>()));
}
var defaultFilter = _eventFilter.Eq(_ => _.Aggregate.WasAppliedByAggregate, true)
& _eventFilter.EqStringOrGuid(_ => _.Metadata.EventSource, eventSource.Value)
& _eventFilter.Eq(_ => _.Aggregate.TypeId, aggregateRoot.Value)
& _eventFilter.Lte(_ => _.Aggregate.Version, version.Value);
var filter = filterCallback(defaultFilter);
var events = await _streams.DefaultEventLog
.Find(filter)
.Sort(Builders <MongoDB.Events.Event> .Sort.Ascending(_ => _.Aggregate.Version))
.ToListAsync(cancellationToken).ConfigureAwait(false);
return(new CommittedAggregateEvents(
eventSource,
aggregateRoot,
events.Select(_ => _eventConverter.ToRuntimeStreamEvent(_))
.Select(_ => _.Event)
.Cast <CommittedAggregateEvent>().ToList()));
}
catch (Exception ex)
{
throw new EventStoreUnavailable("Mongo wait queue is full", ex);
}
}
static void Main(string[] args)
{
var client = new MongoClient("mongodb+srv://ITDS_USER:[email protected]/sample_mflix?retryWrites=true&w=majority");
var database = client.GetDatabase("sample_mflix");
var filterBuilder = new FilterDefinitionBuilder <BsonDocument>();
var filter = filterBuilder.Lte("year", 1983);
using (IAsyncCursor <BsonDocument> documents = database.GetCollection <BsonDocument>("movies").FindSync(filter))
{
while (documents.MoveNext())
{
foreach (var doc in documents.Current)
{
Console.WriteLine(doc.ToJson());
}
}
}
}
public override FilterDefinition <T> Visit(FilterComparison nodeIn)
{
var propertyName = string.Join(".", nodeIn.Lhs);
switch (nodeIn.Operator)
{
case FilterOperator.Empty:
return(Filter.Or(Filter.Exists(propertyName, false), Filter.Eq(propertyName, default(T)), Filter.Eq(propertyName, string.Empty), Filter.Eq(propertyName, new T[0])));
case FilterOperator.StartsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s)));
case FilterOperator.Contains:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s)));
case FilterOperator.EndsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$")));
case FilterOperator.Equals:
return(Filter.Eq(propertyName, nodeIn.Rhs.Value));
case FilterOperator.GreaterThan:
return(Filter.Gt(propertyName, nodeIn.Rhs.Value));
case FilterOperator.GreaterThanOrEqual:
return(Filter.Gte(propertyName, nodeIn.Rhs.Value));
case FilterOperator.LessThan:
return(Filter.Lt(propertyName, nodeIn.Rhs.Value));
case FilterOperator.LessThanOrEqual:
return(Filter.Lte(propertyName, nodeIn.Rhs.Value));
case FilterOperator.NotEquals:
return(Filter.Ne(propertyName, nodeIn.Rhs.Value));
case FilterOperator.In:
return(Filter.In(propertyName, ((IList)nodeIn.Rhs.Value).OfType <object>()));
}
throw new NotSupportedException();
}
public static List <ProcessedLogInfo> GetAndProcessData(MongoConnectionClass db, long min = 0, long max = long.MaxValue)
{
FilterDefinitionBuilder <LogInfo> builder = Builders <LogInfo> .Filter;
FilterDefinition <LogInfo> filter = builder.Gte("unix_timestamp", min)
& builder.Lte("unix_timestamp", max);
IMongoCollection <LogInfo> logCollection = db.Database.GetCollection <LogInfo>("Copy_of_logs");
try
{
//List<LogInfo> logList = logCollection.Find(new BsonDocument()).Limit(limit).ToList();
List <LogInfo> logList = logCollection.Find(filter).ToList();
return(PreprocessLogClass(logList));
}
catch (OutOfMemoryException)
{
Console.WriteLine("Can't load such big size of logs, try smaller time window");
throw;
}
}
public async Task <IEnumerable <Phone> > GetPhones(int?minPrice, int?maxPrice, string name)
{
var builder = new FilterDefinitionBuilder <Phone>();
var filter = builder.Empty;
if (!String.IsNullOrWhiteSpace(name))
{
filter = filter & builder.Regex("Name", new BsonRegularExpression(name));
}
if (minPrice.HasValue)
{
filter = filter & builder.Gte("Price", minPrice.Value);
}
if (maxPrice.HasValue)
{
filter = filter & builder.Lte("Price", maxPrice.Value);
}
return(await Phones.Find(filter).ToListAsync());
}
public FilterDefinition <T> GetFromCompareType <T>(FilterCondition s)
{
FilterDefinitionBuilder <T> filter = Builders <T> .Filter;
if (s.Value == null)
{
return(filter.Empty);
}
switch (s.CompareType)
{
case TableCompareType.EQ:
return(filter.Eq(s.Key, s.Value));
case TableCompareType.GT:
return(filter.Gt(s.Key, s.Value));
case TableCompareType.GTE:
return(filter.Gte(s.Key, s.Value));
case TableCompareType.LT:
return(filter.Lt(s.Key, s.Value));
case TableCompareType.LTE:
return(filter.Lte(s.Key, s.Value));
case TableCompareType.NE:
return(filter.Ne(s.Key, s.Value));
case TableCompareType.REGEX:
{
return(filter.Regex(s.Key, s.Value.ToString()));
}
case TableCompareType.TEXT:
return(filter.Text(s.Value.ToString()));
default:
return(filter.Eq(s.Key, s.Value));
}
}
// получаем все документы, используя критерии фальтрации
public async Task <IEnumerable <Book> > GetProducts(int?minPrice, int?maxPrice, string name)
{
// строитель фильтров
var builder = new FilterDefinitionBuilder <Book>();
var filter = builder.Empty; // фильтр для выборки всех документов
// фильтр по имени
if (!String.IsNullOrWhiteSpace(name))
{
filter = filter & builder.Regex("Name", new BsonRegularExpression(name));
}
if (minPrice.HasValue) // фильтр по минимальной цене
{
filter = filter & builder.Gte("Price", minPrice.Value);
}
if (maxPrice.HasValue) // фильтр по максимальной цене
{
filter = filter & builder.Lte("Price", maxPrice.Value);
}
return(await Books.Find(filter).ToListAsync());
}
//we get all documents using falsification criteria
public async Task <IEnumerable <Product> > GetProducts(int?minPrice, int?maxPrice, string name)
{
// filter builder
var builder = new FilterDefinitionBuilder <Product>();
var filter = builder.Empty; //filter for selection of all documents
// filter by name
if (!String.IsNullOrWhiteSpace(name))
{
filter = filter & builder.Regex("Name", new BsonRegularExpression(name));
}
if (minPrice.HasValue) //filter at the lowest price
{
filter = filter & builder.Gte("Price", minPrice.Value);
}
if (maxPrice.HasValue) //filter at maximum price
{
filter = filter & builder.Lte("Price", maxPrice.Value);
}
return(await Products.Find(filter).ToListAsync());
}
public List <Place> Get(PlaceFilterInfo placeFilter)
{
var queryBuilder = new FilterDefinitionBuilder <Place>();
var filters = new List <FilterDefinition <Place> >();
if (placeFilter.Name != null)
{
filters.Add(queryBuilder.Eq("Name", placeFilter.Name));
}
if (placeFilter.Address != null)
{
filters.Add(queryBuilder.Eq("Address", placeFilter.Address));
}
if (placeFilter.Description != null)
{
filters.Add(queryBuilder.Eq("Description", placeFilter.Description));
}
if (placeFilter.PriceMin != null)
{
filters.Add(queryBuilder.Gte("Price", placeFilter.PriceMin));
}
if (placeFilter.PriceMax != null)
{
filters.Add(queryBuilder.Lte("Price", placeFilter.PriceMax));
}
if (placeFilter.OwnerId != null)
{
filters.Add(queryBuilder.Eq("OwnerId", placeFilter.OwnerId));
}
if (filters.Count != 0)
{
return(places.Find(queryBuilder.And(filters)).ToList());
}
else
{
return(places.Find(x => true).ToList());
}
}
///<inheritdoc/>
public async Task <IrpfTax> GetActive(DateTime?date, CancellationToken cancellationToken = default)
{
FilterDefinitionBuilder <IrpfTax> builder = Builders <IrpfTax> .Filter;
FilterDefinition <IrpfTax> filter;
if (date.HasValue)
{
filter =
builder.Lte(nameof(IrpfTax.DateStart).ToCamelCase(), date.Value)
& (
builder.Gte(nameof(IrpfTax.DateEnd).ToCamelCase(), date.Value)
| builder.Eq(nameof(IrpfTax.DateEnd).ToCamelCase(), BsonNull.Value)
);
}
else
{
filter = builder.Eq(nameof(IrpfTax.Inactive).ToCamelCase(), false);
}
IrpfTax result = await Collection.Find(filter).FirstOrDefaultAsync(cancellationToken);
return(result);
}
public override FilterDefinition <MongoContentEntity> Visit(BinaryOperatorNode nodeIn)
{
if (nodeIn.OperatorKind == BinaryOperatorKind.And)
{
return(Filter.And(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.Or)
{
return(Filter.Or(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.NotEqual)
{
return(Filter.Ne(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.Equal)
{
return(Filter.Eq(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.LessThan)
{
return(Filter.Lt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.LessThanOrEqual)
{
return(Filter.Lte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThan)
{
return(Filter.Gt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThanOrEqual)
{
return(Filter.Gte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
throw new NotSupportedException();
}
private List<FilterDefinition<Flight>> CreateClauses(SearchCriteriaModel criteriaModel, FilterDefinitionBuilder<Flight> filterBuilder)
{
var clauses = new List<FilterDefinition<Flight>>();
if (criteriaModel.FromDate != null)
{
var fromDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.FromDate), DateTimeKind.Utc);
var clause = filterBuilder.Gte(f => f.FlightDate, fromDate);
clauses.Add(clause);
}
if (criteriaModel.ToDate != null)
{
var toDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.ToDate), DateTimeKind.Utc);
var clause = filterBuilder.Lte(f => f.FlightDate, toDate);
clauses.Add(clause);
}
if (criteriaModel.AirlineId != null)
{
var clause = filterBuilder.Eq(f => f.AirlineId, criteriaModel.AirlineId.Value);
clauses.Add(clause);
}
if (criteriaModel.OriginId != null)
{
var clause = filterBuilder.Eq(f => f.OriginAirportId, criteriaModel.OriginId.Value);
clauses.Add(clause);
}
if (criteriaModel.DestinationId != null)
{
var clause = filterBuilder.Eq(f => f.DestinationAirportId, criteriaModel.DestinationId.Value);
clauses.Add(clause);
}
return clauses;
}