internal static bool IsQualifierValidForField(ICursorFilter filter) { switch (filter.GetType()) { case ICursorFilterTypeF f: return(false); case ICursorFilterTypeCTCF ctcf: return(false); } return(false); }
private CursorFilterTypeCTI ConstructCTIFilter(ICursorFilter filter, FilterControlModel m) { var f = (CursorFilterTypeCTI)filter; f.ClauseNumber = m.ClauseNumber; f.Except = m.Except; f.ClarifySeparator = _model.CurrentConnectedItem?.ClarifySeparator; f.ClarifyValue = _model.CurrentConnectedItem?.ClarifyValue; f.Connection = m.CurrentFieldListItem.ConnectionName; f.Category = m.CurrentFieldListItem.ToCategory; f.Item = m.CurrentConnectedItem?.ItemName; return(f); }
private static string FormatCTIFilterRaw(ICursorFilter filter) { ICursorFilterTypeCTI f = (CursorFilterTypeCTI)filter; StringBuilder sb = new StringBuilder("[ViewFilter("); sb.Append(f.ClauseNumber.ToString()); sb.Append(','); sb.Append(f.FiltertypeIdentifier); sb.Append(','); sb.Append(f.Except ? "NOT," : ","); sb.Append(f.Connection); sb.Append(','); sb.Append(f.Category); sb.Append(','); sb.Append(GetClarifiedItemName(f.Item, f.ClarifySeparator, f.ClarifyValue)); sb.Append(")]"); return(sb.ToString()); }
private static string FormatCTCFFilterRaw(ICursorFilter filter) { ICursorFilterTypeCTCF f = (CursorFilterTypeCTCF)filter; StringBuilder sb = new StringBuilder("[ViewFilter("); sb.Append(f.ClauseNumber.ToString()); sb.Append(','); sb.Append(f.FiltertypeIdentifier); sb.Append(','); sb.Append(f.Except ? "NOT," : ","); sb.Append(f.Connection); sb.Append(','); sb.Append(f.Category); sb.Append(','); if (f.SharedOptionSet) { sb.Append(','); sb.Append((f.Shared) ? "Shared" : "Local"); sb.Append(",,"); // two! } else { sb.Append(f.FieldName); sb.Append(','); sb.Append(f.QualifierString); sb.Append(','); if (f.Qualifier == FilterQualifier.Between) // TODO code smell, this value may not be set by COM clients { sb.Append(f.FilterBetweenStartValue); sb.Append(','); sb.Append(f.FilterBetweenEndValue); } else { sb.Append(f.FieldValue); sb.Append(','); sb.Append((f.MatchCase) ? "1" : "0"); } } sb.Append(")]"); return(sb.ToString()); }
private CursorFilterTypeF ConstructFFilter(ICursorFilter filter, FilterControlModel m) { var f = (CursorFilterTypeF)filter; f.ClauseNumber = m.ClauseNumber; f.MatchCase = m.MatchCase; f.Except = m.Except; f.FieldName = m.CurrentFieldListItem.FieldName; f.Qualifier = m.SelectedFilterQualifier; if (m.SelectedFilterQualifier == FilterQualifier.Between) { f.FilterBetweenStartValue = m.BetweenStart; f.FilterBetweenEndValue = m.BetweenEnd; } if (m.SelectedFilterQualifier.GetAttribute <FilterValuesAttribute>()?.Number == 1) { f.FieldValue = m.FieldValue; } return(f); }
internal static string ToString(ICursorFilter filter, FilterOutputFormat format) { switch (format) { // raw means just add quotes around the whole thing so it can at least be copy/pasted or inserted without syntax error case FilterOutputFormat.Raw: var d = GetDelegate(filter.FiltertypeIdentifier); if (d != null) { return(string.Format("\"{0}\"", filter.ToString(d))); } else { return("Unknown filtertype"); } default: return(filter.ToString()); } }
// TODO this is very fishy. // In effect we now have a custom class that responds to UI changes // The underlying idea is that filters will update automagically, // at least I think that that is the general idea // I am pretty convinced now it is a BAD idea // we should leave this kind of model-changing stuff to the model private void Model_PropertyChanged(object sender, PropertyChangedEventArgs e) { // do not update properties that we update ourselves // this code will not win prizes :) if (e.PropertyName.Equals(nameof(_model.CurrentFilter)) || e.PropertyName.Equals(nameof(_model.IsValid))) { return; } // we want to update the filter according to its type switch (_filter) { case CursorFilterTypeF _filter: _filter = ConstructFFilter(_filter, _model); break; case CursorFilterTypeCTI _filter: _filter = ConstructCTIFilter(_filter, _model); break; case CursorFilterTypeCTCF _filter: _filter = ConstructCTCFFilter(_filter, _model); break; case CursorFilterTypeCTCTI _filter: _filter = ConstructCTCTIFilter(_filter, _model); break; } _model.CurrentFilter = _filter; // pass back the updated filter to the model. BAD IDEA FilterValidator fv = new FilterValidator(_filter); _model.IsValid = fv.Validate(); // ALSO BAD IDEA // here would be a place we can put in our FilterString builder so the // textbox would not have to pass a control to ConverterParam, // but instead just be bound to a property }
// TODO this is very fishy. // In effect we now have a custom class that responds to UI changes // The underlying idea is that filters will update automagically, // at least I think that that is the general idea // I am pretty convinced now it is a BAD idea // we should leave this kind of model-changing stuff to the model private void Model_PropertyChanged(object sender, PropertyChangedEventArgs e) { // do not update properties that we update ourselves // this code will not win prizes :) if (e.PropertyName.Equals(nameof(_model.CurrentFilter)) || // not needed e.PropertyName.Equals(nameof(_model.FilterString)) || e.PropertyName.Equals(nameof(_model.IsValid))) { return; } // we want to update the filter according to its type switch (_filter) { case CursorFilterTypeF _filter: _filter = ConstructFFilter(_filter, _model); break; case CursorFilterTypeCTI _filter: _filter = ConstructCTIFilter(_filter, _model); break; case CursorFilterTypeCTCF _filter: _filter = ConstructCTCFFilter(_filter, _model); break; case CursorFilterTypeCTCTI _filter: _filter = ConstructCTCTIFilter(_filter, _model); break; } _model.CurrentFilter = _filter; // pass back the updated filter to the model. FilterValidator fv = new FilterValidator(_filter); _model.IsValid = fv.Validate(); _model.FilterString = FilterStringCreator.ToString(_filter, _model.OutputFormat); }
protected override void ProcessRecord() { ICursorFilter filter = null; if (F.IsPresent) { var f = new CursorFilterTypeF(clauseNumber) { FieldName = fieldName, Qualifier = qualifier, MatchCase = matchCase }; if (qualifier == FilterQualifier.Between) { f.FilterBetweenStartValue = fieldValue; f.FilterBetweenEndValue = fieldValue2; } if (qualifier.GetAttribute <FilterValuesAttribute>()?.Number == 1) { f.FieldValue = fieldValue; } filter = f; } if (CTI.IsPresent) { var cti = new CursorFilterTypeCTI(clauseNumber) { Connection = connection, Category = categoryName, Item = item }; filter = cti; } if ((CTCF.IsPresent)) { var ctcf = new CursorFilterTypeCTCF(clauseNumber) { Connection = connection, Category = categoryName, FieldName = fieldName, Qualifier = qualifier, MatchCase = matchCase }; if (qualifier == FilterQualifier.Between) { ctcf.FilterBetweenStartValue = fieldValue; ctcf.FilterBetweenEndValue = fieldValue2; } if (qualifier.GetAttribute <FilterValuesAttribute>()?.Number == 1) { ctcf.FieldValue = fieldValue; } filter = ctcf; } if (CTCTI.IsPresent) { ICursorFilterTypeCTCTI ctcti = new CursorFilterTypeCTCTI(clauseNumber) { Connection = connection, Category = categoryName, Connection2 = connection2, Category2 = toCategoryName2, Item = item }; filter = ctcti; } filter.Except = except; filter.OrFilter = orFilter; WriteVerbose($"Resulting filterstring is: {filter}, conjunction is: [{(filter.OrFilter ? "OR" : "AND")}]"); WriteObject(filter, false); }
internal FilterConstructor(FilterControlModel model, FilterType filterType) { _model = model; _model.PropertyChanged += Model_PropertyChanged; _filter = CreateFilter(_model.CategoryName, filterType); }
public FilterValidator(ICursorFilter filter) { _filter = filter; }