public CustomFiltersScoreQueryBuilder Add(IFilterBuilder filter, float boost)
{
_filters.Add(filter);
_scripts.Add(null);
_boosts.Add(boost);
return(this);
}
public void SetUp() {
serverConfig = A.Fake<IServerConfig>();
directoryEntryFactory = A.Fake<IDirectoryEntryFactory>();
filterBuilde = new FilterBuilder(serverConfig);
nameParser = new NameParser();
adapter = new DirectoryEntryAdapter(serverConfig, directoryEntryFactory, filterBuilde, nameParser);
}
public SearchBaseController(ISchoolSearchService schoolSearchService, ITrustSearchService trustSearchService, ISchoolBenchmarkListService benchmarkListService, IFilterBuilder filterBuilder)
{
_schoolSearchService = schoolSearchService;
_trustSearchService = trustSearchService;
_schoolBenchmarkListService = benchmarkListService;
_filterBuilder = filterBuilder;
}
//private MongoCursor<UserEvent> GetEventsCursor(ObjectId campaignId,
// IEnumerable<EventTypeEnum> eventTypes, DateTime? start, DateTime? end)
//{
// var query = Query.And(Query.EQ("CampaignId", campaignId),
// Query.In("EventTypeId", eventTypes.Select(x => BsonValue.Create((int)x))));
// if (start.HasValue)
// query = Query.And(query, Query.GTE("EventDate", start.Value.ToUniversalTime().Ticks));
// if (end.HasValue)
// query = Query.And(query, Query.LTE("EventDate", end.Value.ToUniversalTime().Ticks));
// query = Query.And(query, Query.NE("Hidden", true));
// return Context..SlaveServerCollection.FindAs<UserEvent>(query);
//}
public IEnumerable <Object> WinsReport(IFilterBuilder userFilter, IFilterBuilder prizeFilter, ISort sort, int skip, int limit)
{
IMongoQuery query = null;
if (userFilter != null)
{
query = new MongoFilterVisitor(userFilter.Build()).Build();
}
var queryPrize = Query.And(Query.Exists("Prizes._v"),
Query.Not(Query.Size("Prizes._v", 0)),
Query.NE("Hidden", true));
if (query != null)
{
query = Query.And(queryPrize, query);
}
else
{
query = queryPrize;
}
var aggQuery = new AggregationBuilder("User")
.Match(query)
.Project(winReportFields)
.Unwind("$Prizes._v")
.Match(new MongoFilterVisitor(prizeFilter.Build()).Build())
.Sort(sort)
.Skip(skip)
.Limit(limit).Pipeline;
//Console.WriteLine(aggQuery.ToString());
return(AggregationResultToList(RunAggreation(aggQuery)));
}
public CustomFiltersScoreQueryBuilder Add(IFilterBuilder filter, float boost)
{
_filters.Add(filter);
_scripts.Add(null);
_boosts.Add(boost);
return this;
}
/// <summary>
/// Public constructor
/// </summary>
public FilterService()
{
_facilityService = new FacilityService();
_searchService = new SearchService();
_popularCityService = new PopulairCitiesService();
_filterBuilder = new FilterBuilder();
}
public IEnumerable <Object> RegistrationReport(IFilterBuilder userFilter, ISort sort, int skip, int limit)
{
IMongoQuery query = null;
if (userFilter != null)
{
query = new MongoFilterVisitor(userFilter.Build()).Build();
}
//var aggQuery = new AggregationBuilder("UserXUserEvent")
// .Match(query)
// .Project(registrationReportFields)
// .Unwind("$UserEvents")
// .Sort(sort)
// .Skip(skip)
// .Limit(limit).Pipeline;
var aggQuery = new AggregationBuilder("User")
.Match(query)
.Project(registrationReportFields)
.Sort(sort)
.Skip(skip)
.Limit(limit).Pipeline;
// Debug.WriteLine(aggQuery);
//return RunCommand(aggQuery);
return(AggregationResultToList(RunAggreation(aggQuery)));
}
public IEnumerable <Tuple <DateTime, Int32> > WinsGraph(IFilterBuilder userFilter, IFilterBuilder prizeFilter, bool byDay)
{
IMongoQuery query = null;
if (userFilter != null)
{
query = new MongoFilterVisitor(userFilter.Build()).Build();
}
var queryPrize = Query.And(Query.Exists("Prizes._v"),
Query.Not(Query.Size("Prizes._v", 0)),
Query.NE("Hidden", true));
if (query != null)
{
query = Query.And(queryPrize, query);
}
var aggQuery = new AggregationBuilder("User")
.Match(query)
.Project(new Dictionary <String, object> {
{ "Prizes._v", 1 }
})
.Unwind("$Prizes._v")
.Match(new MongoFilterVisitor(prizeFilter.Build()).Build())
.Project(winGraphProjection)
.Group(byDay ? byDayGroup : byMinuteGroup);
var im = AggregationResultToList(RunAggreation(aggQuery.Pipeline));
return(byDay ? GraphByDays(im) : GraphByMinutes(im));
}
public BlobDetector(IFilterBuilder filterBuilder, string path)
{
_filterBuilder = filterBuilder;
_dataInitializer = new DataInitializer(path);
_path = path;
_originalImage = new ImageWrapper(new Bitmap(path));
_scaleSpace = new ScaleLevel[(int)(((FinalT - InitialT) / Step) + 1)];
}
public void SetUp() {
nameParser = new NameParser();
searcherFactory = A.Fake<ISearcherFactory>();
directoryEntryAdapter = A.Fake<IDirectoryEntryAdapter>();
ldapConfig = A.Fake<ILdapConfig>();
filterBuilder = new FilterBuilder(ldapConfig.Server);
adapter = new TestableUserEntryAdapter(ldapConfig, directoryEntryAdapter, searcherFactory, filterBuilder, nameParser);
}
public void SetUp()
{
serverConfig = A.Fake <IServerConfig>();
directoryEntryFactory = A.Fake <IDirectoryEntryFactory>();
filterBuilde = new FilterBuilder(serverConfig);
nameParser = new NameParser();
adapter = new DirectoryEntryAdapter(serverConfig, directoryEntryFactory, filterBuilde, nameParser);
}
Update.IWhere Update.ISet.Where(IFilterBuilder filter)
{
_where = new List <string>()
{
filter.BuildFilter()
};
return(this);
}
public Task <AzureTableQueryResult> ExecuteQueryAsync(string tableName, IFilterBuilder filterBuilder, string propertyFilter, Func <AzureTablePropertyBag, bool> clientSideFilter, DateTimeOffset startTime, DateTimeOffset endTime, int count, CancellationToken token)
{
if (filterBuilder == null)
{
throw new ArgumentNullException("filterBuilder");
}
return(this.ExecuteQueryAsyncInternal(tableName, filterBuilder.BuildFilter(propertyFilter, startTime, endTime), clientSideFilter, count, token));
}
public void SetUp()
{
nameParser = new NameParser();
searcherFactory = A.Fake <ISearcherFactory>();
directoryEntryAdapter = A.Fake <IDirectoryEntryAdapter>();
ldapConfig = A.Fake <ILdapConfig>();
filterBuilder = new FilterBuilder(ldapConfig.Server);
adapter = new TestableUserEntryAdapter(ldapConfig, directoryEntryAdapter, searcherFactory, filterBuilder, nameParser);
}
public void SetUp()
{
nameParser = new NameParser();
searcherFactory = A.Fake <ISearcherFactory>();
directoryEntryAdapter = A.Fake <IDirectoryEntryAdapter>();
groupConfig = A.Fake <IGroupsConfig>();
filterBuilder = new FilterBuilder(A.Fake <IServerConfig>());
adapter = new GroupEntryAdapter(groupConfig, directoryEntryAdapter, searcherFactory, filterBuilder, nameParser);
}
public IEnumerable <IPrize> GetPrizesGridData(IFilterBuilder userFilter, IFilterBuilder prizeFilter, int skip, int limit, ISort sort)
{
var pzsList = PrizesData(userFilter, prizeFilter, skip, limit, sort).ToList();
var list = BsonSerializer.Deserialize <List <Prize> >(pzsList.ToJson());
//// pzsList.Add(tObj);
//tObj.Result = Result.ConvertAll(o => (IPrize))
return(list);
}
public IEnumerable <IPrize> GetPrizesGraphData(IFilterBuilder userFilter, IFilterBuilder prizeFilter)
{
var pzsList = PrizesGraph(userFilter, prizeFilter).ToList();
var list = BsonSerializer.Deserialize <List <Prize> >(pzsList.ToJson());
//// pzsList.Add(tObj);
//tObj.Result = Result.ConvertAll(o => (IPrize))
return(list);
}
public UserEntryAdapter(ILdapConfig configuration,
IDirectoryEntryAdapter directoryEntryAdapter,
ISearcherFactory searcherFactory,
IFilterBuilder filterBuilder,
INameParser nameParser) : base(searcherFactory) {
this.configuration = configuration;
this.directoryEntryAdapter = directoryEntryAdapter;
this.nameParser = nameParser;
this.filterBuilder = filterBuilder;
}
public DirectoryEntryAdapter(IServerConfig serverConfig,
IDirectoryEntryFactory directoryEntryFactory,
IFilterBuilder filterBuilder,
INameParser nameParser)
{
this.serverConfig = serverConfig;
this.directoryEntryFactory = directoryEntryFactory;
this.filterBuilder = filterBuilder;
this.nameParser = nameParser;
}
public GroupEntryAdapter(IGroupsConfig groupConfig,
IDirectoryEntryAdapter directoryEntryAdapter,
ISearcherFactory searcherFactory,
IFilterBuilder filterBuilder,
INameParser nameParser) : base(searcherFactory) {
this.groupConfig = groupConfig;
this.directoryEntryAdapter = directoryEntryAdapter;
this.filterBuilder = filterBuilder;
this.nameParser = nameParser;
}
private IEnumerable <IUserProfilePromo> ReportUserPromoCode(IFilterBuilder userFilter, IFilterBuilder promoFilter, ISort sort, int skip, int limit)
{
var aggQuery = UserPromoCodeReportCommon(userPromoListFields, userFilter, promoFilter)
.Sort(sort)
.Skip(skip)
.Limit(limit).Pipeline;
// Debug.WriteLine(aggQuery.ToJson());
// return RunAggreationToList<UserProfilePromo>(aggQuery);
return(GetAggregationResult(aggQuery));
}
public UserEntryAdapter(ILdapConfig configuration,
IDirectoryEntryAdapter directoryEntryAdapter,
ISearcherFactory searcherFactory,
IFilterBuilder filterBuilder,
INameParser nameParser) : base(searcherFactory)
{
this.configuration = configuration;
this.directoryEntryAdapter = directoryEntryAdapter;
this.nameParser = nameParser;
this.filterBuilder = filterBuilder;
}
private IEnumerable <Tuple <DateTime, Int32> > GraphRegistration(IFilterBuilder userFilter, IFilterBuilder promoFilter, bool byDay)
{
var aggQuery = RegistrationReportCommon(userPromoListFields, userFilter, promoFilter)
.Project(registrationGraphProjection)
.Group(byDay ? byDayGroup : byMinuteGroup).Pipeline;
// Debug.WriteLine(aggQuery.ToJson());
var im = AggregationResultToList(RunAggreation(aggQuery));
return(byDay ? GraphByDays(im) : GraphByMinutes(im));
}
public GroupEntryAdapter(IGroupsConfig groupConfig,
IDirectoryEntryAdapter directoryEntryAdapter,
ISearcherFactory searcherFactory,
IFilterBuilder filterBuilder,
INameParser nameParser) : base(searcherFactory)
{
this.groupConfig = groupConfig;
this.directoryEntryAdapter = directoryEntryAdapter;
this.filterBuilder = filterBuilder;
this.nameParser = nameParser;
}
public IEnumerable <Tuple <DateTime, Int32> > UserPromoCodeGraph(IFilterBuilder userFilter, IFilterBuilder promoFilter, bool byDay, EventTypeEnum eventType)
{
if (eventType == EventTypeEnum.RegistrationSuccessful)
{
return(GraphRegistration(userFilter, promoFilter, byDay));
}
if (eventType == EventTypeEnum.PromoCodeSuccessful)
{
return(GraphUserPromoCode(userFilter, promoFilter, byDay));
}
return(null);
}
public ManualComparisonController(ISchoolBenchmarkListService benchmarkBasketService, ILocalAuthoritiesService laService,
IContextDataService contextDataService, IValidationService valService, ILocationSearchService locationSearchService,
ISchoolSearchService schoolSearchService, IFilterBuilder filterBuilder, ILaSearchService laSearchService, IManualBenchmarkListService manualBenchmarkListService)
: base(schoolSearchService, null, benchmarkBasketService, filterBuilder)
{
_laService = laService;
_laSearchService = laSearchService;
_contextDataService = contextDataService;
_valService = valService;
_locationSearchService = locationSearchService;
_manualBenchmarkListService = manualBenchmarkListService;
}
public DataFetcher(string tableName, string namePrefix, string deploymentId, int maxSingleTakeCount, IAzureTableStorageAccess azureTableAccess)
{
Assert.IsNotEmptyOrNull(tableName, "tableName != null");
Assert.IsNotNull(azureTableAccess, "azureTableAccess != null");
this.tableName = tableName;
this.filterBuilder = new AzureTimeLoggedBasedFilterBuilder();
this.azureTableAccess = azureTableAccess;
this.namePrefix = namePrefix;
this.deploymentId = deploymentId;
this.decoratedTableName = null;
this.takeCount = maxSingleTakeCount;
}
public IEnumerable <Object> WinnersReport(IFilterBuilder userFilter, IFilterBuilder prizeFilter, ISort sort, int skip, int limit)
/**
* > db.User.aggregate(
* {$match: { CampaignId: ObjectId("5011b6099610f710f4fd438e"), PrizeCount: {$gt:3}}}, # user fields
* {$project: { LastName: 1, Prizes:1} } # return fields and Prizes
* {$unwind: '$Prizes._v'}, # unwind the prizes
* {$match: {"Prizes._v.PrizeDate": {$gte: NumberLong("634794549227340147"), $lte: NumberLong("634794559975708161")}}}
* # match on prizes
* {$group: { _id: { _id: '$_id', LastName: '$LastName' ....}, # re-group all the fields you want to see except...
* "Prizes" : { $addToSet: '$Prizes._v'}}}, # prizes, which you add to set (and now they are unsorted!)
* {$project: { _id: "$_id._id", LastName:"$_id.LastName", Prizes: 1}}) # project out of _id to get to top level
*/
{
IMongoQuery userQuery = null;
if (userFilter != null)
{
userQuery = new MongoFilterVisitor(userFilter.Build()).Build();
}
var queryPrize = Query.And(Query.Exists("Prizes._v"),
Query.Not(Query.Size("Prizes._v", 0)),
Query.NE("Hidden", true));
userQuery = userQuery != null?Query.And(queryPrize, userQuery) : queryPrize;
IMongoQuery prizeQuery = new MongoFilterVisitor(prizeFilter.Build()).Build();
var groupFields = winnersReportFields.Keys.Where(x => !x.StartsWith("Prizes")).ToList();
var id = FieldDocument("$", groupFields);
var finalProject = FieldDocument("$_id.", groupFields).Add("Prizes", 1);
var group = new BsonDocument {
{ "_id", id }, { "Prizes", new BsonDocument("$addToSet", "$Prizes._v") }
};
var aggQuery = new AggregationBuilder("User")
.Match(userQuery)
.Project(winnersReportFields)
.Unwind("$Prizes._v")
.Match(prizeQuery)
.Group(group)
.Project(finalProject)
.Sort(sort)
.Skip(skip)
.Limit(limit).Pipeline;
//Console.WriteLine(aggQuery.ToString());
return(AggregationResultToList(RunAggreation(aggQuery)));
}
public long GetWinsCount(ObjectId campaignId, IFilterBuilder userFilter, IFilterBuilder prizeFilter)
{
var pList = WinsGraphBase(userFilter, prizeFilter);
long totalCount = 0;
//foreach (var o in pList)
//{
// var u = BsonSerializer.Deserialize<User>(o.ToJson());
// totalCount += u.Prizes.Count;
//}
return(totalCount);
}
public SchoolSearchController(ILocalAuthoritiesService laService,
ILaSearchService laSearchService, IFilterBuilder filterBuilder,
IValidationService valService, IContextDataService contextDataService,
ISchoolSearchService schoolSearchService, ITrustSearchService trustSearchService)
{
_laService = laService;
_laSearchService = laSearchService;
_filterBuilder = filterBuilder;
_valService = valService;
_contextDataService = contextDataService;
_schoolSearchService = schoolSearchService;
_trustSearchService = trustSearchService;
}
public IEnumerable <IUserProfilePromo> UserPromoCodeReport(IFilterBuilder userFilter, IFilterBuilder promoFilter, ISort sort, int skip, int limit, EventTypeEnum eventType)
{
List <IUserProfilePromo> result = null;
if (eventType == EventTypeEnum.RegistrationSuccessful)
{
result = ReportRegistration(userFilter, promoFilter, sort, skip, limit).ToList();
}
if (eventType == EventTypeEnum.PromoCodeSuccessful)
{
result = ReportUserPromoCode(userFilter, promoFilter, sort, skip, limit).ToList();
}
return(result);
}
private IEnumerable <Tuple <DateTime, Int32> > GraphUserPromoCode(IFilterBuilder userFilter, IFilterBuilder promoFilter, bool byDay)
{
var aggQuery = UserPromoCodeReportCommon(new Dictionary <String, object> {
{ "PromoCodes._v", 1 }
}, userFilter,
promoFilter)
.Project(userPromoGraphProjection)
.Group(byDay ? byDayGroup : byMinuteGroup).Pipeline;
// Debug.WriteLine(aggQuery.ToJson());
var im = AggregationResultToList(RunAggreation(aggQuery));
return(byDay ? GraphByDays(im) : GraphByMinutes(im));
}
/*
* Count Prizes won, grouped by Prize description
*/
protected AggregationBuilder PrizesGraphBase(IFilterBuilder userFilter, IFilterBuilder prizeFilter)
{
var group = new BsonDocument {
{ "_id", "$Prizes._v.PrizeId" }, { "Awarded", new BsonDocument("$sum", 1) }
};
// var groupCount = new BsonDocument { { "_id", "$Count" }, { "Count", new BsonDocument("$sum", 1) } };
var aggQuery = WinsGraphBase(userFilter, prizeFilter)
.Group(group)
.Project(new Dictionary <string, object> {
{ "_id", 1 }, { "Awarded", 1 },
})
;
return(aggQuery);
}
public IEnumerable <Object> SpinReport(IFilterBuilder userFilter, IFilterBuilder eventFilter, ISort sort, int skip, int limit)
{
IMongoQuery query = new MongoFilterVisitor(userFilter.Build()).Build();
IMongoQuery eventQuery = new MongoFilterVisitor(eventFilter.Build()).Build();
var aggQuery = new AggregationBuilder("UserXUserEvent")
.Match(query)
.Project(registrationReportFields)
.Unwind("UserEvents")
.Match(eventQuery)
.Sort(sort)
.Skip(skip)
.Limit(limit)
.Pipeline;
return(AggregationResultToList(RunAggreation(aggQuery)));
}
public Container(ILdapConfig configuration)
{
nameParser = new NameParser();
directoryEntryFactory = new DirectoryEntryFactory();
filterBuilder = new FilterBuilder(configuration.Server);
searcherFactory = new SearcherFactory(configuration.Server, filterBuilder);
directoryEntryAdapter = new DirectoryEntryAdapter(configuration.Server,
directoryEntryFactory,
filterBuilder,
nameParser);
groupEntryAdapter = new GroupEntryAdapter(configuration.Groups, directoryEntryAdapter, searcherFactory, filterBuilder, nameParser);
userEntryAdapter = new UserEntryAdapter(configuration,
directoryEntryAdapter,
searcherFactory,
filterBuilder,
nameParser);
}
public IEnumerable <Tuple <DateTime, Int32> > RegistrationGraph(IFilterBuilder userFilter, bool byDay)
{
IMongoQuery query = null;
if (userFilter != null)
{
query = new MongoFilterVisitor(userFilter.Build()).Build();
}
var aggQuery = new AggregationBuilder("User")
.Match(query)
.Project(registrationGraphProjection)
.Group(byDay ? byDayGroup : byMinuteGroup);
var im = AggregationResultToList(RunAggreation(aggQuery.Pipeline));
return(byDay ? GraphByDays(im) : GraphByMinutes(im));
}
private async Task <IDictionary <TKey, TValue> > FetchDataInternalAsync(IFilterBuilder receivedFilterBuilder, string propertyFilter, Func <AzureTablePropertyBag, bool> clientSideFilter, DateTimeOffset startTime, DateTimeOffset endTime, int takeCount, CancellationToken token)
{
if (this.decoratedTableName == null)
{
var decorator = new ServiceFabricAzureAccessDataDecorator(this.azureTableAccess, this.namePrefix, this.deploymentId);
this.decoratedTableName = await decorator.DecorateTableNameAsync(this.tableName, token).ConfigureAwait(false);
}
if (takeCount == -1)
{
takeCount = MaxTakeCount;
}
var azureQueryResult = await this.azureTableAccess.ExecuteQueryAsync(this.decoratedTableName, receivedFilterBuilder, propertyFilter, clientSideFilter, startTime, endTime, takeCount, token).ConfigureAwait(false);
return(azureQueryResult.AzureTableProperties.ToDictionary(
oneRow => (TKey)(ICacheKey) new AzureTableCacheKey(oneRow.PartitionKey, oneRow.RowKey, startTime, endTime, oneRow.TimeLogged, oneRow.TimeStamp),
oneRow => (TValue)(ICacheValue) new AzureTableCacheValue(oneRow)));
}
public IList<ScaleLevel> ReadData(IFilterBuilder filterBuilder)
{
var result = new List<ScaleLevel>();
foreach (var path in Directory.EnumerateFiles(FolderName))
{
var fileInfo = new FileInfo(path);
if (Extension.Equals(fileInfo.Extension, StringComparison.OrdinalIgnoreCase))
{
using (var stream = fileInfo.OpenRead())
{
var deserilizer = new BinaryFormatter();
var metadata = (ScaleMetadata)deserilizer.Deserialize(stream);
var scaleLevel = new ScaleLevel(filterBuilder.Build(metadata.T), metadata.Image);
result.Add(scaleLevel);
}
}
}
return result;
}
/// <summary>
/// A query that wraps a filter and simply returns a constant score equal to the
/// query boost for every document in the filter.
/// </summary>
/// <param name="filterBuilder">The filter to wrap in a constant score query</param>
public ConstantScoreQueryBuilder(IFilterBuilder filterBuilder)
{
_filterBuilder = filterBuilder;
}
protected AbstractFacetBuilder FacetFilter(IFilterBuilder filter)
{
_facetFilter = filter;
return this;
}
/// <summary>
/// A query that applies a filter to the results of another query.
/// </summary>
/// <param name="queryBuilder">The query to apply the filter to</param>
/// <param name="filterBuilder">The filter to apply on the query</param>
public FilteredQueryBuilder(IQueryBuilder queryBuilder, IFilterBuilder filterBuilder)
{
_queryBuilder = queryBuilder;
_filterBuilder = filterBuilder;
}
public BoolFilterBuilder Should(IFilterBuilder filterBuilder)
{
_clauses.Add(new Clause(filterBuilder, Occur.SHOULD));
return this;
}
public NestedFilterBuilder(string path, IQueryBuilder queryBuilder)
{
_path = path;
_queryBuilder = queryBuilder;
_filterBuilder = null;
}
public FilteredQueryBuilder(IFilterBuilder filterFactory, IQueryBuilder queryFactory)
{
this.filterFactory = filterFactory;
this.queryFactory = queryFactory;
}
/// <summary>
/// An additional filter used to further filter down the set of documents the facet will run on.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public new RangeScriptFacetBuilder FacetFilter(IFilterBuilder filter)
{
base.FacetFilter(filter);
return this;
}
public FilterBlockBuilder(Stream stream, IFilterBuilder filterBuilder)
{
_stream = stream;
_filterBuilder = filterBuilder;
}
/// <summary>
/// A query that wraps a filter and simply returns a constant score equal to the
/// query boost for every document in the filter.
/// </summary>
/// <param name="filterBuilder">The filter to wrap in a constant score query</param>
/// <returns></returns>
public static ConstantScoreQueryBuilder ConstantScoreQuery(IFilterBuilder filterBuilder)
{
return new ConstantScoreQueryBuilder(filterBuilder);
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static NestedFilterBuilder NestedFilter(string path, IFilterBuilder filter)
{
return new NestedFilterBuilder(path, filter);
}
/// <summary>
///
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public static NotFilterBuilder NotFilter(IFilterBuilder filter)
{
return new NotFilterBuilder(filter);
}
/// <summary>
/// An additional filter used to further filter down the set of documents the facet will run on.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public new GeoDistanceFacetBuilder FacetFilter(IFilterBuilder filter)
{
base.FacetFilter(filter);
return this;
}
public new TermsFacetBuilder Filter(IFilterBuilder filter)
{
_facetFilter = filter;
return this;
}
/// <summary>
/// An additional filter used to further filter down the set of documents the facet will run on.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public new HistogramFacetBuilder FacetFilter(IFilterBuilder filter)
{
base.FacetFilter(filter);
return this;
}
/// <summary>
/// An additional filter used to further filter down the set of documents the facet will run on.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public new QueryFacetBuilder FacetFilter(IFilterBuilder filter)
{
base.FacetFilter(filter);
return this;
}
public new FilterFacetBuilder Filter(IFilterBuilder filter)
{
_filter = filter;
return this;
}
/// <summary>
/// An additional filter used to further filter down the set of documents the facet will run on.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public new StatisticalScriptFacetBuilder FacetFilter(IFilterBuilder filter)
{
base.FacetFilter(filter);
return this;
}
/// <summary>
/// Adds a filter to the list of filters to "or".
/// </summary>
/// <param name="filterBuilder"></param>
/// <returns></returns>
public OrFilterBuilder Add(IFilterBuilder filterBuilder)
{
_filters.Add(filterBuilder);
return this;
}
public static FilterFacetBuilder FilterFacet(string facetName, IFilterBuilder filter)
{
return new FilterFacetBuilder(facetName).Filter(filter);
}
public Clause(IFilterBuilder filterBuilder, Occur occur)
{
Filter = filterBuilder;
Occur = occur;
}
public NestedFilterBuilder(string path, IFilterBuilder filterBuilder)
{
_path = path;
_queryBuilder = null;
_filterBuilder = filterBuilder;
}
public BoolFilterBuilder MustNot(IFilterBuilder filterBuilder)
{
_clauses.Add(new Clause(filterBuilder, Occur.MUST_NOT));
return this;
}
