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