public PickerCollectionItemVM(FilterValue value) { Id = value.Id; Value = value.Value; ValueName = value.ValueName; }
internal override string CreateWhere(IDictionary <string, string> objectPropertyToColumnNameMapper, int parameterIndex) { if (objectPropertyToColumnNameMapper == null) { throw new ArgumentNullException(nameof(objectPropertyToColumnNameMapper)); } if (FilterType == SetFilterType.Between && FilterValue.Count() != 2) { throw new ArgumentOutOfRangeException(nameof(objectPropertyToColumnNameMapper), "The 'Between' search type may only be used with exactly 2 values."); } var columnName = objectPropertyToColumnNameMapper[PropertyName]; var parametersString = FilterType == SetFilterType.Between ? $"@p{parameterIndex++} AND @p{parameterIndex++}" : string.Join(", ", FilterValue.Select(value => $"@p{parameterIndex++}")); switch (FilterType) { case SetFilterType.In: return($"[{columnName}] IN ({parametersString})"); case SetFilterType.Between: return($"[{columnName}] BETWEEN {parametersString}"); case SetFilterType.NotIn: return($"[{columnName}] NOT IN ({parametersString})"); default: throw new NotImplementedException(); } }
private questStatus create(MasterPricingEntities dbContext, List <Quest.Functional.MasterPricing.FilterValue> filterValueList, out List <Quest.Functional.MasterPricing.FilterValue> filterValueIdList) { // Initialize filterValueIdList = null; // Perform create try { List <Quest.Services.Dbio.MasterPricing.FilterValues> _filterValueList = new List <Quest.Services.Dbio.MasterPricing.FilterValues>(); foreach (Quest.Functional.MasterPricing.FilterValue filterValue in filterValueList) { Quest.Services.Dbio.MasterPricing.FilterValues _filterValue = new Quest.Services.Dbio.MasterPricing.FilterValues(); BufferMgr.TransferBuffer(filterValue, _filterValue); _filterValueList.Add(_filterValue); } dbContext.FilterValues.AddRange(_filterValueList); dbContext.SaveChanges(); filterValueIdList = new List <FilterValue>(); foreach (Quest.Services.Dbio.MasterPricing.FilterValues _filterValue in _filterValueList) { Quest.Functional.MasterPricing.FilterValue filterValue = new FilterValue(); filterValue.Id = _filterValue.Id; filterValueIdList.Add(filterValue); } } catch (System.Exception ex) { return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}", this.GetType().Name, MethodBase.GetCurrentMethod().Name, ex.InnerException != null ? ex.InnerException.Message : ex.Message))); } return(new questStatus(Severity.Success)); }
List<FilterValue> _Items; // list of FilterValue public FilterValues(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p) { FilterValue f; _Items = new List<FilterValue>(); // Loop thru all the child nodes foreach(XmlNode xNodeLoop in xNode.ChildNodes) { if (xNodeLoop.NodeType != XmlNodeType.Element) continue; switch (xNodeLoop.Name) { case "FilterValue": f = new FilterValue(r, this, xNodeLoop); break; default: f=null; // don't know what this is // don't know this element - log it OwnerReport.rl.LogError(4, "Unknown FilterValues element '" + xNodeLoop.Name + "' ignored."); break; } if (f != null) _Items.Add(f); } if (_Items.Count == 0) OwnerReport.rl.LogError(8, "For FilterValues at least one FilterValue is required."); else _Items.TrimExcess(); }
protected void gvOrders_HeaderFilterFillItems(object sender, ASPxGridViewHeaderFilterEventArgs e) { if (e.Column.FieldName == "CustomDescription") { List <string> exsistingNewValues = new List <string>(); List <FilterValue> newValues = new List <FilterValue>(); foreach (FilterValue value in e.Values) { string description = value.Value; string[] items = description.Split(';'); foreach (string item in items) { if (!exsistingNewValues.Contains(item)) { exsistingNewValues.Add(item); FilterValue newValue = new FilterValue(); newValue.DisplayText = item.Substring(1, item.Length - 2); newValue.Query = String.Format("Contains([{0}], '{1}')", e.Column.FieldName, item); newValues.Add(newValue); } } } e.Values.Clear(); e.Values.AddRange(newValues); } }
public ActionResult Create(FilterValueViewModel model) { if (ModelState.IsValid) { //_context.dbFilterValue.Add(new FilterValue //{ // Name = model.Name //}); FilterValue categoryValue = new FilterValue() { Name = model.Name }; _context.dbFilterValue.Add(categoryValue); _context.SaveChanges(); _context.dbFilterNameGroups.Add(new FilterNameGroups { FilterNameId = model.NameFilterId, FilterValueId = categoryValue.Id, CategoryId = model.CategoryId }); _context.SaveChanges(); return(RedirectToAction("Index", "FilterValue")); } else { return(View(model)); } }
FilterValue ReadValueFromEnd(int position) { var result = new FilterValue(); while (position >= _bufferLength) { position -= _bufferLength; } while (position < 0) { position += _bufferLength; } int positionFromBufferStartPointer = _bufferTopPointer - position; if (positionFromBufferStartPointer < 0) { positionFromBufferStartPointer += _bufferLength; } result = _buffer[positionFromBufferStartPointer]; return(result); }
public void FindByFilter() { AreaModel match = new AreaModel { Area = "ROM", Value = 200 }; AreaModel noMatch = new AreaModel { Area = "ROM", Value = 100 }; AreaModel extra = new AreaModel { Area = "Mining", Value = 100 }; Repository.Add(match); Repository.Add(noMatch); Repository.Add(extra); Assert.That(Records.Count, Is.EqualTo(3)); IList <AreaModel> models = Repository.FindByFilter(); Assert.That(models, Is.Not.Empty); Assert.That(models.Count, Is.EqualTo(2)); Assert.That(models[0].Area, Is.EqualTo("ROM")); Assert.That(models[1].Area, Is.EqualTo("ROM")); models = Repository.FindByFilter(FilterValue.Parse("Value=100")); Assert.That(models, Is.Not.Empty); Assert.That(models.Count, Is.EqualTo(1)); Assert.That(models[0].Area, Is.EqualTo("ROM")); Assert.That(models[0].Value, Is.EqualTo(100)); }
private FilterValue[] ExtractFilterValues(IEnumerable <IColumn> columns, Type dataModelType) { PropertyInfo[] props = dataModelType .GetProperties(); var result = new FilterValue[props.Count()]; int index = 0; foreach (PropertyInfo prop in props) { object[] attrs = prop.GetCustomAttributes(true); foreach (var attr in attrs) { var dataColumnAttr = attr as CsvHeaderAttribute; if (dataColumnAttr != null) { var filterValue = new FilterValue { Index = columns.First(c => c.Value == dataColumnAttr.ColumnName).Index, PropertyInfo = prop, Type = prop.PropertyType, Label = dataColumnAttr.ColumnName }; result[index++] = filterValue; } } } return(result.OrderBy(x => x.Index).ToArray()); }
public void FilterCollection() { if (FilterValue == null || FilterValue.Equals(default(TInner))) { FilteredCollection.Clear(); return; } foreach (var item in UnfilteredCollection) { if (PassFilterDelegate(item, FilterValue)) { if (!FilteredCollection.Contains(item)) { FilteredCollection.Add(item); } } else { if (FilteredCollection.Contains(item)) { FilteredCollection.Remove(item); } } } }
/// <summary> /// Gets the versions of the model /// </summary> /// <param name="id">The unique identifier.</param> /// <returns></returns> public ModelVersions GetVersions(int id) { IAmplaViewProperties <TModel> amplaViewProperties = GetViewProperties(null); amplaViewProperties.Enforce.CanView(); FilterValue idFilter = new FilterValue("Id", Convert.ToString(id)); FilterValue deletedFilter = new FilterValue("Deleted", ""); GetDataRequest dataRequest = GetDataRequest(false, idFilter, deletedFilter); GetDataResponse dataResponse = webServiceClient.GetData(dataRequest); TModel model; AmplaRecord amplaRecord = FindAmplaRecord(dataResponse, ModelProperties, amplaViewProperties, out model); if (amplaRecord != null) { var request = GetAuditDataRequest(amplaRecord); GetAuditDataResponse response = webServiceClient.GetAuditData(request); List <AmplaAuditRecord> auditRecords = new List <AmplaAuditRecord>(); IAmplaBinding binding = new AmplaGetAuditDataRecordBinding <TModel>(response, amplaRecord, auditRecords, modelProperties); if (binding.Validate() && binding.Bind()) { AmplaAuditRecord auditRecord = auditRecords.Count > 0 ? auditRecords[0] : null; ModelVersions modelVersions = new ModelVersions(amplaRecord); IAmplaBinding historyBinding = new AmplaGetDataVersionsBinding <TModel>(amplaRecord, auditRecord, model, modelVersions, modelProperties, amplaViewProperties); if (historyBinding.Validate() && historyBinding.Bind()) { return(modelVersions); } } } return(null); }
private bool FilterMatches(ScanResults fileProperties) { if (FilterType == YaraFilterType.AlwaysRun) { return(true); } else if (FilterType == YaraFilterType.IsPeFile) { return(fileProperties.IsPe); } else if (FilterType == YaraFilterType.FileExtension) { return(string.Equals(FilterValue.Replace(".", ""), fileProperties.Extension.Replace(".", ""), StringComparison.InvariantCultureIgnoreCase)); } else if (FilterType == YaraFilterType.MimeType) { return(string.Equals(FilterValue, fileProperties.MimeType, StringComparison.InvariantCultureIgnoreCase)); } else if (FilterType == YaraFilterType.ElseNoMatch) { return(false); } else { throw new NotImplementedException($"You must have added a new {nameof(YaraFilterType)} enum without adding the appropriate logic in {nameof(YaraFilter)}.{nameof(FilterMatches)}."); } }
private static BinaryExpression GetExpression <T> (ParameterExpression param, FilterValue filter1, FilterValue filter2) { Expression bin1 = GetExpression <T>(param, filter1); Expression bin2 = GetExpression <T>(param, filter2); return(Expression.AndAlso(bin1, bin2)); }
/// <summary> /// Initialize new <see cref="Setting{T}"/> instance. /// </summary> /// <param name="group">Group for which this setting belongs to.</param> /// <param name="key">Unique key used to identify this setting.</param> /// <param name="defaultValue">Default value of setting which can be restored.</param> /// <param name="filter">Optional delegate which can be used to filter values /// on assignment if specified. It is important to note that default values /// are also filtered on assignment.</param> internal Setting(DynamicSettingGroup group, string key, T defaultValue, FilterValue <T> filter) { this._group = group; this.Key = key; this.DefaultValue = defaultValue; this._filter = filter; }
private object Check <TType, TFilter, TValue>(FilterValue <TType, TFilter, TValue> obj, string parameter) where TType : struct, IComparable, IConvertible where TFilter : struct, IComparable, IConvertible where TValue : struct, IComparable, IConvertible { return(obj.ToString() == parameter ? obj.Value : Binding.DoNothing); }
internal override void Save() { var node = (XmlElement)CreateNode("d:top10"); node.SetAttribute("filterVal", FilterValue.ToString("R15", CultureInfo.InvariantCulture)); node.SetAttribute("percent", Percent ? "1": "0"); node.SetAttribute("top", Top ? "1" : "0"); node.SetAttribute("val", Value.ToString("R15", CultureInfo.InvariantCulture)); }
public override TSource Visit(SingleValuePropertyAccessNode nodeIn) { current.FieldName = nodeIn.Property.Name; //We are finished, add current to collection. filterValueList.Add(current); //Reset current current = new FilterValue(); return(null); }
protected void grid_HeaderFilterFillItems(object sender, ASPxGridViewHeaderFilterEventArgs e) { if (e.Column.FieldName != "CategoryNameNull") { return; } e.Values.Insert(0, FilterValue.CreateShowBlanksValue(e.Column, "Blanks")); e.Values.Insert(1, FilterValue.CreateShowNonBlanksValue(e.Column, "Non Blanks")); }
public CollectionItemVM(FilterDataType dataType, FilterValue value, bool selected) { DataType = dataType; Id = value.Id; ValueName = !value.ValueName.IsNullOrEmtpy() ? value.ValueName : value.Value; Value = value.Value; Selected = selected; }
public UdpFilterViewModel(FilterValue filterValue, FilterFormatType type, string crProcess, DynamicTypeManager theDynamicTypeManager, string name, string crFieldName, FilterList filterList) { if (theDynamicTypeManager == null) { throw new ArgumentNullException("theDynamicTypeManager"); } Name = name; Type = type != null ? GetTypeForView(type.MemberType.Name != "Nullable`1" ? type.MemberType : type.MemberType.GenericTypeArguments[0]) : "Text"; if (crProcess != null) { //Type itemType = theDynamicTypeManager.GetInfoType<IInfoClass>(crProcess); //PropertyInfo guidProperty = itemType.GetPropertyByName("Guid"); // PropertyInfo crFieldProperty = itemType.GetPropertyByName(crFieldName); if (crProcess == Constants.StateProcessName) { Values = theDynamicTypeManager.GetList<IInfoList>(crProcess, string.Empty, 0, int.MaxValue, null, filterList) .Cast<IStateInfo>() .Select(x => new IdValuePair { Id = x.Id.ToString(CultureInfo.InvariantCulture),//guidProperty.With(v => v.GetValue(x)).Return(v => v.ToString(), string.Empty), //Value = crFieldProperty.GetValue(x) Value = x.GetValueByPropertyName(crFieldName) }) .ToList(); } else { Values = theDynamicTypeManager.GetList<IInfoList>(crProcess, string.Empty, 0, int.MaxValue) .Cast<IInfoClass>() .Select(x => new IdValuePair { Id = x.Id.ToString(CultureInfo.InvariantCulture), Value = x.GetValueByPropertyName(crFieldName) }) .ToList(); } } else { if (Type == "Approval") { Values = Enum.GetValues(typeof(ApprovalStates)).Cast<ApprovalStates>().Select(x => new IdValuePair { Id = x.ToString(), Value = x.GetDescription() }).ToList(); } else { Values = null; } } DefaultValue = filterValue != null && filterValue.DefaultValue != null ? Convert.ToString(filterValue.DefaultValue, CultureInfo.InvariantCulture) : string.Empty; }
private static int ApplyFilter(bool isFilterEnabled, FilterType filterType, string columnName, List <string> values, FilterValue[] filters, int filterCount) { if (isFilterEnabled) { filters[filterCount++] = new FilterValue { FilterType = filterType, ColumnName = columnName, Values = values }; } return(filterCount); }
/// <summary> /// Tries the get filter specified /// </summary> /// <typeparam name="TModel">The type of the model.</typeparam> /// <param name="filterValues">The filter values.</param> /// <returns></returns> public static bool TryGetFilter <TModel>(out FilterValue[] filterValues) { AmplaDefaultFiltersAttribute attribute; if (typeof(TModel).TryGetAttribute(out attribute)) { filterValues = attribute.Filters; return(filterValues.Length > 0); } filterValues = new FilterValue[0]; return(false); }
public override Expression <Func <FilledForm, bool> > GetFilterExpression(FilterValue filter) { if (filter is RangeFilterValue) { var rangeFilterValue = filter as RangeFilterValue; int?fromValue = null; int?toValue = null; if (!string.IsNullOrEmpty(rangeFilterValue.FromValue)) { fromValue = Convert.ToInt32(rangeFilterValue.FromValue); } if (!string.IsNullOrEmpty(rangeFilterValue.ToValue)) { toValue = Convert.ToInt32(rangeFilterValue.ToValue); } Expression <Func <FilledForm, bool> > result = null; if (fromValue.HasValue && !toValue.HasValue) { result = f => f.FormValues.Any(v => v.MetricId == this.Id && v.NumericValue >= fromValue.Value); } else if (!fromValue.HasValue && toValue.HasValue) { result = f => f.FormValues.Any(v => v.MetricId == this.Id && v.NumericValue <= toValue.Value); } else if (fromValue.HasValue && toValue.HasValue) { result = f => f.FormValues.Any(v => v.MetricId == this.Id && v.NumericValue >= fromValue.Value && v.NumericValue <= toValue.Value); } return(result); } if (filter is MultipleFilterValue) { var multipleFilterValue = filter as MultipleFilterValue; var values = new List <double?>(); foreach (var item in multipleFilterValue.Values) { values.Add(Convert.ToDouble(item)); } Expression <Func <FilledForm, bool> > result = f => f.FormValues.Any(v => v.MetricId == this.Id && values.Contains(v.NumericValue)); return(result); } throw new InvalidOperationException("FilterValue could not be cast! invalid value."); }
public override Expression <Func <FilledForm, bool> > GetFilterExpression(FilterValue filterValue) { var singleValue = filterValue as SingleFilterValue; var value = singleValue.Value; var punctuation = value.Where(Char.IsPunctuation).Distinct().ToArray(); var words = value.Split().Select(x => x.Trim(punctuation)); Expression <Func <FilledForm, bool> > result = (FilledForm f) => f.FormValues.Any(v => v.MetricId == this.Id && words.Any(w => v.TextValue.Contains(w))); return(result); }
private void SetFilter(FilterTypes type, object filter, bool value) { switch (type) { case FilterTypes.Level: FilterLevel = new FilterValue <FilterTypes, LevelValues, bool>(type, (LevelValues)filter, value); break; case FilterTypes.Highlight: FilterHighlighted = new FilterValue <FilterTypes, int, bool>(type, Convert.ToInt32(filter), value); break; } }
public ArrayList GetFilterArrays(Type fieldType) { string[] spValues = FilterValue.Split((",").ToCharArray()); ArrayList al = new ArrayList(); foreach (string spValue in spValues) { al.Add(Convert.ChangeType(spValue, fieldType)); } return(al); }
public static FilterValueResult ToAggregate(this FilterValue filter) { if (filter == null) { throw new ArgumentNullException(nameof(filter)); } return(new FilterValueResult { Id = filter.Id, Content = filter.Content }); }
public static List<int> FilterCollection(List<int> list, FilterValue filter) { List<int> result = new List<int>(); foreach (var item in list) { if (filter(item)) { result.Add(item); } } return result; }
/// <summary> /// Finds the record. /// </summary> /// <param name="id"></param> /// <returns></returns> public AmplaRecord FindRecord(int id) { IAmplaViewProperties <TModel> amplaViewProperties = GetViewProperties(null); amplaViewProperties.Enforce.CanView(); FilterValue idFilter = new FilterValue("Id", Convert.ToString(id)); FilterValue deletedFilter = new FilterValue("Deleted", ""); var request = GetDataRequest(true, idFilter, deletedFilter); GetDataResponse response = webServiceClient.GetData(request); TModel model; return(FindAmplaRecord(response, ModelProperties, amplaViewProperties, out model)); }
public questStatus Update(DbMgrTransaction trans, FilterValue filterValue) { // Initialize questStatus status = null; // Update filterValue status = _dbFilterValuesMgr.Update(trans, filterValue); if (!questStatusDef.IsSuccess(status)) { return(status); } return(new questStatus(Severity.Success)); }
public override Expression <Func <FilledForm, bool> > GetFilterExpression(FilterValue filter) { var multipleFilterValue = filter as MultipleFilterValue; var values = new List <bool?>(); foreach (var item in multipleFilterValue.Values) { var value = Convert.ToInt32(item); values.Add(Convert.ToBoolean(value)); } Expression <Func <FilledForm, bool> > result = f => f.FormValues.Any(v => v.MetricId == this.Id && values.Contains(v.BoolValue)); return(result); }
protected virtual IEnumerable <TItem> FilterItems(IEnumerable <TItem> items) { if (FilterValue == null || (FilterValue as string) == "") { return(items); } var key = FilterValue.ToString(); return(items.Where(x => { var itemKey = ((dynamic)x)[FilterField] ?? ReflectionUtils.GetPropertyValue(x, FilterField); return itemKey != null && ((object)itemKey).ToString() == key; })); }
public StringBuilder TheValues(FilterValue filterValue, int nr) { StringBuilder query = new StringBuilder(); if (filterValue.Filter.Group.ParentGroup == 0) { query.AppendFormat(" G{0}.{1} = '{2}'", nr, filterValue.FilterValueName, filterValue.Value); } else { query.AppendFormat(" G{0}.{1} = '{2}'", nr, filterValue.Filter.FilterName, filterValue.FilterValueName); } return(query); }
public void FilterOptionsCommandShouldUpdatProcessFieldAfterPopupIsClosed() { var filter = Mock.Create<IFilterDescriptor>(Behavior.Loose); var stepEdit = DisplayListRequiredStepEdit.NewStep(1); stepEdit.SelectedFields = new DisplayListStepFields(); var processFieldViewModel = new ProcessFieldViewModel(new FieldEdit(), new ProcessSectionViewModel(Mock.Create<ISectionEdit>())); var vm = new ProcessFieldDisplayListRequiredStepViewModel(stepEdit, new StepInfo(1), processFieldViewModel); Mock.Arrange(() => vm.GetProcessedFilter()).IgnoreInstance().Returns(Mock.Create<IFilterDescriptor>()); var processEdit = Mock.Create<ProcessEdit>(Behavior.Loose); var fieldsViewModel = new ProcessFieldsViewModel { Model = processEdit }; vm.Model = fieldsViewModel; var popupFactory = Mock.Create<PopupFactory>(Behavior.Loose); var popupBuilder = Mock.Create<PopupBuilder>(Behavior.CallOriginal); Mock.Arrange(() => popupFactory.Popup()).Returns(popupBuilder); Mock.Arrange(() => popupBuilder.Show(Arg.IsAny<Action>(), Arg.IsAny<Func<bool>>())).DoInstead((Action ok, Action cancel) => ok()); vm.ThePopupFactory = popupFactory; var filterOptions = Mock.Create<FilterOptionsViewModel>(Behavior.Loose); vm.FilterOptionsVM = new Lazy<FilterOptionsViewModel>(() => filterOptions); var procField = new ProcessField("test", "test"); filterOptions.IsProcessField = true; filterOptions.SelectedProcessField = procField; var filterValue = new FilterValue { Type = FilterValueType.ProcessField }; Mock.Arrange(() => filter.Value).Returns(filterValue); vm.FilterOptionsCommand.Execute(filter); Assert.AreEqual("FLD: test", filterValue.ProvidedValue.ToString()); Mock.Arrange(() => filter.Value).Returns((FilterValue)null); vm.FilterOptionsCommand.Execute(filter); Mock.AssertSet(() => filter.Value = Arg.IsAny<FilterValue>()); }
private FilterParameterMetadata CreateReverseCrossReferenceParameter( FilterValue filterValue, ReverseCrossReferenceFieldMetadata field, bool includeValues) { var parameter = CreateGenericParameter(filterValue, field); if (includeValues) { parameter.Values.AddRange(FilteringUtils.GetReverseCrossReferenceFieldValues(field)); parameter.ValuesSpecified = true; } return parameter; }
private FilterParameterMetadata CreateParameterMetadata(IProcessMetadata process, FilterValue filterValue, bool includeParameterValues) { if (process.SupportsStates && IsCurrentStateFilter(filterValue)) { return CreateCurrentStateParameter(filterValue, process, includeParameterValues); } var field = FilteringUtils.FindProcessField(process, filterValue.SystemName); return field != null ? CreateParameter(filterValue, field, includeParameterValues) : CreateParameter(filterValue); }
private static FilterParameterMetadata CreateParameter(FilterValue filterValue) { return new FilterParameterMetadata { Name = filterValue.SystemName, DisplayName = filterValue.DisplayName, DefaultValue = filterValue.DefaultValue, DataType = FilterDataType.String }; }
private bool IsCurrentStateFilter(FilterValue filterValue) { var fieldName = filterValue.SystemName; return FilteringUtils.IsCurrentState(fieldName); }
private FilterParameterMetadata CreateParameter(FilterValue filterValue, IFieldMetadata field, bool includeValues) { switch (field.ColumnType) { case ColumnTypes.Approval: return CreateApprovalParameter(filterValue, field, includeValues); case ColumnTypes.DateTime: return CreateDateTimeParameter(filterValue, (DateTimeFieldMetadata)field); case ColumnTypes.Reference: case ColumnTypes.MultiReference: return CreateCrossReferenceParameter(filterValue, (CrossReferenceFieldMetadata)field, includeValues); case ColumnTypes.ReverseReference: case ColumnTypes.ReverseMultiReference: return CreateReverseCrossReferenceParameter(filterValue, (ReverseCrossReferenceFieldMetadata)field, includeValues); default: return CreateGenericParameter(filterValue, field); } }
private FilterParameterMetadata CreateCurrentStateParameter(FilterValue filterValue, IProcessMetadata process, bool includeValues) { var parameter = new FilterParameterMetadata { Name = filterValue.SystemName, DisplayName = filterValue.DisplayName, DefaultValue = filterValue.DefaultValue, DataType = FilterDataType.State }; if (includeValues) { parameter.Values.AddRange( filterValue.SystemName == Constants.CurrentStateGuidColumnName ? FilteringUtils.GetCurrentStateGuidValues(process) : FilteringUtils.GetCurrentStateIdValues(process)); parameter.ValuesSpecified = true; } return parameter; }
private static FilterParameterMetadata CreateGenericParameter(FilterValue filterValue, IFieldMetadata field) { return new FilterParameterMetadata { Name = filterValue.SystemName, DisplayName = filterValue.DisplayName, DefaultValue = filterValue.DefaultValue, DataType = GetDataType(field.ColumnType) }; }
private FilterParameterMetadata CreateApprovalParameter(FilterValue filterValue, IFieldMetadata field, bool includeValues) { var parameter = CreateGenericParameter(filterValue, field); if (includeValues) { parameter.Values.AddRange(FilteringUtils.GetApprovalFieldValues()); parameter.ValuesSpecified = true; } return parameter; }
private FilterParameterMetadata CreateDateTimeParameter(FilterValue filterValue, DateTimeFieldMetadata field) { var parameter = CreateGenericParameter(filterValue, field); parameter.DateTimeFormat = field.DateTimeFormat; return parameter; }
private static void Static(WeakEventListener<ProcessMetricsGadgetViewModel, FilterValue, PropertyChangedEventArgs> listener, FilterValue source) { source.PropertyChanged -= listener.OnEvent; }