public void setTypeNparent(int tp, AdvancedFilter pa, int func_ind)
{
parent = pa;
type = tp;
if (func_ind == 0)
{
include_all = true;
}
else
{
include_all = false;
}
switch (type)
{
case 1: //project
load_als_project();
break;
case 2: //bedrijf
bdr_nr_loc_adapt.Fill(bdr_nr_loc_dt);
AdvFilterDataset.bedrijvenlijstDataTable bldt = parent.kies_bedrijvenlijst();
AdvFilterDataset.bedrijvenlijstRow blr = (AdvFilterDataset.bedrijvenlijstRow)bldt.Rows[func_ind];
load_als_bedrijf(blr);
break;
case 3: //contact
pers_nr_loc_adapt.Fill(pers_nr_loc_dt);
AdvFilterDataset.personenlijstDataTable pldt = parent.kies_personenlijst();
AdvFilterDataset.personenlijstRow plr = (AdvFilterDataset.personenlijstRow)pldt.Rows[func_ind];
load_als_contact(plr);
break;
}
init_all();
}
private void AdvancedQueryButton_Click(object sender, EventArgs e)
{
AdvancedFilter filterform = new AdvancedFilter();
filterform.FormClosing += filterform_FormClosing;
filterform.ShowDialog();
}
private void btnMissingResource_Click(object sender, EventArgs e)
{
// Filter the non-summary tasks and not milestone that're missing resource
AdvancedFilter advancedFilter = new AdvancedFilter();
ConditionTaskFilter summaryCondition = new ConditionTaskFilter();
summaryCondition.FilterField = FilterField.Summary;
summaryCondition.TestOperator = TestOperators.Equal;
summaryCondition.FilterValue = false;
advancedFilter.Conditions.Add(summaryCondition);
ConditionTaskFilter milestoneCondition = new ConditionTaskFilter();
milestoneCondition.FilterField = FilterField.Milestone;
milestoneCondition.TestOperator = TestOperators.Equal;
milestoneCondition.FilterValue = false;
advancedFilter.Conditions.Add(milestoneCondition);
ConditionTaskFilter resourceCondition = new ConditionTaskFilter();
resourceCondition.FilterField = FilterField.ResourceNames;
resourceCondition.TestOperator = TestOperators.Equal;
resourceCondition.FilterValue = string.Empty;
advancedFilter.Conditions.Add(resourceCondition);
gv.ApplyFilter(advancedFilter);
}
private void btnPerformWithin_Click(object sender, EventArgs e)
{
AdvancedFilter filter = new AdvancedFilter();
// Filter the tasks start from 2014/03/16...
ConditionTaskFilter startCondition = new ConditionTaskFilter();
startCondition.FilterField = FilterField.Start;
startCondition.TestOperator = TestOperators.IsGreaterThanOrEqualTo;
startCondition.FilterValue = new DateTime(2014, 3, 16);
filter.Conditions.Add(startCondition);
// ...finish before or at 2014/04/01...
ConditionTaskFilter finishCondition = new ConditionTaskFilter();
finishCondition.FilterField = FilterField.Finish;
finishCondition.TestOperator = TestOperators.IsLessThanOrEqualTo;
finishCondition.FilterValue = new DateTime(2014, 4, 1);
filter.Conditions.Add(finishCondition);
// ...and are not non-summary tasks.
ConditionTaskFilter summaryCondition = new ConditionTaskFilter();
summaryCondition.FilterField = FilterField.Summary;
summaryCondition.TestOperator = TestOperators.Equal;
summaryCondition.FilterValue = false;
filter.Conditions.Add(summaryCondition);
gv.ApplyFilter(filter);
}
private static void ValidateInclude <TEntity>(AdvancedFilter advancedFilter)
{
if (!string.IsNullOrWhiteSpace(advancedFilter.Include))
{
var propertyNames = advancedFilter.Include.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
propertyNames = advancedFilter.PropertyMappings.MapProperties(propertyNames).ToArray();
ValidateInclude <TEntity>(propertyNames);
}
}
void filterform_FormClosing(object sender, FormClosingEventArgs e)
{
AdvancedFilter filterform = (AdvancedFilter)sender;
foreach (IFilterQuery query in filterform.GetQueries())
{
AddFilterToFilterRules(query);
}
RefreshGridView();
}
public void FirstName()
{
// Arrange
var view = GetView(new[] { A_A, A_B, B_A, B_B });
var filter = new AdvancedFilter(view);
// Act/Assert
filter.Filter(nameof(Data.FirstName), new[] { 'A' });
AssertEquivalent(view, new[] { A_A, A_B });
}
/// <inheritdoc />
public async Task <int> GetCountAsync(AdvancedFilter advancedFilter, Expression <Func <TEntity, bool> >?filter = null)
{
IQueryable <TEntity> query = DbSet;
if (filter != null)
{
query = query.Where(filter);
}
return(await query.Filter(advancedFilter).CountAsync());
}
/// <inheritdoc />
public int GetCount(AdvancedFilter advancedFilter, Expression <Func <TEntity, bool> >?filter = null)
{
IQueryable <TEntity> query = DbSet;
if (filter != null)
{
query = query.Where(filter);
}
return(query.Filter(advancedFilter).Count());
}
private void btnMissNaming_Click(object sender, EventArgs e)
{
AdvancedFilter filter = new AdvancedFilter();
ConditionTaskFilter condition = new ConditionTaskFilter();
condition.FilterField = FilterField.Name;
condition.TestOperator = TestOperators.Equal;
filter.Conditions.Add(condition);
gv.ApplyFilter(filter);
}
private void btnHaveNotes_Click(object sender, EventArgs e)
{
AdvancedFilter filter = new AdvancedFilter();
ConditionTaskFilter notesCondition = new ConditionTaskFilter();
notesCondition.FilterField = FilterField.Notes;
notesCondition.TestOperator = TestOperators.DoesNotEqual;
filter.Conditions.Add(notesCondition);
gv.ApplyFilter(filter);
}
/// <summary>
/// Applies the advanced filter to the queryable.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <param name="source">The queryable.</param>
/// <param name="advancedFilter">The advanced filter.</param>
/// <returns>A collection of entities.</returns>
public static IQueryable <TEntity> Filter <TEntity>(
this IQueryable <TEntity> source,
AdvancedFilter advancedFilter)
where TEntity : class, IDataEntity
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
else if (advancedFilter == null)
{
return(source);
}
ValidateOrderBy <TEntity>(advancedFilter);
ValidateInclude <TEntity>(advancedFilter);
// Include
if (!string.IsNullOrWhiteSpace(advancedFilter.Include))
{
var paths = advancedFilter.Include.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
paths = advancedFilter.PropertyMappings.MapProperties(paths).ToArray();
source = source.Include(paths);
}
// Filter
if (!string.IsNullOrEmpty(advancedFilter.Filter))
{
source = source.Filter(advancedFilter.Filter, advancedFilter.PropertyMappings);
}
// Order by
if (!string.IsNullOrEmpty(advancedFilter.OrderBy))
{
var orderBy = advancedFilter.PropertyMappings.MapProperty(advancedFilter.OrderBy);
source = source.OrderBy(orderBy, advancedFilter.SortOrder);
}
// Select
if (!string.IsNullOrWhiteSpace(advancedFilter.Select))
{
var paths = advancedFilter.Select.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
paths = advancedFilter.PropertyMappings.MapProperties(paths).ToArray();
string[] fields = GetEntityProperties <TEntity>(paths);
source = source.Select(fields);
}
// Paging
source = source.GetPage(advancedFilter.Page, advancedFilter.PageSize);
return(source);
}
/// <inheritdoc />
public virtual IEnumerable <TEntity> Find(
AdvancedFilter advancedFilter,
Expression <Func <TEntity, bool> >?filter = null)
{
IQueryable <TEntity> query = DbSet;
// Filter
if (filter != null)
{
query = query.Where(filter);
}
return(query.Filter(advancedFilter).ToList());
}
/// <inheritdoc />
public virtual async Task <IEnumerable <TEntity> > FindAsync(
AdvancedFilter advancedFilter,
Expression <Func <TEntity, bool> >?filter = null)
{
IQueryable <TEntity> query = DbSet;
// Filter
if (filter != null)
{
query = query.Where(filter);
}
return(await query.Filter(advancedFilter).ToListAsync());
}
public void When_Find_is_called_then_fields_should_be_selected()
{
// Arrange
var searchCriteria = new AdvancedFilter
{
Select = "Id,Name",
};
// Act
var result = SystemUnderTest.Find(searchCriteria);
// Assert
result.Any(product => product.Id == 0).Should().BeFalse(because: "we selected the field Id and Name");
result.Any(product => product.Name == null).Should().BeFalse(because: "we selected the field Id and Name");
result.All(product => product.Category == null).Should().BeTrue(because: "we selected the field Id and Name and not Category");
}
private void btnCompletedByCarole_Click(object sender, EventArgs e)
{
AdvancedFilter advancedFilter = new AdvancedFilter();
// Filter the tasks that those ResourceNames contain "Carole Poland"...
ConditionTaskFilter resourceCondition = new ConditionTaskFilter();
resourceCondition.FilterField = FilterField.ResourceNames;
resourceCondition.TestOperator = TestOperators.Contain;
resourceCondition.FilterValue = "Carole Poland";
advancedFilter.Conditions.Add(resourceCondition);
ConditionTaskFilter percentCompleteCondition = new ConditionTaskFilter();
percentCompleteCondition.FilterField = FilterField.PercentComplete;
percentCompleteCondition.TestOperator = TestOperators.Equal;
percentCompleteCondition.FilterValue = 1.0;
advancedFilter.Conditions.Add(percentCompleteCondition);
gv.ApplyFilter(advancedFilter);
}
public List <StudentDetailsModel> FetchStudentdetailsV2(StudentFilterModel filter)
{
_context = new StudentdataContext();
StudentFilterModel primaryFilter = new StudentFilterModel();
var studentDetails = _context.sp_FetchStudentDetails(primaryFilter.StudentId, primaryFilter.EnrollmentId, primaryFilter.ServiceId).AsEnumerable();
var advancedfilter = new AdvancedFilter();
var spec1 = new StudentSpecification(filter.StudentId);
var spec2 = new EnrollmentSpecification(filter.EnrollmentId);
var spec3 = new ServiceSpecification(filter.ServiceId);
//var result= advancedfilter.Filter(studentDetails, spec1);
//result = advancedfilter.Filter(result, spec2);
//result = advancedfilter.Filter(result, spec3);
var result = advancedfilter.AdvancedFilterMethod(studentDetails, new List <ISpecification <sp_FetchStudentDetails_Result> > {
spec1, spec2, spec3
});
if (result != null)
{
var output = result.Distinct().Select(student =>
new StudentDetailsModel
{
Id = student.Id
,
DateOfBirth = student.DateOfBirth
,
EndDate = student.Enddate
,
Startdate = student.StartDate
,
EnrollmentYear = student.Enrollment
,
FullName = student.FirstName + " " + student.LastName
,
ServiceName = student.ServiceName
}).ToList();
return(output);
}
return(new List <StudentDetailsModel>());
}
IEnumerable <TViewModel> DoFilter(string input, bool order, bool advanced)
{
IEnumerable <TViewModel> results;
if (string.IsNullOrEmpty(input))
{
results = Collection;
}
else
{
if (advanced)
{
var terms = AdvancedFilter.Parse(input);
if (!terms.Any())
{
results = Collection;
}
else
{
var normal = terms.FirstOrDefault(p => p.Type == AdvancedFilterType.Normal);
var negate = terms.Where(p => p.Type == AdvancedFilterType.Negate);
results = Collection.Where(p =>
(normal == null || p.DomainObject.Name.ToLower().Contains(normal.Value.ToLower())) &&
negate.All(z => !p.DomainObject.Name.ToLower().Contains(z.Value.ToLower())));
}
}
else
{
results = Collection.Where(p => p.DomainObject.Name.ToLower().Contains(input.ToLower()));
}
}
if (order)
{
results = results.OrderBy(p => p.DomainObject.Name);
}
return(results);
}
/// <summary>
/// Creates search package for Advanced Search function
/// </summary>
/// <param name="dict"></param>
/// <returns></returns>
public static SearchPackage GetExportSearchPackage(Dictionary <string, string> dict, string sortColumn, string sortOrder)
{
SearchPackage searchPackage = new SearchPackage();
searchPackage.SortSord = sortOrder;
searchPackage.SortColumn = sortColumn;
searchPackage.PageIndex = 1;
searchPackage.RowCount = 100000000;
AdvancedFilter advancedFilter = new AdvancedFilter();
List <SingleFilter> lstfilters = new List <SingleFilter>();
SingleFilter singleFilter;
foreach (KeyValuePair <string, string> item in dict)
{
singleFilter = new SingleFilter(item.Key, ComparisonOperator.eq, item.Value);
lstfilters.Add(singleFilter);
}
advancedFilter.Rules = lstfilters.ToArray();
searchPackage.AdvancedFilter = advancedFilter;
return(searchPackage);
}
private void btnTobyOrToni_Click(object sender, EventArgs e)
{
AdvancedFilter advancedFilter = new AdvancedFilter();
// Filter the tasks that those ResourceNames contain "Toby Nixon"...
ConditionTaskFilter tobyCondition = new ConditionTaskFilter();
tobyCondition.FilterField = FilterField.ResourceNames;
tobyCondition.TestOperator = TestOperators.Contain;
tobyCondition.FilterValue = "Toby Nixon";
advancedFilter.Conditions.Add(tobyCondition);
// ...and "Toni Poe".
ConditionTaskFilter sharonCondition = new ConditionTaskFilter();
// Using Or combination operator.
sharonCondition.CombinationOperator = CombinationOperator.Or;
sharonCondition.FilterField = FilterField.ResourceNames;
sharonCondition.TestOperator = TestOperators.Contain;
sharonCondition.FilterValue = "Toni Poe";
advancedFilter.Conditions.Add(sharonCondition);
gv.ApplyFilter(advancedFilter);
}
private void btnFilter_Click(object sender, EventArgs e)
{
ArrayList columns;
AdvancedFilter filter = null;
switch (typeOfData)
{
case EntityTypes.Client:
{
columns = new ArrayList
{
new DBMap("name", "Name"),
new DBMap("phone_number", "Phone #"),
new DBMap("email_address", "Email"),
new DBMap("fax_number", "Fax #")
};
filter = new AdvancedFilter("Client", columns, "Find Clients", "", Icon.FromHandle(Resources.client_16x16.GetHicon()));
break;
}
case EntityTypes.Realtor:
{
columns = new ArrayList
{
new DBMap("name", "Name"),
new DBMap("company_name", "Company Name"),
new DBMap("phone_number", "Phone #"),
new DBMap("email_address", "Email"),
new DBMap("fax_number", "Fax #")
};
filter = new AdvancedFilter("Realtor", columns, "Find Realtors", "", Icon.FromHandle(Resources.realtor_16x16.GetHicon()));
break;
}
case EntityTypes.TitleCompany:
{
columns = new ArrayList
{
new DBMap("name", "Name"),
new DBMap("associate_name", "Associate's Name"),
new DBMap("associate_email", "Associate's Email"),
new DBMap("office_number", "Office #")
};
filter = new AdvancedFilter("TitleCompany", columns, "Find Title Companies", "", Icon.FromHandle(Resources.title_company_16x16.GetHicon()));
break;
}
case EntityTypes.Rate:
{
columns = new ArrayList
{
new DBMap("description", "Description"),
new DBMap("amount", "Amount"),
new DBMap("time_unit", "Time Unit")
};
filter = new AdvancedFilter("Rates", columns, "Find Rates");
break;
}
case EntityTypes.Survey:
{
columns = new ArrayList
{
new DBMap("job_number", "Job #"),
new DBMap("client_id", "Client ID"),
new DBMap("description", "Description"),
new DBMap("subdivision", "Subdivision"),
new DBMap("lot", "Lot #"),
new DBMap("block", "Block #"),
new DBMap("section", "Section #"),
new DBMap("county_id", "County"),
new DBMap("acres", "Acres"),
new DBMap("realtor_id", "Realtor ID"),
new DBMap("title_company_id", "Title Company ID")
}; //TODO: combine all tables to search for surveys!
filter = new AdvancedFilter("Survey", columns, "Find Surveys", "", Icon.FromHandle(Resources.surveying_16x16.GetHicon()));
break;
}
}
if (filter != null)
{
filter.FilterDone += ProcessSearch;
filter.Show();
}
}
