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