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));
}
