internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Nickname", ShortName); builder.Simple("Username", Username); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("Message", Message); builder.Relation("Recipient", Recipient); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.ListRelation<GoalType>("Category",Type); builder.ListRelation<GoalPriority>("Priority", Priority); }
public ITypeSearch<EpiFindNotice> CreateQuery(NoticesSearchOptions options) { SearchOptions = options; GetFilter = new FilterBuilder<EpiFindNotice>(_client); Query = _client.Search<EpiFindNotice>(); return Query; }
/// <summary> /// Adds a filter for the list of given <paramref name = "extensions" /> /// </summary> /// <param name = "extensions"></param> /// <returns></returns> public FilterBuilder AddFilter(params string[] extensions) { var filterBuilder = new FilterBuilder(this, extensions); _filters.Add(filterBuilder); return filterBuilder; }
public void TestMethod1() { // arrange var builder = new FilterBuilder(); builder.AddConstraint("endDate", DateTime.Parse("2010-12-26")); var client = new Mock<IMyAtTaskRestClient>(); client.Setup(x => x.Search(ObjCode.TIMESHEET, builder.Filter)) .Returns(JToken.Parse(Resources.timesheets)); client.Setup(x => x.Search(ObjCode.EXPENSE, It.IsAny<List<string>>())) .Returns(JToken.Parse(Resources.expenses)); /* var mapper = new Mock<IPayrollMapper>(); var expectedPayroll = new Payroll[0]; mapper.Setup(x => x.MapTimesheetsToPayrollReportItem(It.IsAny<JToken>(), It.IsAny<JToken>())) .Returns(expectedPayroll);*/ var gateway = new Gateway(new PayrollMapper(), client.Object); // act Payroll[] result = gateway.GetTimesheetsByFilter(builder); // assert var payrollFive = result.Single(x => x.Lastname == "Five"); Assert.AreEqual(13, payrollFive.TotalMileage); //mapper.Verify(m => m.MapTimesheetsToPayrollReportItem( }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("Owner", Owners); builder.Simple("Reference", Reference); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("RegressionSuite", RegressionSuite); builder.Relation("Environment", Environment); }
//TODO investigate if this method redundant and filter can work using base class implementation internal override void InternalModifyState(FilterBuilder builder) { if(HasState) { builder.Root.And(HasActive ? new TokenTerm("AssetState='Active';AssetType='Epic'") : new TokenTerm("AssetState='Closed';AssetType='Epic'")); } else { builder.Root.And(new TokenTerm("AssetState!='Dead';AssetType='Epic'")); } }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.MultiRelation("Owners", Owners); builder.Simple("Reference", Reference); builder.Comparison("DetailEstimate", DetailEstimate); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.ListRelation<TestType>("Category", Type); builder.ListRelation<TestStatus>("Status", Status); builder.Relation("Parent", Epic); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Name", Name); builder.Simple("URL", URL); builder.Relation("Asset", Asset); }
internal override void InternalModifyState(FilterBuilder builder) { // The basic idea is to exclude 'dead' (Epic'd and Deleted) stuff, exept Epic'd Stories // Also take into account the fact that we usually want only active stuff, unless 'Closed' is specified if(HasState) { builder.Root.And(HasActive ? new TokenTerm("(AssetState='Active')") : new TokenTerm("(AssetState='Closed')")); } else { builder.Root.And(new TokenTerm("(AssetState!='Dead')")); } }
public void Builder_Constructs_Proper_Date_Less_Than_Operation() { var builder = new FilterBuilder(); ExpectCorrectDateRangeFilter("startDate", "lte", (field, date) => { builder.LessThanOrEqual(field, date); return builder.Filter; }); }
internal override void InternalModifyState(FilterBuilder builder) { if (HasState) if (HasActive) builder.Root.And(new TokenTerm("AssetState='Active';AssetType='Task'")); else builder.Root.And(new TokenTerm("AssetState='Closed';AssetType='Task'")); else builder.Root.And(new TokenTerm("AssetState!='Dead';AssetType='Task'")); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("LastVersion", Build); builder.ListRelation<TaskSource>("Source", Source); builder.ListRelation<TaskType>("Category", Type); builder.ListRelation<TaskStatus>("Status", Status); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("Scope", Project); builder.MultiRelation("TestSets", TestSet); builder.Simple("Number", DisplayID); builder.Simple("Name", Name); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); if(projects.Count == 1) { CreateSingleScopeFilter(builder); } else { CreateMultipleScopeFilter(builder); } }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("Parent", Parent); builder.Relation("TestSuite", TestSuite); builder.MultiRelation("Targets", Targets); }
List<string> CreateExpenseParameters(DateTime startDate, DateTime endDate) { var expenseBuilder = new FilterBuilder(); expenseBuilder.ShortDateRange("effectiveDate", startDate, endDate); expenseBuilder.AddConstraint("$$LIMIT", "500"); List<string> expenseFields = expenseBuilder.Filter; expenseFields.Add(InChargeExpenseFields); return expenseFields; }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Date",Date); builder.Relation("Timebox", Iteration); builder.Relation("FacilitatedBy", FacilitatedBy); builder.Relation("Team", Team); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Name", Name); builder.Simple("Description", Description); foreach (var kvp in ArbitraryWhereTerms) { builder.Simple(kvp.Key, kvp.Value); } }
public Payroll GetPayrollForEmployee(string userId, DateTime weekEnding) { var builder = new FilterBuilder(); builder.AddConstraint("userID", userId); builder.AddConstraint("endDate", weekEnding); var items = Gateway.GetTimesheetsByFilter(builder); if (items == null || items.Length == 0) return null; return items[0]; }
public NoticesIndexer(INoticeLogger logger) { _logger = logger ?? new NoticeLogger(); if (_client == null) { CreateClients(null); } GetFilter = new FilterBuilder<EpiFindNotice>(_client); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Number", DisplayID); builder.Simple("Reference", Reference); builder.Comparison("Estimate", Estimate); builder.Relation("Owner", Owners); builder.Relation("RegressionPlan", RegressionPlan); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Relation("Author", Author); builder.Comparison("AuthoredAt", AuthoredAt); builder.Relation("Conversation", Conversation); builder.MultiRelation("ExpressionsInConversation", ExpressionsInConversation); builder.Relation("InReplyTo", InReplyTo); builder.MultiRelation("Replies", Replies); builder.MultiRelation("Mentions", Mentions); }
public void BooleanTests() { var a = new FilterBuilder<TestObject>() .Where(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)) .And(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)) .Or(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)); var b = new FilterBuilder<TestObject>() .Where(to => to.BooleanProperty, BooleanFilterType.Equals, true) .And(to => to.BooleanProperty, BooleanFilterType.Equals, true) .Or(to => to.BooleanProperty, BooleanFilterType.Equals, true); var c = new FilterBuilder<TestObject>() .Where("BooleanProperty", BooleanFilterType.Equals, true) .And("BooleanProperty", BooleanFilterType.Equals, true) .Or("BooleanProperty", BooleanFilterType.Equals, true); var d = new FilterBuilder<TestObject>() .Where(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)) .And(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)) .Or(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)); var e = new FilterBuilder<TestObject>() .Where(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null) .And(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null) .Or(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null); var f = new FilterBuilder<TestObject>() .Where("NullableBooleanProperty", BooleanFilterType.Equals, null) .And("NullableBooleanProperty", BooleanFilterType.Equals, null) .Or("NullableBooleanProperty", BooleanFilterType.Equals, null); var g = new FilterBuilder<TestObject>() .Where(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)) .Or(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)) .And(new BooleanCriterion<TestObject>(to => to.BooleanProperty, BooleanFilterType.Equals, true)); var h = new FilterBuilder<TestObject>() .Where(to => to.BooleanProperty, BooleanFilterType.Equals, true) .Or(to => to.BooleanProperty, BooleanFilterType.Equals, true) .And(to => to.BooleanProperty, BooleanFilterType.Equals, true); var i = new FilterBuilder<TestObject>() .Where("BooleanProperty", BooleanFilterType.Equals, true) .Or("BooleanProperty", BooleanFilterType.Equals, true) .And("BooleanProperty", BooleanFilterType.Equals, true); var j = new FilterBuilder<TestObject>() .Where(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)) .Or(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)) .And(new NullableBooleanCriterion<TestObject>(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null)); var k = new FilterBuilder<TestObject>() .Where(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null) .Or(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null) .And(to => to.NullableBooleanProperty, BooleanFilterType.Equals, null); var l = new FilterBuilder<TestObject>() .Where("NullableBooleanProperty", BooleanFilterType.Equals, null) .Or("NullableBooleanProperty", BooleanFilterType.Equals, null) .And("NullableBooleanProperty", BooleanFilterType.Equals, null); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Reference", References); builder.Relation("BuildProject", BuildProjects); builder.Relation("ChangeSets", ChangeSets); builder.ListRelation<BuildSource>("Source", Source); builder.ListRelation<BuildStatus>("Status", Status); }
internal override void InternalModifyFilter(FilterBuilder builder) { base.InternalModifyFilter(builder); builder.Simple("Name", Name); builder.Simple("Description", Description); builder.Relation("Asset", Asset); builder.ListRelation<AttachmentType>("Category", Type); }
/// <summary> /// Adds a filter for the given <paramref name = "extension" />. By default, the first filter will be the default in the dialog /// </summary> /// <param name = "extension">the file extension</param> /// <param name = "isDefault">sets this filter as the default filter in the dialog</param> /// <example> /// AddFilter("xml") /// </example> /// <returns></returns> public FilterBuilder AddFilter(string extension, bool isDefault = false) { var filterBuilder = new FilterBuilder(this, extension); if (isDefault) _filters.Insert(0, filterBuilder); else _filters.Add(filterBuilder); if (String.IsNullOrEmpty(DefaultExtension) || isDefault) DefaultExtension = extension; return filterBuilder; }
public static SimpleFilterBuilder <TFilterable> Where <TFilterable>(this FilterBuilder <TFilterable> filterBuilderBase, Expression <Func <TFilterable, DateTimeOffset> > propertyNameExpression, DateTimeFilterType filterType, DateTimeOffset filterValue) where TFilterable : class, IFilterable { return(filterBuilderBase.Where(new DateTimeOffsetCriterion <TFilterable>(propertyNameExpression, filterType, filterValue))); }
public override FilterDefinition <SimpleTestDocument> GetFilter() { return(FilterBuilder.Gte(d => d.IntField, 2)); }
static void Main(string[] args) { var filterBuilder = new FilterBuilder(); var runCleaner = true; var simulateCleaning = false; var currentOperation = ArgsOperation.None; foreach (var arg in args) { switch (arg.ToLower()) { case "-help": Console.WriteLine("\n------------------------ Commands ------------------------\n\n" + "Command: closeall -except <app1> <app2> <app3> : Indicated processes won't get killed\n" + " ex: closeall -except opera : All the processes will get killed, except Opera\n" + " ex: closeall -except discord devenv : All the processes will get killed, except Discord and Visual Studio\n" + "\nCommand: closeall -ignore-startup : Startup processes won't get killed\n" + "\nCommand: closeall -nofocus : Focused window won't get killed\n" + "\n\nAbbreviations:" + "\n -except: -e" + "\n -ignore-startup: -i-s" + "\n -nofocus: -nf" + "\n----------------------------------------------------------"); runCleaner = false; break; case "-list": case "-ls": ListRunningProcesses(); runCleaner = false; break; case "-simulate": case "-sim": simulateCleaning = true; break; case "-except": case "-e": currentOperation = ArgsOperation.Except; break; // Not Supported yet case "-whitelist": case "-wl": currentOperation = ArgsOperation.WhitelistAppend; break; // Not Supported yet case "-removefromwhitelist": case "-rfwl": currentOperation = ArgsOperation.WhitelistRemove; break; default: if (currentOperation == ArgsOperation.None) { Console.WriteLine($"Invalid argument: {arg}"); runCleaner = false; } if (currentOperation == ArgsOperation.Except) { filterBuilder.Except(arg); } break; } } if (!runCleaner) { return; } var processManager = new ProcessManager(); var filter = filterBuilder.IgnoreStartup(processManager) .EnableWhiteList(new WhiteListManager(new FileManager())) .Build(); new ProcessCleaner(filter, processManager) .Start(simulateCleaning); }
public override FilterDefinition <SimpleTestDocument> GetFilter() { var values = new[] { 0, 1, 2 }; return(FilterBuilder.Where(d => !values.Contains(d.IntField))); }
public PagedResults <CustomUser> ListCustomUsersExtended(string searchType, string criteria, Uri nextPage = null) { string encodedfilter = null; string stringFilter = criteria.ToString(); encodedfilter = HttpUtility.UrlPathEncode(stringFilter); FilterBuilder filterBuilder = new FilterBuilder(encodedfilter); PagedResults <User> oktaUserList = null; List <CustomUser> customUserList = new List <CustomUser>(); CustomUser customUser = null; try { if (searchType == "query") { oktaUserList = _usersClient.GetList(nextPage, query: criteria, pageSize: 200); } else if (searchType == "search") { oktaUserList = _usersClient.GetList(nextPage: nextPage, filter: filterBuilder, searchType: SearchType.ElasticSearch, pageSize: 200); } else if (searchType == "filter") { oktaUserList = _usersClient.GetList(nextPage: nextPage, filter: filterBuilder, searchType: SearchType.Filter, pageSize: 200); } foreach (var user in oktaUserList.Results) { customUser = new CustomUser(user); List <string> customAttributes = user.Profile.GetUnmappedPropertyNames(); foreach (var item in customAttributes) { PropertyInfo tempProp = customUser.Profile.GetType().GetProperty(item); if (tempProp != null) { object myValue = user.Profile.GetProperty(item); if (tempProp.CanWrite) { tempProp.SetValue(customUser.Profile, myValue, null); } } else { _logger.Debug("unmapped okta attribute " + item + " is not defined as an extention"); } } customUserList.Add(customUser); } } catch (Exception ex) { _logger.Error(string.Format("Error searching for Okta user in Okta. Okta username: {0}.", criteria), ex); } PagedResults <CustomUser> pagedCustomUserList = new PagedResults <CustomUser>(customUserList); if (!pagedCustomUserList.IsLastPage) { pagedCustomUserList.NextPage = oktaUserList.NextPage; pagedCustomUserList.PrevPage = oktaUserList.PrevPage; } //pagedCustomUserList.RequestUri = oktaUserList.RequestUri; return(pagedCustomUserList); }
public void Process(Complex *buffer, int length) { if (!_scanning) { return; } if (_control.Frequency == _checkedFrequency) { return; } if (_workingBuffer == null || _workingBuffer.Length < length) { _workingBuffer = new Complex[length]; } for (var n = 0; n < length; n++) { _workingBuffer[n] = buffer[n]; } if (_window == null || _window.Length < length) _window = FilterBuilder.MakeWindow(WindowType.Hamming, length); fixed(Complex *workingPtr = &_workingBuffer[0]) { fixed(float *winPtr = &_window[0]) Fourier.ApplyFFTWindow(workingPtr, winPtr, length); Fourier.ForwardTransform(workingPtr, length); if (_spectrum == null || _spectrum.Length < length) _spectrum = new float[length]; fixed(float *spectrumPtr = &_spectrum[0]) Fourier.SpectrumPower(workingPtr, spectrumPtr, length); } float avg = 0.0f; for (var n = 0; n < length; n++) { avg += _spectrum[n]; } avg /= length; _drawing.AddDataPoint(_control.Frequency, avg); if (_control.Frequency > _gui.EndFreq * 1000000 - _gui.Step * 1000) { StopScanning(); } else { if (_control.IsPlaying) { _checkedFrequency = _control.Frequency; _control.SetFrequency(_control.Frequency + _gui.Step * 1000, false); } } }
#pragma warning disable 1998 public async Task FilterTests() #pragma warning restore 1998 { var data = TestSource.GetData(); // filter: entity => entity.ReferenceModel.Name.ToString().Contains("Model") && // (entity.Number == 1 || entity.Number == 2) && // (new [] {5,6,10}).Contains("Number") var filter = new FilterBuilder() .Not(f => f.In <int>("Number", new[] { 5, 6, 10 })) .Build(); var filter1 = new FilterBuilder() .Contains("Name", "6") .Not(f => f.In <int>("Number", new[] { 5, 6, 10 })) .Build(); var filter1_0 = new FilterBuilder() .Not(f => f .Not(d => d.Equal("Number", 3)) .Contains("Name", "l3")) .Build(); var filter2_0 = new FilterBuilder() .Contains("Name", "testModel") .Build(); var filter2_1 = new FilterBuilder() .Contains("Name", "testmodel") .Build(); var filter2_2 = new FilterBuilder() .Contains("Name", "Testmodel") .Build(); var filter2_3 = new FilterBuilder() .Contains("Name", "TESTMODEL") .Build(); var expression = filter.ToLambdaFilter <TestModel>(); var expression1 = filter1.ToLambdaFilter <TestModel>(); var expression1_0 = filter1_0.ToLambdaFilter <TestModel>(); var expression2_0 = filter2_0.ToLambdaFilter <TestModel>(); var expression2_1 = filter2_1.ToLambdaFilter <TestModel>(); var expression2_2 = filter2_2.ToLambdaFilter <TestModel>(); var expression2_3 = filter2_3.ToLambdaFilter <TestModel>(); var filtered = data.Where(expression).ToList(); var filtered1 = data.Where(expression1).ToList(); var filtered1_0 = data.Where(expression1_0).ToList(); var filtered2_0 = data.Where(expression2_0).ToList(); var filtered2_1 = data.Where(expression2_1).ToList(); var filtered2_2 = data.Where(expression2_2).ToList(); var filtered2_3 = data.Where(expression2_3).ToList(); Assert.True(filtered2_0.Count == 500); Assert.True(filtered2_1.Count == 500); Assert.True(filtered2_2.Count == 500); Assert.True(filtered2_3.Count == 500); Assert.True(filtered.Count == 498); Assert.False(filtered1.All(e => e.Number == 5 || e.Number == 6 || e.Number == 10)); Assert.True(filtered1_0.Count == 0); var filterEqualToDate = new FilterBuilder() .EqualToDate("Date", new DateTime(2019, 1, 24, 15, 15, 15)) .Build(); var expressionEqualToDate = filterEqualToDate.ToLambdaFilter <TestModel>(); var filteredEqualToDate = data.Where(expressionEqualToDate).ToList(); Assert.Equal(100, filteredEqualToDate.Count); var filterEqualToDateNull = new FilterBuilder() .EqualToDate("Date", new DateTime()) .Build(); var expressionEqualToDateNull = filterEqualToDateNull.ToLambdaFilter <TestModel>(); var filteredEqualToDateNull = data.Where(expressionEqualToDateNull).ToList(); Assert.Single(filteredEqualToDateNull); //500 }
public void TestPagedSearch() { ConnectorPoolManager.Dispose(); ConnectorInfoManager manager = GetConnectorInfoManager(); ConnectorInfo info1 = FindConnectorInfo(manager, "1.0.0.0", "org.identityconnectors.testconnector.TstStatefulPoolableConnector"); Assert.IsNotNull(info1); APIConfiguration config = info1.CreateDefaultAPIConfiguration(); config.ProducerBufferSize = 0; config.ConnectorPoolConfiguration.MinIdle = 1; config.ConnectorPoolConfiguration.MaxIdle = 2; ConnectorFacade facade1 = ConnectorFacadeFactory.GetInstance().NewInstance(config); OperationOptionsBuilder builder = new OperationOptionsBuilder(); builder.PageSize = 10; builder.SetSortKeys(new ICF.SortKey(Name.NAME, true)); SearchResult searchResult = null; ISet <Uid> UIDs = new HashSet <Uid>(); int iteration = 0; do { if (null != searchResult) { builder.PagedResultsCookie = searchResult.PagedResultsCookie; } int size = 0; searchResult = facade1.Search(ObjectClass.ACCOUNT, null, new ResultsHandler() { Handle = obj => { if (size >= 10) { Assert.Fail("More then 10 objects was handled!"); } size++; if (UIDs.Contains(obj.Uid)) { Assert.Fail("Duplicate Entry in results"); } return(UIDs.Add(obj.Uid)); } }, builder.Build()); iteration++; Assert.IsNotNull(searchResult); Assert.AreEqual(searchResult.RemainingPagedResults, 100 - (iteration * 10)); } while (searchResult.PagedResultsCookie != null); // Search with paged results offset builder = new OperationOptionsBuilder(); builder.PageSize = 10; builder.PagedResultsOffset = 5; builder.SetSortKeys(new ICF.SortKey(Name.NAME, true)); searchResult = null; UIDs.Clear(); Filter filter = FilterBuilder.EqualTo(ConnectorAttributeBuilder.BuildEnabled(true)); iteration = 0; do { if (null != searchResult) { builder.PagedResultsCookie = searchResult.PagedResultsCookie; } int size = 0; searchResult = facade1.Search(ObjectClass.ACCOUNT, filter, new ResultsHandler() { Handle = obj => { if (size >= 10) { Assert.Fail("More then 10 objects was handled!"); } size++; if (UIDs.Contains(obj.Uid)) { Assert.Fail("Duplicate Entry in results"); } return(UIDs.Add(obj.Uid)); } }, builder.Build()); iteration++; Assert.IsNotNull(searchResult); Assert.AreEqual(searchResult.RemainingPagedResults, Math.Max(50 - (iteration * 15), 0)); } while (searchResult.PagedResultsCookie != null); }
/// <summary> /// Delete by query /// </summary> /// <param name="filters"></param> /// <returns></returns> public async Task <bool> DeleteByQueryAsync(FilterDefinition <TDocument> filters) { filters = filters ?? FilterBuilder.GetFilterBuilder <TDocument>().Empty; return((await this.Collection.DeleteManyAsync(filters)).IsAcknowledged); }
public async Task <TicketFilter> ToFilter(TicketFilter filter) { if (filter.OrFilter == null) { filter.OrFilter = new List <TicketFilter>(); } if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0) { return(filter); } List <Organization> Organizations = await OrganizationService.List(new OrganizationFilter { Skip = 0, Take = int.MaxValue, Selects = OrganizationSelect.ALL, OrderBy = OrganizationOrder.Id, OrderType = OrderType.ASC }); foreach (var currentFilter in CurrentContext.Filters) { TicketFilter subFilter = new TicketFilter(); filter.OrFilter.Add(subFilter); List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value; foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions) { if (FilterPermissionDefinition.Name == nameof(subFilter.AppUserId)) { subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.OrganizationId)) { var organizationIds = FilterOrganization(Organizations, FilterPermissionDefinition.IdFilter); IdFilter IdFilter = new IdFilter { In = organizationIds }; subFilter.OrganizationId = FilterBuilder.Merge(subFilter.OrganizationId, IdFilter); } if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null) { if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id) { if (subFilter.UserId == null) { subFilter.UserId = new IdFilter { } } ; subFilter.UserId.Equal = CurrentContext.UserId; } if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id) { if (subFilter.UserId == null) { subFilter.UserId = new IdFilter { } } ; subFilter.UserId.NotEqual = CurrentContext.UserId; } } if (FilterPermissionDefinition.Name == nameof(subFilter.TicketTypeId)) { subFilter.TicketTypeId = FilterBuilder.Merge(subFilter.TicketTypeId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.DepartmentId)) { subFilter.DepartmentId = FilterBuilder.Merge(subFilter.DepartmentId, FilterPermissionDefinition.IdFilter); } } } return(filter); }
private static FilterBuilder AllBlockFilter() => FilterBuilder.New().FromEarliestBlock().ToPendingBlock();
public void Test_InvalidFilter() { var simpleFilterDefinition1 = new SimpleFilterDefinition("LastName", "Jack", ComparesionOperator.Equals); var expFilter = FilterBuilder.CreateFilterExpression <Person>(simpleFilterDefinition1); var filterdData = SampleData.PersonList.Where(expFilter.Compile()).ToList(); }
public override FilterDefinition <SimpleTestDocument> GetFilter() { return(FilterBuilder.Where(d => !(d.IntField == 3))); }
public void ContainsDateRange_Will_Return_False_If_Date_Range_Doesnt_Exist() { var builder = new FilterBuilder(); Assert.IsFalse(builder.ContainsDateRange); }
#pragma warning disable 1998 public async Task FilterAnyTest() #pragma warning restore 1998 { var items = new List <TestModel> { new TestModel { Date = DateTime.Now, Id = "1", NestedModels = new List <NestedModel>(), Number = 1 }, new TestModel() { Date = DateTime.Now, Id = "2", NestedModels = null, Number = 2 }, new TestModel() { Date = DateTime.Now, Id = "3", NestedModels = new List <NestedModel> { new NestedModel { NestedId = 1, NestedName = "Name1" }, new NestedModel { NestedId = 2, NestedName = "Name2" } }, Number = 3 }, new TestModel() { Date = DateTime.Now, Id = "4", NestedModels = new List <NestedModel> { new NestedModel { NestedId = 2, NestedName = "Name3" } }, Number = 4 } }.AsQueryable(); // case 1: test any without predicate { // 1.1: positive test var filterPositive = new FilterBuilder() .NotNull("NestedModels") .Any("NestedModels") .Build() .ToLambdaFilter <TestModel>(); var resultPositive = items.Where(filterPositive).ToList(); resultPositive.ShouldDeepEqual(new List <TestModel> { items.ElementAt(2), items.ElementAt(3) }); // 1.2: negative test var filterNegative = new FilterBuilder(LogicalOperators.Or) .Null("NestedModels") .Not(b => b.Any("NestedModels")) .Build() .ToLambdaFilter <TestModel>(); var resultNegative = items.Where(filterNegative).ToList(); resultNegative.ShouldDeepEqual(new List <TestModel> { items.ElementAt(0), items.ElementAt(1) }); } // case 2: test any with predicate { // 2.1: positive test var filterPositive = new FilterBuilder() .NotNull("NestedModels") .Any("NestedModels", anyB => anyB.In("NestedName", new[] { "Name2", "Name3" }) ) .Build() .ToLambdaFilter <TestModel>(); var resultPositive = items.Where(filterPositive).ToList(); resultPositive.ShouldDeepEqual(new List <TestModel> { items.ElementAt(2), items.ElementAt(3) }); // 2.2: negative test (using all) var filterNegative = new FilterBuilder( LogicalOperators.Or ) .Null("NestedModels") .AllNot("NestedModels", allNot => allNot.In("NestedName", new[] { "Name2", "Name3" }) ) .Build() .ToLambdaFilter <TestModel>(); var resultNegative = items.Where(filterNegative).ToList(); resultNegative.ShouldDeepEqual(new List <TestModel> { items.ElementAt(0), items.ElementAt(1) }); } }
public LambdaExpression Calculate() => FilterBuilder.AllPredicate(Data, InnerOperand.Calculate());
public void Test_InvalidFilter_Null() { var expFilter = FilterBuilder.CreateFilterExpression <Person>(null); Assert.IsNull(expFilter); }
public void TestBasics() { ConnectorAttribute attribute = ConnectorAttributeBuilder.Build("att-name", "att-value"); ConnectorAttribute attribute2 = ConnectorAttributeBuilder.Build("att-name2", "att-value2"); AllFiltersTranslator translator = new AllFiltersTranslator(); { Filter filter = FilterBuilder.Contains(attribute); String expected = "( CONTAINS att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.EndsWith(attribute); String expected = "( ENDS-WITH att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.EqualTo(attribute); String expected = "( = att-name [att-value] )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.GreaterThan(attribute); String expected = "( > att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.GreaterThanOrEqualTo(attribute); String expected = "( >= att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.LessThan(attribute); String expected = "( < att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.LessThanOrEqualTo(attribute); String expected = "( <= att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.StartsWith(attribute); String expected = "( STARTS-WITH att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } { Filter filter = FilterBuilder.ContainsAllValues(attribute); String expected = "( CONTAINS-ALL-VALUES " + attribute + " )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expected = "( ! " + expected + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } //and { Filter left = FilterBuilder.Contains(attribute); Filter right = FilterBuilder.Contains(attribute2); String expectedLeft = "( CONTAINS att-name att-value )"; String expectedRight = "( CONTAINS att-name2 att-value2 )"; Filter filter = FilterBuilder.And(left, right); String expected = "( & " + expectedLeft + " " + expectedRight + " )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expectedLeft = "( ! " + expectedLeft + " )"; expectedRight = "( ! " + expectedRight + " )"; expected = "( | " + expectedLeft + " " + expectedRight + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } //or { Filter left = FilterBuilder.Contains(attribute); Filter right = FilterBuilder.Contains(attribute2); String expectedLeft = "( CONTAINS att-name att-value )"; String expectedRight = "( CONTAINS att-name2 att-value2 )"; Filter filter = FilterBuilder.Or(left, right); String expected = "( | " + expectedLeft + " " + expectedRight + " )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); filter = FilterBuilder.Not(filter); expectedLeft = "( ! " + expectedLeft + " )"; expectedRight = "( ! " + expectedRight + " )"; expected = "( & " + expectedLeft + " " + expectedRight + " )"; actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } //double-negative { Filter filter = FilterBuilder.Contains(attribute); filter = FilterBuilder.Not(filter); filter = FilterBuilder.Not(filter); String expected = "( CONTAINS att-name att-value )"; String actual = TranslateSingle(translator, filter); Assert.AreEqual(expected, actual); } }
public async Task <IList <TUser> > GetUsersInRoleAsync(string roleName, CancellationToken cancellationToken) { var filter = FilterBuilder <TUser> .Equal(x => x.Roles, roleName); return((await _dbContext.User.FindAsync(filter)).ToList()); }
public IEnumerable <CardScore> Search(SearchViewModel model) { var filters = new List <SearchFilter>(); var results = new Dictionary <string, CardScore>(); if (model.HasQuery() && !string.IsNullOrEmpty(model.BasicQuery())) { var queryFilters = new List <SearchFilter>(); queryFilters.Add(new SearchFilter((s, c) => { return(c.Title.IsEqualToLower(s.BasicQuery())); }, 100, "Title matches with '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.NormalizedTitle.IsEqualToLower(s.BasicQuery())); }, 100, "Title matches with '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Title.StartsWithLower(s.BasicQuery())); }, 90, "Title starts with '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.NormalizedTitle.StartsWithLower(s.BasicQuery())); }, 90, "Title starts with '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Title.ContainsLower(s.BasicQuery())); }, 70, "Title includes '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.NormalizedTitle.ContainsLower(s.BasicQuery())); }, 70, "Title includes '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Text.ContainsLower(s.BasicQuery())); }, 50, "Card Text includes '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.OppositeText.ContainsLower(s.BasicQuery())); }, 45, "Card Text includes '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Shadow.ContainsLower(s.BasicQuery())); }, 45, "Shadow Text includes '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Traits.Any(t => t.ToLowerSafe().Equals(s.BasicQuery() + "."))); }, 30, "Trait matches '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.NormalizedTraits.Any(t => t.ToLowerSafe().Equals(s.BasicQuery() + "."))); }, 30, "Trait matches '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Traits.Any(t => t.ToLowerSafe().Contains(s.BasicQuery()))); }, 25, "Trait contains '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.NormalizedTraits.Any(t => t.ToLowerSafe().Contains(s.BasicQuery()))); }, 25, "Trait contains '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Keywords.Any(k => k.ToLowerSafe().Equals(s.BasicQuery()))); }, 15, "Keyword matches '" + model.Query + "'")); queryFilters.Add(new SearchFilter((s, c) => { return(c.Keywords.Any(k => k.ToLowerSafe().Contains(s.BasicQuery()))); }, 15, "Keyword contains '" + model.Query + "'")); filters.Add(new SearchFilter(queryFilters)); } if (model.HasCardType()) { filters.Add(new SearchFilter((s, c) => { return(s.CardTypeMatches(c)); }, 100, "Card Type matches '" + model.CardType.ToEnumDisplayString() + "'")); } if (model.HasCardSubtype()) { filters.Add(new SearchFilter((s, c) => { return(s.CardSubtype == c.CardSubtype); }, 100, "Card Subtype matches '" + model.CardSubtype.ToEnumDisplayString() + "'")); } if (model.HasDeckType()) { filters.Add(new SearchFilter((s, c) => { return(s.DeckType == c.GetDeckType()); }, 100, "Deck Type matches '" + model.DeckType.ToEnumDisplayString() + "'")); } if (model.HasCardSet()) { filters.Add(new SearchFilter((s, c) => { return(s.CardSetMatches(c) || (!string.IsNullOrEmpty(c.CardSet.Cycle) && s.CardSet.ToUpper() == c.CardSet.Cycle.ToUpper())); }, 100, "Card Set matches '" + model.CardSet + "'")); } if (model.HasScenario()) { filters.Add(new SearchFilter((s, c) => { return(scenarioService.BelongsToScenario(c.Slug, c.CardType, s.Scenario)); }, 100, "Scenario matches '" + model.Scenario + "'")); } if (model.HasTrait()) { filters.Add(new SearchFilter((s, c) => { return(c.HasTrait(s.Trait)); }, 100, "Has Trait '" + model.Trait + "'")); } if (model.HasKeyword()) { filters.Add(new SearchFilter((s, c) => { return(c.HasKeyword(s.Keyword)); }, 100, "Has Keyword '" + model.Trait + "'")); } if (model.HasSphere()) { filters.Add(new SearchFilter((s, c) => { return(s.Sphere == c.Sphere); }, 100, "Has Sphere '" + model.Sphere.ToEnumDisplayString() + "'")); } if (model.HasCategory()) { filters.Add(new SearchFilter((s, c) => { return(c.Categories.Any(x => x == s.GetCategory())); }, 100, "Has Category '" + model.Category + "'")); } if (model.HasEncounterCategory()) { filters.Add(new SearchFilter((s, c) => { return(c.EncounterCategories.Any(x => x == s.GetEncounterCategory())); }, 100, "Has Encounter Category '" + model.EncounterCategory + "'")); } if (model.HasQuestCategory()) { filters.Add(new SearchFilter((s, c) => { return(c.QuestCategories.Any(x => x == s.GetQuestCategory())); }, 100, "Has Quest Category '" + model.QuestCategory + "'")); } if (model.HasResourceCost()) { if (model.Cost == "-") { filters.Add(new SearchFilter((s, c) => { return(c.ResourceCost.HasValue && c.ResourceCost.Value == byte.MaxValue); }, 100, "Cost is '-'")); } else if (model.Cost != "X") { filters.Add(new SearchFilter((s, c) => { return(c.ResourceCost.CompareTo(s.CostOperator, s.Cost)); }, 100, "Cost " + model.CostOperator.ToEnumDisplayString() + " '" + model.Cost + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(s.Cost == c.ResourceCostLabel); }, 100, "Cost is 'X'")); } } if (model.Attack.IsDefinedFilter()) { if (model.Attack == "-") { filters.Add(new SearchFilter((s, c) => { return(c.Attack.HasValue && c.Attack.Value == byte.MaxValue); }, 100, "Attack is '-'")); } else if (model.Attack != "X") { filters.Add(new SearchFilter((s, c) => { return(c.Attack.HasValue && c.Attack.Value != byte.MaxValue && c.Attack.CompareTo(s.AttackOp, s.Attack)); }, 100, "Attack " + model.AttackOp.ToEnumDisplayString() + " '" + model.Attack + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.Attack.HasValue && c.Attack.Value != byte.MaxValue && c.IsVariableAttack); }, 100, "Attack is 'X'")); } } if (model.Defense.IsDefinedFilter()) { if (model.Defense == "-") { filters.Add(new SearchFilter((s, c) => { return(c.Defense.HasValue && c.Defense.Value == byte.MaxValue); }, 100, "Defense is '-'")); } else if (model.Defense != "X") { filters.Add(new SearchFilter((s, c) => { return(c.Defense.HasValue && c.Defense.Value != byte.MaxValue && c.Defense.CompareTo(s.DefenseOp, s.Defense)); }, 100, "Defense " + model.DefenseOp.ToEnumDisplayString() + " '" + model.Defense + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.Defense.HasValue && c.Defense.Value != byte.MaxValue && c.IsVariableDefense); }, 100, "Defense is 'X'")); } } if (model.HitPoints.IsDefinedFilter()) { if (model.HitPoints == "-") { filters.Add(new SearchFilter((s, c) => { return(c.HitPoints.HasValue && c.HitPoints.Value == byte.MaxValue); }, 100, "Hit Points are '-'")); } else if (model.HitPoints != "X") { filters.Add(new SearchFilter((s, c) => { return(c.HitPoints.HasValue && c.HitPoints.Value != byte.MaxValue && c.HitPoints.CompareTo(s.HitPointsOp, s.HitPoints)); }, 100, "Hit Points " + model.HitPointsOp.ToEnumDisplayString() + " '" + model.HitPoints + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.HitPoints.HasValue && c.HitPoints.Value != byte.MaxValue && c.IsVariableHitPoints); }, 100, "Hit Points are 'X'")); } } if (model.Willpower.IsDefinedFilter()) { if (model.Willpower == "-") { filters.Add(new SearchFilter((s, c) => { return(c.Willpower.HasValue && c.Willpower.Value == byte.MaxValue); }, 100, "Willpower is '-'")); } else if (model.Willpower != "X") { filters.Add(new SearchFilter((s, c) => { return(c.Willpower.HasValue && c.Willpower.Value != byte.MaxValue && !c.IsVariableWillpower && c.Willpower.CompareTo(s.WillpowerOp, s.Willpower)); }, 100, "Willpower " + model.WillpowerOp.ToEnumDisplayString() + " '" + model.Willpower + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.Willpower.HasValue && c.Willpower.Value != byte.MaxValue && c.IsVariableWillpower); }, 100, "Willpower is 'X'")); } } if (model.Threat.IsDefinedFilter()) { if (model.Threat == "-") { filters.Add(new SearchFilter((s, c) => { return(c.Threat.HasValue && c.Threat.Value == byte.MaxValue); }, 100, "Threat is '-'")); } else if (model.Threat != "X") { filters.Add(new SearchFilter((s, c) => { return(c.Threat.HasValue && c.Threat.Value != byte.MaxValue && !c.IsVariableThreat && c.Threat.CompareTo(s.ThreatOp, s.Threat)); }, 100, "Threat " + model.ThreatOp.ToEnumDisplayString() + " '" + model.Threat + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.Threat.HasValue && c.Threat.Value != byte.MaxValue && c.IsVariableThreat); }, 100, "Threat is 'X'")); } } if (model.QuestPoints.IsDefinedFilter()) { if (model.QuestPoints == "-") { filters.Add(new SearchFilter((s, c) => { return(c.QuestPoints.HasValue && c.QuestPoints.Value == byte.MaxValue); }, 100, "Quest Points are '-'")); } else if (model.QuestPoints != "X") { filters.Add(new SearchFilter((s, c) => { return(c.QuestPoints.HasValue && c.QuestPoints.Value != byte.MaxValue && !c.IsVariableQuestPoints && c.QuestPoints.CompareTo(s.QuestPointsOp, s.QuestPoints)); }, 100, "Quest Points " + model.QuestPointsOp.ToEnumDisplayString() + " '" + model.QuestPoints + "'")); } else { filters.Add(new SearchFilter((s, c) => { return(c.QuestPoints.HasValue && c.QuestPoints.Value != byte.MaxValue && c.IsVariableQuestPoints); }, 100, "Quest Points are 'X'")); } } if (model.Popularity.IsDefinedFilter()) { filters.Add(new SearchFilter((s, c) => { var pop = c.Popularity(getPopularity); return(pop > 0 && pop.CompareTo(s.PopularityOp, s.Popularity)); }, 100, "Popularity " + model.PopularityOp.ToEnumDisplayString() + " '" + model.Popularity + "'")); } if (model.Errata.HasValue && model.Errata.Value != ErrataVersion.Any) { Func <string, double, bool> hasErrata = (slug, version) => { return(noteService.HasErrata(slug, version)); }; var errataFilter = FilterBuilder.ErrataFilter(model.Errata.Value, hasErrata); if (errataFilter != null) { filters.Add(errataFilter); } } if (model.HasThreatCost()) { filters.Add(new SearchFilter((s, c) => { return(c.ThreatCost.CompareTo(s.ThreatCostOperator, s.ThreatCost)); }, 100, "Threat Cost" + model.ThreatCostOperator.ToEnumDisplayString() + " '" + model.ThreatCost + "'")); } if (model.HasEngagementCost()) { filters.Add(new SearchFilter((s, c) => { return(c.EngagementCost.CompareTo(s.EngagementCostOperator, s.EngagementCost)); }, 100, "Engagement Cost" + model.EngagementCostOperator.ToEnumDisplayString() + " '" + model.EngagementCost + "'")); } if (model.HasArtist()) { filters.Add(new SearchFilter((s, c) => { return(s.Artist == c.Artist.Name); }, 100, "Has Artist '" + model.Artist + "'")); } if (model.HasEncounterSet()) { filters.Add(new SearchFilter((s, c) => { return(s.EncounterSet == c.EncounterSet || s.EncounterSet == c.AlternateEncounterSet); }, 100, "Has Encounter Set '" + model.EncounterSet + "'")); } if (model.HasVictoryPoints()) { filters.Add(new SearchFilter((s, c) => { return(s.VictoryPointsMatch(c)); }, 100, "Has Victory Points '" + model.VictoryPoints + "'")); } if (model.HasShadow.HasValue && model.HasShadow.Value != HasShadow.Any) { filters.Add(new SearchFilter((s, c) => { return(s.HasShadow == HasShadow.Yes && !string.IsNullOrEmpty(c.Shadow) || s.HasShadow == HasShadow.No && string.IsNullOrEmpty(c.Shadow)); }, 50, model.HasShadow == HasShadow.Yes ? "Has Shadow Effect" : "Does Not Have Shadow Effect")); } if (model.IsUnique.HasValue && model.IsUnique.Value != Uniqueness.Any) { filters.Add(new SearchFilter((s, c) => { return((s.IsUnique == Uniqueness.Yes && c.IsUnique) || (s.IsUnique == Uniqueness.No && !c.IsUnique)); }, 50, model.IsUnique == Uniqueness.Yes ? "Is Unique" : "Is Not Unique")); } if (model.HasQuest()) { var scenario = scenarioService.GetScenario(model.Quest.ToUrlSafeString()); filters.Add(new SearchFilter((s, c) => { return(!string.IsNullOrEmpty(c.EncounterSet) && scenario.QuestCards.Any(x => (x.Quest != null && x.Quest.EncounterSet != null && x.Quest.EncounterSet == c.EncounterSet) || (x.IncludedEncounterSets != null && x.IncludedEncounterSets.Any(y => y != null && y.Name == c.EncounterSet)))); }, 50, "Has Quest '" + model.Quest + "'")); } var officialSetFilter = false; if (model.SetType.HasValue) { if (model.SetType.Value != SetType.None) { if (model.SetType.Value == SetType.Non_Nightmare) { filters.Add(new SearchFilter((s, c) => { return(c.CardSet.SetType != SetType.Nightmare_Expansion); }, 50f, 0f, "Is Not From A Nightmare Set")); } else if (model.SetType.Value != SetType.ALL_SETS) { filters.Add(new SearchFilter((s, c) => { return((s.SetType == SetType.OFFICIAL && c.CardSet.SetType != SetType.CUSTOM) || (s.SetType.Value == c.CardSet.SetType)); }, 50f, 0f, "Has Set Type '" + model.SetType + "'")); } } else { officialSetFilter = true; } } else { officialSetFilter = true; } var productFilter = FilterBuilder.ProductFilter(model); if (productFilter != null) { filters.Add(productFilter); } if (filters.Count == 0 && !model.IsAdvancedSearch()) { filters.Add(new SearchFilter((s, c) => { return(c.CardType == CardType.Hero && c.CardSet.Name == "Core Set"); }, 100f, "Default Search - Core Set Heroes")); } if (filters.Count > 0) { if (officialSetFilter) { filters.Add(new SearchFilter((s, c) => { return(c.CardSet.SetType != SetType.CUSTOM); }, 100f, 0f, "From an Official release")); } foreach (var card in cards) { foreach (var filter in filters) { var score = filter.Score(model, card); if (results.ContainsKey(card.Slug)) { results[card.Slug].AddDescription(filter.Description(model, card)); results[card.Slug].AddScore(score); /* * var existing = results[card.Slug].Score; * if (score == 0 || existing > 0 && score > existing) * { * results[card.Slug].Score = score; * }*/ } else { results[card.Slug] = new CardScore(card, score, filter.Description(model, card)); } } } } else { foreach (var card in cards) { results[card.Slug] = new CardScore(card, SearchFilter.WeightedScore(card, 1), string.Empty); } } /* * if (!model.IsAdvancedSearch() && isOfficialOnly) * { * //var setNames = cards.Select(x => x.CardSet.Name).Distinct().OrderBy(y => y).ToList(); * //var sn = setNames; * * //If this is not an advanced search and there are no filters then return only the heroes from the Core Set * foreach (var item in cards.Where(x => x.CardSet.Name == "Core Set" && x.Number < 13)) * { * results[item.Slug] = new CardScore(item, 13 - item.Number, string.Empty); * } * }*/ /* * if (!model.Custom && model.SetType != SetType.CUSTOM) * { * var official = new Dictionary<string, CardScore>(); * * foreach (var score in results) * { * if (!model.CardIsCustom(score.Value.Card)) * official.Add(score.Key, score.Value); * } * * results = official; * }*/ if (model.IsRandom()) { var total = results.Values.Where(x => x.Score() > 0).Count(); if (total > 1) { var random = new Random(); var choice = random.Next(0, total - 1); var score = results.Values.Where(x => x.Score() > 0).ToList()[choice]; results = new Dictionary <string, CardScore>(); results[score.Card.Slug] = score; } return(results.Values.ToList()); } var sortedResults = sortService.Sort(model, filters, results); if (model.IsAdvancedSearch()) { sortedResults = advancedSearchService.Search(model, sortedResults); } return(sortedResults); }
public Func <TClass, bool> GetSqlSyntax(Filter <TClass> filter) { var builder = new FilterBuilder(new BuilderHelper()); return(builder.GetExpression <TClass>(filter).Compile()); }
public override FilterDefinition <SimpleTestDocument> GetFilter() { return(FilterBuilder.Where(d => d.IntField == 1 || d.StringField == "another value")); }
public Query(IEfGraphQLService <GraphQlEfSampleDbContext> efGraphQlService, Func <GraphQlEfSampleDbContext> dbContextFunc) : base(efGraphQlService) { AddQueryField( name: "companies", resolve: context => context.DbContext.Companies); #endregion AddSingleField( resolve: context => context.DbContext.Companies, name: "company"); AddSingleField( resolve: context => context.DbContext.Companies, name: "companyOrNull", nullable: true); AddQueryConnectionField( name: "companiesConnection", resolve: context => context.DbContext.Companies); AddQueryField( name: "employees", resolve: context => context.DbContext.Employees); AddQueryField( name: "employeesByArgument", resolve: context => { var content = context.GetArgument <string>("content"); return(context.DbContext.Employees.Where(x => x.Content == content)); }, arguments: new QueryArguments( new QueryArgument <StringGraphType> { Name = "content" })); AddQueryConnectionField( name: "employeesConnection", resolve: context => context.DbContext.Employees); #region ManuallyApplyWhere Field <ListGraphType <EmployeeSummaryGraph> >( name: "employeeSummary", arguments: new QueryArguments( new QueryArgument <ListGraphType <WhereExpressionGraph> > { Name = "where" } ), resolve: context => { IQueryable <Employee> query = dbContextFunc().Employees; if (context.HasArgument("where")) { var wheres = context.GetArgument <List <WhereExpression> >("where"); var predicate = FilterBuilder <Employee> .BuildPredicate(wheres); query = query.Where(predicate); } return(from q in query group q by new { q.CompanyId } into g select new EmployeeSummary { CompanyId = g.Key.CompanyId, AverageAge = g.Average(x => x.Age), }); }); #endregion }
public bool CalendarExists(string calendarName) { return (Collection.Find( FilterBuilder.Where(calendar => calendar.Id == new CalendarId(calendarName, InstanceName))).Any()); }
/// <summary> /// Gets a single page list /// </summary> /// <param name="nextPage">The next page.</param> /// <param name="pageSize">Size of the page.</param> /// <param name="filter">The filter.</param> /// <param name="query">A query parameter supported by a few clients.</param> /// <param name="after">The cursor for where to begin the page.</param> /// <param name="startDate">A start date parameter supported by a few clients.</param> /// <returns>A single page list</returns> /// <exception cref="OktaException">Unable to convert the response from + resourcePath + to an enumerable</exception> public virtual PagedResults <T> GetList( Uri nextPage = null, int pageSize = Constants.DefaultPageSize, FilterBuilder filter = null, string query = null, string after = null, DateTime?startDate = null) { // Ensure we have a non-empty query if (query == string.Empty) { query = null; } // Ensure we have a non-empty filter if (filter != null && filter.ToString() == string.Empty) { filter = null; } HttpResponseMessage result; if (nextPage != null) { result = BaseClient.Get(nextPage); } else { // Build the first request var path = new StringBuilder(); path.Append(resourcePath); // Add a pageSize on every request path.Append("?limit=" + pageSize); // Add the filter if it exists if (filter != null) { path.Append("&filter=" + filter); } // Add a query if it exists if (query != null) { path.Append("&q=" + query); } // Add a start date if it exists if (startDate != null) { path.Append("&startDate=" + startDate.Value.ToString(Constants.DateFormat)); } // Add an after value if it exists if (after != null) { path.Append("&after=" + after); } result = BaseClient.Get(path.ToString()); } OktaExceptionResolver.ParseHttpResponse(result); var list = Utils.Deserialize <IList <T> >(result); if (list == null) { throw new OktaException("Unable to convert the response from " + resourcePath + " to an enumerable"); } var results = new PagedResults <T>(list); results.RequestUri = result.RequestMessage.RequestUri; IEnumerable <string> linkHeaders; if (result.Headers.TryGetValues("Link", out linkHeaders)) { foreach (var header in linkHeaders) { // Split the header on semicolons var split = header.Split(';'); // Get and sanitize the url var url = split[0]; url = url.Trim('<', '>', ' '); // Get and sanitize the relation var relation = split[1]; relation = relation.Split('=')[1]; relation = relation.Trim('"'); if (relation == "self") { results.RequestUri = new Uri(url); } else if (relation == "next") { results.NextPage = new Uri(url); } else if (relation == "prev") { results.PrevPage = new Uri(url); } } } return(results); }
/// <summary> /// Methode receiving a json filter and transforming it to a NHibernate filter /// </summary> /// <param name="filter"></param> /// <returns></returns> IEnumerable <Message> IMessageFactory.Search(JObject filter) { return(FilterBuilder <Message> .Search(filter)); }
private ITypeSearch <BaseProduct> BuildBaseQuery(IContent currentContent, FilterOptionViewModel filterOptions) { var query = SearchClient.Instance.Search <BaseProduct>(); if (!string.IsNullOrWhiteSpace(filterOptions.Q)) { filterOptions.Q = filterOptions.Q.Replace("-", ""); query = query.For(filterOptions.Q) .InFields(x => x.EscapedCode, x => x.DisplayName, x => x.Name, x => x.Brand) .InField(x => x.Description) .InField(x => x.LongDescription) .InField(x => x.EscapedVariantCodes) .ApplyBestBets(); } query = query.FilterOnCurrentMarket(); query = query.FilterForVisitor(); var nodeContent = currentContent as NodeContent; try { if (nodeContent != null) { query = query.Filter( p => p.Ancestors() .Match(nodeContent.ContentLink.ToReferenceWithoutVersion().ToString())); } } catch (AccessDeniedException ex) { LogManager.GetLogger(GetType()).Error(ex.Message, ex.StackTrace); } catch (Exception ex) { LogManager.GetLogger(GetType()).Error(ex.Message, ex.StackTrace); } FilterBuilder <BaseProduct> filter = SearchClient.Instance.BuildFilter <BaseProduct>(); foreach (var facetGroup in filterOptions.FacetGroups.Where(fg => fg.Facets.Any(fo => fo.Selected))) { var selectedValues = facetGroup.Facets.Where(fo => fo.Selected).Select(fo => fo.Key); switch (facetGroup.GroupFieldName) { case Constants.Product.Brand: filter = filter.And(p => p.Brand.In(selectedValues)); break; case Constants.Product.AvailableColors: filter = filter.And(p => p.AvailableColorList.In(selectedValues)); break; case Constants.Product.AvailableSizes: filter = filter.And(p => p.AvailableSizeList.In(selectedValues)); break; case Constants.Product.TopCategory: filter = filter.And(p => p.TopCategory.In(selectedValues)); break; case Constants.Product.Categories: filter = filter.And(p => p.ParentName.In(selectedValues)); break; } } if (_organizationService.GetCurrentUserOrganization() != null) { List <string> organizationName = new List <string> { _organizationService.GetCurrentUserOrganization().Name }; query = query.Filter(prod => !prod.ExplicitACLProductBlackList.In(organizationName) & !prod.ExplicitACLParentBlackList.In(organizationName)); } query = query.Filter(filter); return(query); }
public async Task <CompanyActivityFilter> ToFilter(CompanyActivityFilter filter) { if (filter.OrFilter == null) { filter.OrFilter = new List <CompanyActivityFilter>(); } if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0) { return(filter); } foreach (var currentFilter in CurrentContext.Filters) { CompanyActivityFilter subFilter = new CompanyActivityFilter(); filter.OrFilter.Add(subFilter); List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value; foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions) { if (FilterPermissionDefinition.Name == nameof(subFilter.Id)) { subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Title)) { subFilter.Title = FilterBuilder.Merge(subFilter.Title, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.FromDate)) { subFilter.FromDate = FilterBuilder.Merge(subFilter.FromDate, FilterPermissionDefinition.DateFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.ToDate)) { subFilter.ToDate = FilterBuilder.Merge(subFilter.ToDate, FilterPermissionDefinition.DateFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.ActivityTypeId)) { subFilter.ActivityTypeId = FilterBuilder.Merge(subFilter.ActivityTypeId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.ActivityPriorityId)) { subFilter.ActivityPriorityId = FilterBuilder.Merge(subFilter.ActivityPriorityId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Description)) { subFilter.Description = FilterBuilder.Merge(subFilter.Description, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Address)) { subFilter.Address = FilterBuilder.Merge(subFilter.Address, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.CompanyId)) { subFilter.CompanyId = FilterBuilder.Merge(subFilter.CompanyId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.AppUserId)) { subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.ActivityStatusId)) { subFilter.ActivityStatusId = FilterBuilder.Merge(subFilter.ActivityStatusId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null) { if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id) { } if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id) { } } } } return(filter); }
public async Task Execute(string id) { var filter = FilterBuilder.Where(shipment => shipment.Id == ObjectId.Parse(id)); await Collections.Shipments.DeleteOneAsync(filter); }
public async Task <bool> CalendarExists(string calendarName) { return (await Collection.Find( FilterBuilder.Where(calendar => calendar.Id == new CalendarId(calendarName, InstanceName))).AnyAsync().ConfigureAwait(false)); }