internal void ResetFieldFilters()
{
if (m_createdScheduleId == null)
{
return;
}
try
{
using (Transaction t = new Transaction(m_doc, "Reset Filters"))
{
ViewSchedule tmpSchedule =
m_doc.GetElement(m_createdScheduleId) as ViewSchedule;
t.Start();
foreach (string paramName in m_filtersValues.Keys)
{
FieldFilter fieldFilter =
new FieldFilter(tmpSchedule, paramName);
fieldFilter.UpdateFilter(m_filtersValues[paramName]);
}
t.Commit();
}
}
catch (Exception ex)
{
throw ex;
}
}
private IQueryable <FieldDAO> DynamicFilter(IQueryable <FieldDAO> query, FieldFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.MenuId != null)
{
query = query.Where(q => q.MenuId, filter.MenuId);
}
if (filter.FieldTypeId != null)
{
query = query.Where(q => q.FieldTypeId, filter.FieldTypeId);
}
query = OrFilter(query, filter);
return(query);
}
protected virtual List <SCField> FilteredFields(Item item)
{
var filteredFields = new List <SCField>();
if (IndexAllFields)
{
item.Fields.ReadAll();
filteredFields.AddRange(item.Fields);
}
else if (HasFieldIncludes)
{
foreach (var includeFieldId in from p in FieldFilter where p.Value select p)
{
filteredFields.Add(item.Fields[ID.Parse(includeFieldId.Key)]);
}
}
if (HasFieldExcludes)
{
foreach (SCField field in item.Fields)
{
var fieldKey = field.ID.ToString();
if (!(!FieldFilter.ContainsKey(fieldKey) ? true : FieldFilter[fieldKey]))
{
filteredFields.Remove(field);
}
}
}
return(filteredFields.Where(f => !String.IsNullOrEmpty(f.Key)).ToList());
}
private IQueryable <FieldDAO> OrFilter(IQueryable <FieldDAO> query, FieldFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <FieldDAO> initQuery = query.Where(q => false);
foreach (FieldFilter FieldFilter in filter.OrFilter)
{
IQueryable <FieldDAO> queryable = query;
if (FieldFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, FieldFilter.Id);
}
if (filter.FieldTypeId != null)
{
query = query.Where(q => q.FieldTypeId, filter.FieldTypeId);
}
if (filter.MenuId != null)
{
query = query.Where(q => q.MenuId, filter.MenuId);
}
if (FieldFilter.Name != null)
{
queryable = queryable.Where(q => q.Name, FieldFilter.Name);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
static partial void RealInstanceFactory(ref FieldFilter real, string callerName)
{
FieldDefinition fd = (FieldDefinition)FormatterServices.GetUninitializedObject(typeof(FieldDefinition));
object value = null;
real = new FieldFilter(fd, value);
}
public async Task GetPageFilterFieldsTest(string fieldName,
object[] values, int expectedCount)
{
//Arrange
var teamProjects = Builder <ProjectTeam> .CreateListOfSize(10)
.All().WithFactory(i => new ProjectTeam(_testData.Projects[i].Id, 1))
.Build();
var context = ContextHelper.CreateContext(_dbConnection, false);
context.RemoveRange(_testData.ProjectTeams);
await context.AddRangeAsync(teamProjects);
await context.SaveChangesAsync();
var filterField = new FieldFilter(fieldName, values);
var pageOptions = new PageOptions
{
PageNumber = 0,
PageSize = 10,
FilterFields = new[] { filterField }
};
//Act
var projects = (await _service.GetPage(_currentUser, 1, pageOptions)).ToArray();
//Assert
Assert.AreEqual(expectedCount, projects.Length);
}
public async Task <int> Count(FieldFilter filter)
{
IQueryable <FieldDAO> Fields = DataContext.Field.AsNoTracking();
Fields = DynamicFilter(Fields, filter);
return(await Fields.CountAsync());
}
public void FilterFields(FieldFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
FilterFieldsImpl(this, filter);
}
/// <summary>Builds a count query.</summary>
/// <param name="filter">An optional filter.</param>
/// <param name="token">Optional query token.</param>
/// <returns>A count query.</returns>
public static IQuery BuildCountQuery(FieldFilter filter = null, object token = null)
{
CountQuery countQuery = new CountQuery
{
Filter = filter,
Token = token
};
return(countQuery);
}
/// <summary>Builds a simple query.</summary>
/// <param name="filter">An optional filter.</param>
/// <param name="sortOption">Optional sorting options.</param>
/// <param name="token">Optional query token.</param>
/// <returns>A simple query.</returns>
public static IQuery BuildSimpleQuery(FieldFilter filter = null, Sort sortOption = null, object token = null)
{
SimpleQuery simpleQuery = new SimpleQuery
{
Filter = filter,
Sort = sortOption,
Token = token
};
return(simpleQuery);
}
/// <summary>Builds an indexed query.</summary>
/// <param name="pageSize">The number of results to return.</param>
/// <param name="index">The results starting index.</param>
/// <param name="filter">An optional filter.</param>
/// <param name="sortOption">Optional sorting options.</param>
/// <param name="token">Optional query token.</param>
/// <returns>A paged query.</returns>
public static IQuery BuildIndexedQuery(int pageSize, int index = 0, FieldFilter filter = null, Sort sortOption = null, object token = null)
{
IndexedQuery indexedQuery = new IndexedQuery
{
PageSize = pageSize,
Index = index,
Filter = filter,
Sort = sortOption,
Token = token
};
return(indexedQuery);
}
private List <FieldFilter> AddFieldsEqualParams(KeyValuePair <string, string>[] filter)
{
List <FieldFilter> fieldFilters = new List <FieldFilter>();
foreach (KeyValuePair <string, string> keyValue in filter)
{
FieldFilter ff = new FieldFilter();
ff.name = keyValue.Key;
ff.value = keyValue.Value;
fieldFilters.Add(ff);
}
return(fieldFilters);
}
internal static FieldFilterWrapper GetInstance()
{
FieldFilter real = default(FieldFilter);
RealInstanceFactory(ref real);
var instance = (FieldFilterWrapper)FieldFilterWrapper.GetWrapper(real);
InstanceFactory(ref instance);
if (instance == null)
{
Assert.Inconclusive("Could not Create Test Instance");
}
return(instance);
}
public Field Map(FieldFilter filter, Field field, CreateOrEditViewModel createOrEdit)
{
if (field.Id == 0)
{
field.FormId = (int)filter.Form.Id;
}
field.FieldTypeId = createOrEdit.FieldTypeId;
field.Code = createOrEdit.Code;
field.IsRequired = createOrEdit.IsRequired;
field.MaxLength = createOrEdit.MaxLength;
field.Position = createOrEdit.Position;
return(field);
}
public async Task <List <Field> > List(FieldFilter filter)
{
if (filter == null)
{
return(new List <Field>());
}
IQueryable <FieldDAO> FieldDAOs = DataContext.Field.AsNoTracking();
FieldDAOs = DynamicFilter(FieldDAOs, filter);
FieldDAOs = DynamicOrder(FieldDAOs, filter);
List <Field> Fields = await DynamicSelect(FieldDAOs, filter);
return(Fields);
}
/// <summary>
/// Called by infrastructure to automatically build filters from attributes on content types
/// </summary>
/// <param name="ehd">Event data when called via an event being raised after the repository is built</param>
/// <returns>Returns null (needed to have signature of an event processor)</returns>
public object BuildFilters(EventHubData ehd)
{
// Get filters on summary types
foreach (Type t in ContentTypeHierarchy.SummaryBaseTypes.Keys.Concat(typeof(Summary)))
{
foreach (PropertyInfo pi in t.GetProperties(BindingFlags.DeclaredOnly |
BindingFlags.Public |
BindingFlags.Instance)) // just the properties declared in this class, not any base class
{
var lfa = pi.GetCustomAttribute <FieldFilterAttribute>();
if (lfa != null)
{
Filters.Add(FieldFilter.Create(lfa, pi));
}
}
}
// Get filters on container types
foreach (Type t in ContentTypeHierarchy.AllContentTypes.Select(ct => Collator.Instance.ContainerType(ct)).Distinct())
{
foreach (PropertyInfo pi in t.GetProperties())
{
var lfa = pi.GetCustomAttribute <FieldFilterAttribute>();
if (lfa != null)
{
Filters.Add(FieldFilter.Create(lfa, pi));
}
}
}
// Get filters on container extension types
foreach (Type extT in CompositeTypeManager.Instance.ExtensionTypes)
{
Type baseT = extT.BaseType;
foreach (PropertyInfo pi in extT.GetProperties(BindingFlags.DeclaredOnly |
BindingFlags.Public |
BindingFlags.Instance))
{
var lfa = pi.GetCustomAttribute <FieldFilterAttribute>();
if (lfa != null)
{
PropertyInfo mappedPi = CompositeTypeManager.Instance.ExtendedTypes[baseT]
.GetProperty(pi.Name);
Filters.Add(FieldFilter.Create(lfa, mappedPi));
}
}
}
return(null);
}
private IQueryable <FieldDAO> DynamicOrder(IQueryable <FieldDAO> query, FieldFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case FieldOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case FieldOrder.Menu:
query = query.OrderBy(q => q.Menu.Name);
break;
case FieldOrder.FieldType:
query = query.OrderBy(q => q.FieldType.Name);
break;
case FieldOrder.Name:
query = query.OrderBy(q => q.Name);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case FieldOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case FieldOrder.Menu:
query = query.OrderByDescending(q => q.Menu.Name);
break;
case FieldOrder.FieldType:
query = query.OrderByDescending(q => q.FieldType.Name);
break;
case FieldOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
/// <summary>
/// Gets the iteration path where clause.
/// </summary>
/// <param name="fieldFilter">The field filter.</param>
/// <returns></returns>
private static string GetIterationPathWhereClause(string projectName, FieldFilter fieldFilter)
{
string iterationPathClause = " ";
if (!string.IsNullOrEmpty(fieldFilter.Iteration) && !string.IsNullOrEmpty(fieldFilter.Release))
{
//TODO If it is Group need to get the group members from TA SDK API.
string iterationPath = projectName + "\\" + fieldFilter.Release + "\\" + fieldFilter.Iteration;
// Individual resource we can use directly as below.
iterationPathClause = iterationPathClause + string.Format("AND [System.IterationPath] = '{0}'", iterationPath);
}
return(iterationPathClause);
}
public AddEditFilterForm(FieldFilter filter) : this()
{
this.FieldFilter = filter ?? new FieldFilter
{
Name = "New Filter",
Type = FilterType.CannotBeNull,
Action = FilterAction.Flag
};
this.ddlType.DataSource = Enum.GetValues(typeof(FilterType));
this.ddlAction.DataSource = Enum.GetValues(typeof(FilterAction));
this.txtName.Text = this.FieldFilter.Name;
this.ddlType.SelectedValue = this.FieldFilter.Type;
this.ddlAction.SelectedValue = this.FieldFilter.Action;
}
private static AbstractSolrQuery Compute(FilterBase filter, Operation op)
{
if (filter != null)
{
if (filter is RangeFilter)
{
RangeFilter rf = filter as RangeFilter;
return(Compute(new SolrQueryByRange <string>(rf.Field, rf.From, rf.To, rf.Inclusive), null, op));
}
else if (filter is FieldFilter)
{
FieldFilter ff = filter as FieldFilter;
return(Compute(new SolrQueryByField(ff.Field, ff.Value), null, op));
}
}
return(null);
}
/// <summary>
/// Gets the work item type where clause.
/// </summary>
/// <param name="fieldFilter">The field filter.</param>
/// <returns>Work item type Where Clause</returns>
private static string GetWorkItemTypeWhereClause(FieldFilter fieldFilter)
{
string whereClause = " WHERE [System.TeamProject] = @project";
ItemType workItemType = (ItemType)fieldFilter.WorkItemType;
switch (workItemType)
{
case ItemType.Item:
whereClause = whereClause + " AND [System.WorkItemType] = 'Item'";
break;
case ItemType.Task:
whereClause = whereClause + " AND [System.WorkItemType] = 'Task'";
break;
case ItemType.Bug:
whereClause = whereClause + " AND [System.WorkItemType] = 'Bug'";
break;
case ItemType.UserStory:
whereClause = whereClause + " AND [System.WorkItemType] = 'User Story'";
break;
case ItemType.OutOfScope:
whereClause = whereClause + " AND [System.WorkItemType] = 'Out-of-scope'";
break;
case ItemType.TechnicalDebt:
whereClause = whereClause + " AND [System.WorkItemType] = 'Technical Debt'";
break;
case ItemType.Feature:
whereClause = whereClause + " AND [System.WorkItemType] = 'Feature'";
break;
case ItemType.EnhancementRequest:
whereClause = whereClause + " AND [System.WorkItemType] = 'Enhancement Request'";
break;
default:
break;
}
return(whereClause);
}
public string Build(IEnumerable <FieldFilter> fieldFilters)
{
const string location = "location";
if (!IsValid(fieldFilters))
{
throw new ArgumentException("One or more field filter parameters is invalid");
}
_fieldFilters = fieldFilters;
FieldFilter latitude = _fieldFilters.Where(n => string.Equals(n.Name, LatitudeFieldName, StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
FieldFilter longitude = _fieldFilters.Where(n => string.Equals(n.Name, LongitudeFieldName, StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
string query = $"within_circle({location}, {latitude.Value}, {longitude.Value}, {_appSettingsManager.AppSettings.Value.RadiusOfCentralCoordinateInMeters})";
return(query);
}
// protected static EntityAssociation LookupEntityAssociation(ApplicationAssociationDefinition association) {
// var appMetadata = MetadataProvider.Application(association.From);
// var indexOf = association._labelField.IndexOf(".", StringComparison.Ordinal);
// var firstPart = _labelField.Substring(0, indexOf);
// var lookupString = firstPart.EndsWith("_") ? firstPart : firstPart + "_";
// return MetadataProvider.Entity(appMetadata.Entity).Associations.FirstOrDefault(a => a.Qualifier == lookupString);
// }
public static ApplicationAssociationSchemaDefinition GetSchemaInstance(AssociationDataProvider dataProvider, AssociationFieldRenderer renderer,
FieldFilter filter, string dependantFieldsST)
{
var schema = new ApplicationAssociationSchemaDefinition(dataProvider, renderer, filter);
if (schema.DataProvider != null)
{
schema.DependantFields = DependencyBuilder.TryParsingDependentFields(schema.DataProvider.WhereClause);
}
if (dependantFieldsST != null)
{
var fields = dependantFieldsST.Split(',');
foreach (var field in fields)
{
schema.DependantFields.Add(field);
}
}
return(schema);
}
public async Task GetPageFilterFieldsTest(int pageNumber, int pageSize,
string filter, string fieldName, object[] values, int expectedCount)
{
//Arrange
var filterField = new FieldFilter(fieldName, values);
var pageOptions = new PageOptions
{
PageNumber = pageNumber,
PageSize = pageSize,
Filter = filter,
FilterFields = new[] { filterField }
};
//Act
var projects = (await _service.GetPage(_currentUser, pageOptions)).ToArray();
//Assert
Assert.AreEqual(expectedCount, projects.Length);
}
public async Task <List <Role_FieldDTO> > SingleListField([FromBody] Role_FieldFilterDTO Role_FieldFilterDTO)
{
FieldFilter FieldFilter = new FieldFilter();
FieldFilter.Skip = 0;
FieldFilter.Take = 200;
FieldFilter.OrderBy = FieldOrder.Id;
FieldFilter.OrderType = OrderType.ASC;
FieldFilter.Selects = FieldSelect.ALL;
FieldFilter.Id = Role_FieldFilterDTO.Id;
FieldFilter.MenuId = Role_FieldFilterDTO.MenuId;
FieldFilter.Name = Role_FieldFilterDTO.Name;
List <Field> Fieldes = await FieldService.List(FieldFilter);
List <Role_FieldDTO> Role_FieldDTOs = Fieldes
.Select(x => new Role_FieldDTO(x)).ToList();
return(Role_FieldDTOs);
}
private void btnGetBurn_Click(object sender, EventArgs e)
{
try
{
this.Cursor = Cursors.WaitCursor;
SmartManager.SmartManagerSDK smartManagerSDK = new SmartManager.SmartManagerSDK();
//ChildItemCollection childReport = smartManagerSDK.GetChildTasksDetails("http://tfs.kofax.com:8080/tfs/products", "KTA", "742678");
FieldFilter fieldFilter = new FieldFilter();
fieldFilter.AssignedTo.Name = "Tiger Team";
burnReport = smartManagerSDK.GetBurnDetails("7A2D26351789904A8993CC2455163262", "http://tfs.kofax.com:8080/tfs/products", "KTA", fieldFilter);
//burnReport = smartManagerSDK.GetAssignedWorkItems("7A2D26351789904A8993CC2455163262", "http://tfs.kofax.com:8080/tfs/products", "KTA", fieldFilter);
this.ResetBurnReport();
filter = PopulateFilterDetails();
//ViewType selectedViewType = ViewType.Resource;
//if (radStoryView.Checked)
//{
// selectedViewType = ViewType.Story;
//}
ClientApplication.Manager.Connect("http://tfs.kofax.com:8080/tfs/products", "KTA");
burnReport = ClientApplication.Manager.GetBurnDetails(filter);
//Report report = ClientApplication.Manager.GetChildTasksDetails(filter);
//burnReport.SetView(selectedViewType, filter.Team.Members);
this.PopulateBurnView();
reportRunningTime = DateTime.Now.TimeOfDay - reportRunningTime;
lblReportRunTime.Text = reportRunningTime.TotalSeconds.ToString("F0");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
this.Cursor = Cursors.Default;
}
}
public static Dictionary <string, FieldFilter> ParseFilterExp(ref string filterExp, ListRequest dto)
{
var groups = Regex.Matches(filterExp, _regexGetFilterGroupDetails, RegexOptions.IgnoreCase);
var fieldFilters = new Dictionary <string, FieldFilter>();
for (var i = 0; i < groups.Count; i++)
{
//Log.Debug($@"A - {DateTime.Now.ToString("O")}");
var g = groups[i];
var groupName = $"group{i}";
var not = g.Groups[1]?.Value == "not";
var fieldName = g.Groups[2].Value;
filterExp = filterExp.Replace(g.ToString(), $"({groupName})");
var value = g.Groups[4]?.Value?.Trim();
if (value == null)
{
continue;
}
FilterOperator?operator_ = g.Groups[3].Value.ToEnum <FilterOperator>();
// No need this anymore, cause auto gen exp already included default operator
//if ((isFilterAutoGenerated || operator_ == null)
// && dto.FilterSettings != null
// && dto.FilterSettings.ContainsKey(fieldName))
//{
// operator_ = dto.FilterSettings[fieldName].DefaultOperator;
//}
fieldFilters[groupName] = new FieldFilter
{
Not = not,
Exp = g.Groups[0]?.Value,
FieldName = fieldName,
Operator = operator_.Value,
Value = value,
ValueTypeString = g.Groups[5]?.Value
};
}
return(fieldFilters);
}
private List <FieldFilter> AddFacetFilters(List <KeyValuePair <string, string[]> > facetFilters)
{
List <FieldFilter> fieldFilters = new List <FieldFilter>();
var specialFilters = facetFilters.Where(elem => elem.Key == "personaward" || elem.Key == "personyear");
List <KeyValuePair <string, string[]> > copyfacetFilters = new List <KeyValuePair <string, string[]> >();
copyfacetFilters.AddRange(facetFilters);
if (specialFilters.Count() == 2)
{
var personyear = copyfacetFilters.Where(elem => elem.Key == "personyear").FirstOrDefault();
var personaward = copyfacetFilters.Where(elem => elem.Key == "personaward").FirstOrDefault();
copyfacetFilters.Remove(personyear);
copyfacetFilters.Remove(personaward);
foreach (string filterValueAward in personaward.Value)
{
foreach (string filterValueYear in personyear.Value)
{
FieldFilter ff = new FieldFilter();
ff.name = "personyearaward";
ff.value = filterValueYear + " " + filterValueAward;
fieldFilters.Add(ff);
}
}
}
foreach (KeyValuePair <string, string[]> filter in copyfacetFilters)
{
foreach (string filterValue in filter.Value)
{
FieldFilter ff = new FieldFilter();
ff.name = filter.Key;
ff.value = filterValue;
fieldFilters.Add(ff);
}
}
return(fieldFilters);
}
/// <summary>
/// Gets the state where clause.
/// </summary>
/// <param name="fieldFilter">The field filter.</param>
/// <returns>State Where Clause</returns>
private static string GetStateWhereClause(FieldFilter fieldFilter)
{
string stateClause = " ";
StatusType status = (StatusType)fieldFilter.State;
switch (status)
{
case StatusType.Any:
break;
case StatusType.Active:
stateClause = stateClause + "AND [System.State] = 'Active'";
break;
case StatusType.Closed:
stateClause = stateClause + "AND [System.State] = 'Closed'";
break;
case StatusType.Impeded:
stateClause = stateClause + "AND [System.State] = 'Impeded'";
break;
case StatusType.New:
stateClause = stateClause + "AND [System.State] = 'New'";
break;
case StatusType.Open:
stateClause = stateClause + "AND [System.State] = 'Open'";
break;
case StatusType.Resolved:
stateClause = stateClause + "AND [System.State] = 'Resolved'";
break;
default:
break;
}
return(stateClause);
}
/// <summary>
/// Gets the assigned to where clause.
/// </summary>
/// <param name="sessionId">The session identifier.</param>
/// <param name="fieldFilter">The field filter.</param>
/// <returns>
/// Assigned to WhereClause
/// </returns>
private static string GetAssignedToWhereClause(string sessionId, FieldFilter fieldFilter, BurnRetrievalOptions retrievalOptions)
{
string assignedToClause = " ";
ResourceSummaryCollection reesourceSummaryCollection = null;
if (fieldFilter.AssignedTo != null && !string.IsNullOrEmpty(fieldFilter.AssignedTo.Name))
{
if (fieldFilter.AssignedTo.Name.Contains("Team"))
{
// Get Group Members
ResourceService resourceService = new ResourceService();
ResourceIdentity groupresourceIdenity = new ResourceIdentity()
{
Id = fieldFilter.AssignedTo.Id, Name = fieldFilter.AssignedTo.Name
};
reesourceSummaryCollection = resourceService.GetMembersOfGroup(sessionId, groupresourceIdenity, false);
if (reesourceSummaryCollection != null && reesourceSummaryCollection.Count > 0)
{
assignedToClause = assignedToClause + string.Format("({0})", BuildResourceString(reesourceSummaryCollection));
}
}
else
{
// Individual resource we can use directly as below.
assignedToClause = assignedToClause + string.Format("('{0}')", fieldFilter.AssignedTo.Name);
reesourceSummaryCollection = new ResourceSummaryCollection();
ResourceSummary resourceSummary = new ResourceSummary();
resourceSummary.Identity = new ResourceIdentity();
resourceSummary.Identity.Name = fieldFilter.AssignedTo.Name;
reesourceSummaryCollection.Add(resourceSummary);
}
PopulateTeamMembers(retrievalOptions, reesourceSummaryCollection);
}
return(assignedToClause);
}
