/// <summary>
/// Get criteria(in string) from Numeric Evaluator
/// </summary>
/// <param name="fsre">String Evaluator used to retrieve the criteria.</param>
/// <param name="inverted">Indicates whether rule to which Evaluator belong is inverse rule.
/// If inverted is true, inverse criteria for this evaluator will be returned. </param>
/// <returns>criteria of this Evaluator.</returns>
static string GetEvaluatorCriteriaName(FilterNumericRuleEvaluator fsre, bool inverted)
{
// indicate if inverse criteria should be returned
bool isInverseRule = inverted;
if (fsre is FilterNumericEquals)
{
return(isInverseRule ? RuleCriteraNames.NotEquals : RuleCriteraNames.Equals_);
}
else if (fsre is FilterNumericGreater)
{
return(isInverseRule ? RuleCriteraNames.LessOrEqual : RuleCriteraNames.Greater);
}
else if (fsre is FilterNumericGreaterOrEqual)
{
return(isInverseRule ? RuleCriteraNames.Less : RuleCriteraNames.GreaterOrEqual);
}
else if (fsre is FilterNumericLess)
{
return(isInverseRule ? RuleCriteraNames.GreaterOrEqual : RuleCriteraNames.Less);
}
else if (fsre is FilterNumericLessOrEqual)
{
return(isInverseRule ? RuleCriteraNames.Greater : RuleCriteraNames.LessOrEqual);
}
else
{
return(RuleCriteraNames.Invalid);
}
}
/// <summary>
/// Convert FilterRule to our custom FilterRuleBuilder which will be displayed in form controls
/// </summary>
/// <param name="param">Parameter to which the FilterRule is applied.</param>
/// <param name="rule">FilterRule to be converted.</param>
/// <returns>Custom FilterRuleBuilder data converted from FilterRule</returns>
public static FilterRuleBuilder CreateFilterRuleBuilder(BuiltInParameter param, FilterRule rule)
{
// Maybe FilterRule is inverse rule, we need to find its inner rule(FilterValueRule)
// Note that the rule may be inversed more than once.
bool inverted = false;
FilterRule innerRule = ReflectToInnerRule(rule, out inverted);
if (innerRule is FilterStringRule)
{
FilterStringRule strRule = innerRule as FilterStringRule;
FilterStringRuleEvaluator evaluator = strRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), strRule.RuleString, strRule.RuleString.ToLower() == strRule.RuleString ? false : true));
}
else if (innerRule is FilterDoubleRule)
{
FilterDoubleRule dbRule = innerRule as FilterDoubleRule;
FilterNumericRuleEvaluator evaluator = dbRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), dbRule.RuleValue, dbRule.Epsilon));
}
else if (innerRule is FilterIntegerRule)
{
FilterIntegerRule intRule = innerRule as FilterIntegerRule;
FilterNumericRuleEvaluator evaluator = intRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), intRule.RuleValue));
}
else if (innerRule is FilterElementIdRule)
{
FilterElementIdRule idRule = innerRule as FilterElementIdRule;
FilterNumericRuleEvaluator evaluator = idRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), idRule.RuleValue));
}
//
// for other rule, not supported yet
throw new System.NotImplementedException("The filter rule is not recognizable and supported yet!");
}
protected override void SolveInstance(IGH_DataAccess DA)
{
var parameterId = ElementId.InvalidElementId;
if (!DA.GetData("ParameterKey", ref parameterId))
{
return;
}
DA.DisableGapLogic();
if (!TryGetParameterDefinition(Revit.ActiveDBDocument, parameterId, out var storageType, out var parameterType))
{
if (parameterId.TryGetBuiltInParameter(out var builtInParameter))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{LabelUtils.GetLabelFor(builtInParameter)}' in Revit document.");
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{parameterId.IntegerValue}' in Revit document.");
}
return;
}
var provider = new ParameterValueProvider(parameterId);
Autodesk.Revit.DB.FilterRule rule = null;
if (storageType == StorageType.String)
{
FilterStringRuleEvaluator ruleEvaluator = null;
switch (Condition)
{
case ConditionType.NotEquals:
case ConditionType.Equals: ruleEvaluator = new FilterStringEquals(); break;
case ConditionType.Greater: ruleEvaluator = new FilterStringGreater(); break;
case ConditionType.GreaterOrEqual: ruleEvaluator = new FilterStringGreaterOrEqual(); break;
case ConditionType.Less: ruleEvaluator = new FilterStringLess(); break;
case ConditionType.LessOrEqual: ruleEvaluator = new FilterStringLessOrEqual(); break;
}
var goo = default(GH_String);
if (DA.GetData("Value", ref goo))
{
rule = new FilterStringRule(provider, ruleEvaluator, goo.Value, true);
}
}
else
{
FilterNumericRuleEvaluator ruleEvaluator = null;
switch (Condition)
{
case ConditionType.NotEquals:
case ConditionType.Equals: ruleEvaluator = new FilterNumericEquals(); break;
case ConditionType.Greater: ruleEvaluator = new FilterNumericGreater(); break;
case ConditionType.GreaterOrEqual: ruleEvaluator = new FilterNumericGreaterOrEqual(); break;
case ConditionType.Less: ruleEvaluator = new FilterNumericLess(); break;
case ConditionType.LessOrEqual: ruleEvaluator = new FilterNumericLessOrEqual(); break;
}
switch (storageType)
{
case StorageType.Integer:
{
var goo = default(GH_Integer);
if (DA.GetData("Value", ref goo))
{
rule = new FilterIntegerRule(provider, ruleEvaluator, goo.Value);
}
}
break;
case StorageType.Double:
{
var goo = default(GH_Number);
if (DA.GetData("Value", ref goo))
{
if (Condition == ConditionType.Equals || Condition == ConditionType.NotEquals)
{
if (parameterType == ParameterType.Length || parameterType == ParameterType.Area || parameterType == ParameterType.Volume)
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), ToHost(Revit.VertexTolerance, parameterType));
}
else
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 1e-6);
}
}
else
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 0.0);
}
}
}
break;
case StorageType.ElementId:
{
switch (parameterType)
{
case (ParameterType)int.MaxValue: // Category
{
var value = default(Types.Category);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
case ParameterType.FamilyType:
{
var value = default(Types.ElementType);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
default:
{
var value = default(Types.Element);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
}
}
break;
}
}
if (rule is object)
{
if (Condition == ConditionType.NotEquals)
{
DA.SetData("Rule", new FilterInverseRule(rule));
}
else
{
DA.SetData("Rule", rule);
}
}
}
public static ElementFilter createParameterFilter(Document doc, ParameterData parameter, string operation, string ruleString)
{
ElementId parameterId = parameter.Id;
ParameterValueProvider fvp = new ParameterValueProvider(parameterId);
StorageType storageType = parameter.StorageType;
FilterRule fRule = null;
FilterInverseRule fInvRule = null;
ElementParameterFilter filter = null;
switch (storageType)
{
case StorageType.String:
case StorageType.Integer:
FilterStringRuleEvaluator fsre = null;
switch (operation)
{
case "равно":
fsre = new FilterStringEquals();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fsre = new FilterStringEquals();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "содержит":
fsre = new FilterStringContains();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не содержит":
fsre = new FilterStringContains();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "начинается с":
fsre = new FilterStringBeginsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не начинается с":
fsre = new FilterStringBeginsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "заканчивается на":
fsre = new FilterStringEndsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не заканчивается на":
fsre = new FilterStringEndsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
}
break;
case StorageType.Double:
FilterNumericRuleEvaluator fnre = null;
double ruleValue = Convert.ToDouble(ruleString);
switch (operation)
{
case "равно":
fnre = new FilterNumericEquals();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fnre = new FilterNumericEquals();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "больше":
fnre = new FilterNumericGreater();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "больше или равно":
fnre = new FilterNumericGreaterOrEqual();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "меньше":
fnre = new FilterNumericLess();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "меньше или равно":
fnre = new FilterNumericLessOrEqual();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
}
break;
case StorageType.ElementId:
var levels = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Levels).ToElements();
var level = levels.Where(i => i.Name == ruleString).FirstOrDefault();
ElementId ruleId = level.Id;
fnre = null;
switch (operation)
{
case "равно":
fnre = new FilterNumericEquals();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fnre = new FilterNumericEquals();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "выше":
fnre = new FilterNumericGreater();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ровно или выше":
fnre = new FilterNumericGreaterOrEqual();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ниже":
fnre = new FilterNumericLess();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ровно или ниже":
fnre = new FilterNumericLessOrEqual();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
}
break;
}
return(filter);
}
//Private Method
private static string CastFilterRule(FilterRule r)
{
if (r is FilterStringRule)
{
FilterStringRule filterRule = r as FilterStringRule;
FilterStringRuleEvaluator evaluator = filterRule.GetEvaluator();
if (filterRule.GetEvaluator() is FilterStringBeginsWith)
{
return("FilterStringBeginsWith");
}
else if (filterRule.GetEvaluator() is FilterStringContains)
{
return("FilterStringContains");
}
else if (filterRule.GetEvaluator() is FilterStringEndsWith)
{
return("FilterStringEndsWith");
}
else if (filterRule.GetEvaluator() is FilterStringEquals)
{
return("FilterStringEquals");
}
else if (filterRule.GetEvaluator() is FilterStringGreaterOrEqual)
{
return("FilterStringGreaterOrEqual");
}
else if (filterRule.GetEvaluator() is FilterStringLess)
{
return("FilterStringLess");
}
else if (filterRule.GetEvaluator() is FilterStringLessOrEqual)
{
return("FilterStringLessOrEqual");
}
}
else if (r is FilterIntegerRule || r is FilterDoubleRule || r is FilterGlobalParameterAssociationRule)
{
FilterIntegerRule filterRule = r as FilterIntegerRule;
FilterNumericRuleEvaluator evaluator = filterRule.GetEvaluator();
if (filterRule.GetEvaluator() is FilterNumericEquals)
{
return("FilterNumericEquals");
}
else if (filterRule.GetEvaluator() is FilterNumericGreater)
{
return("FilterNumericGreater");
}
else if (filterRule.GetEvaluator() is FilterNumericGreaterOrEqual)
{
return("FilterNumericGreaterOrEqual");
}
else if (filterRule.GetEvaluator() is FilterNumericLess)
{
return("FilterNumericLess");
}
else if (filterRule.GetEvaluator() is FilterNumericLessOrEqual)
{
return("FilterNumericLessOrEqual");
}
}
else if (r is FilterInverseRule)
{
FilterInverseRule filterRule = r as FilterInverseRule;
FilterRule innerRule = filterRule.GetInnerRule();
return(CastFilterRule(innerRule) + "_InnerRule");
}
else if (r is SharedParameterApplicableRule)
{
return("SharedParameterApplicableRule");
}
;
return(null);
}
private ElementFilter CreateParamFilter(int paramId, string strOperator, string paramValue, bool emptyValue)
{
try
{
ParameterProperties pp = selectedParameters[paramId];
ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(pp.ParamId));
switch (pp.ParamStorageType)
{
case StorageType.ElementId:
if (pp.ParamName == "Phase Created" || pp.ParamName == "Phase Demolished")
{
FilterNumericRuleEvaluator fnre1 = new FilterNumericEquals();
var phaseId = from phase in phases where phase.Value.Name == paramValue select phase.Key;
int pId = phaseId.First();
ElementId ruleValId = new ElementId(pId);
FilterRule filterRule1 = new FilterElementIdRule(pvp, fnre1, ruleValId);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule1, true));
}
else
{
return(new ElementParameterFilter(filterRule1));
}
}
return(null);
case StorageType.Double:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterDoubleRule doubleRule = new FilterDoubleRule(pvp, fnre, 0, double.Epsilon);
return(new ElementParameterFilter(doubleRule, true));
}
FilterNumericRuleEvaluator fnre2 = FindFilterNumericRuleEvaluator(strOperator);
double dblValue = 0;
if (!string.IsNullOrEmpty(paramValue))
{
double.TryParse(paramValue, out dblValue);
}
FilterRule filterRule2 = new FilterDoubleRule(pvp, fnre2, dblValue, double.Epsilon);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule2, true));
}
else
{
return(new ElementParameterFilter(filterRule2));
}
case StorageType.Integer:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterIntegerRule integerRule = new FilterIntegerRule(pvp, fnre, 0);
return(new ElementParameterFilter(integerRule, true));
}
FilterNumericRuleEvaluator fnre3 = FindFilterNumericRuleEvaluator(strOperator);
int intValue = 0;
if (pp.ParamName == "Workset")
{
var worksetId = from ws in worksets where ws.Value.Name == paramValue select ws.Key;
intValue = worksetId.First();
}
else if (!string.IsNullOrEmpty(paramValue))
{
int.TryParse(paramValue, out intValue);
}
FilterRule filterRule3 = new FilterIntegerRule(pvp, fnre3, intValue);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule3, true));
}
else
{
return(new ElementParameterFilter(filterRule3));
}
case StorageType.String:
if (emptyValue)
{
FilterStringRuleEvaluator fsre = new FilterStringGreater();
FilterStringRule stringRule = new FilterStringRule(pvp, fsre, "", false);
return(new ElementParameterFilter(stringRule, true));
}
FilterStringRuleEvaluator fnre4 = FindFilterStringRuleEvaluator(strOperator);
string strValue = paramValue;
FilterStringRule filterRule4 = new FilterStringRule(pvp, fnre4, strValue, false);
if (strOperator.Contains("does not"))
{
return(new ElementParameterFilter(filterRule4, true));
}
else
{
return(new ElementParameterFilter(filterRule4, false));
}
default:
return(null);
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to create parameter filters.\n" + ex.Message, "CreateParamFilter", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(null);
}
/// <summary>
/// Get criteria(in string) from Numeric Evaluator
/// </summary>
/// <param name="fsre">String Evaluator used to retrieve the criteria.</param>
/// <param name="inverted">Indicates whether rule to which Evaluator belong is inverse rule.
/// If inverted is true, inverse criteria for this evaluator will be returned. </param>
/// <returns>criteria of this Evaluator.</returns>
static string GetEvaluatorCriteriaName(FilterNumericRuleEvaluator fsre, bool inverted)
{
// indicate if inverse criteria should be returned
bool isInverseRule = inverted;
if (fsre is FilterNumericEquals)
return (isInverseRule ? RuleCriteraNames.NotEquals: RuleCriteraNames.Equals_);
else if (fsre is FilterNumericGreater)
return (isInverseRule ? RuleCriteraNames.LessOrEqual: RuleCriteraNames.Greater);
else if (fsre is FilterNumericGreaterOrEqual)
return (isInverseRule ? RuleCriteraNames.Less: RuleCriteraNames.GreaterOrEqual);
else if (fsre is FilterNumericLess)
return (isInverseRule ? RuleCriteraNames.GreaterOrEqual: RuleCriteraNames.Less);
else if (fsre is FilterNumericLessOrEqual)
return (isInverseRule ? RuleCriteraNames.Greater: RuleCriteraNames.LessOrEqual);
else
return RuleCriteraNames.Invalid;
}
