public Rule AddValueTypeRule(ValueTypeEnum typeEnum)
{
ValueTypeRule rule = new ValueTypeRule(ValueTypeEnumHelper.ToValue(typeEnum));
this.Add(rule);
return(rule);
}
public virtual TResult Visit(ValueTypeRule expression, TEnvironment environment)
{
expression.ValueType.Accept(this, environment);
expression.Properties.ForEach(x => x.Accept(this, environment));
expression.Widget.Accept(this, environment);
return(default(TResult));
}
public virtual TResult Visit(ValueTypeRule rule, TEnvironment environment)
{
rule.ValueType.Accept(this, environment);
rule.Properties?.ForEach(x => x.Accept(this, environment));
rule.Widget?.Accept(this, environment);
return(default(TResult));
}
private StyleSheet GetStyleSheetWrapper(ValueTypeRule rule)
{
return(new StyleSheet("SampleStyleShett", new List <Page>
{
new Page("SamplePage", null, new List <ValueTypeRule> {
rule
})
}));
}
public Rule AddValueTypeRule(string valueType)
{
if (string.IsNullOrEmpty(valueType))
{
return(null);
}
ValueTypeRule rule = new ValueTypeRule(valueType);
this.Add(rule);
return(rule);
}
public void Analyze_ShouldDetectErrorIfInvalidValueTypeRuleIsGiven(
Widget widget,
IList <ValueType> invalidTypes)
{
const string sampleQuestionName = "SampleQuestion";
foreach (var invalidType in invalidTypes)
{
var typeAnamyzer = new TypeAnalyzer();
var sampleQuestionMapings = new Dictionary <string, ValueType>
{
{ sampleQuestionName, invalidType }
};
var valueTypeRule = new ValueTypeRule(invalidType, widget, null);
typeAnamyzer.Analyze(this.GetStyleSheetWrapper(valueTypeRule), sampleQuestionMapings);
Assert.NotEmpty(typeAnamyzer.Report.AllMessages);
Assert.IsType <InvalidWidgetTypeMessage>(typeAnamyzer.Report.Errors.FirstOrDefault());
Assert.Equal(1, typeAnamyzer.Report.AllMessages.Count());
}
}
public override object Visit(ValueTypeRule rule, ITypeAnalyzerEnvironment environment)
{
this.CheckWidgetTyping(rule.Widget, rule.ValueType, environment);
return(base.Visit(rule, environment));
}
public static Rule CreateRule(RuleTypeEnum ruleType)
{
Rule rule = null;
switch (ruleType)
{
case RuleTypeEnum.MAX_LENGTH_RULE:
rule = new MaxLengthRule();
break;
case RuleTypeEnum.MIN_LENGTH_RULE:
rule = new MinLengthRule();
break;
case RuleTypeEnum.MAX_VALUE_RULE:
rule = new MaxValueRule();
break;
case RuleTypeEnum.MIN_VALUE_RULE:
rule = new MinValueRule();
break;
case RuleTypeEnum.MAX_INPUT_NUM_RULE:
rule = new MaxInputNumRule();
break;
case RuleTypeEnum.MIN_INPUT_NUM_RULE:
rule = new MinInputNumRule();
break;
case RuleTypeEnum.VALUE_TYPE_RULE:
rule = new ValueTypeRule();
break;
case RuleTypeEnum.REQUIRED_RULE:
rule = new RequiredRule();
break;
case RuleTypeEnum.DISABLE_RULE:
rule = new DisableRule();
break;
case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE:
rule = new MaxDecimalDigitsRule();
break;
case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE:
rule = new MinDecimalDigitsRule();
break;
case RuleTypeEnum.REGEX_RULE:
rule = new RegexRule();
break;
case RuleTypeEnum.SET_RULE:
rule = new SetRule();
break;
case RuleTypeEnum.TIP_RULE:
rule = new TipRule();
break;
case RuleTypeEnum.DEV_TIP_RULE:
rule = new DevTipRule();
break;
case RuleTypeEnum.READ_ONLY_RULE:
rule = new ReadOnlyRule();
break;
case RuleTypeEnum.MAX_TARGET_SIZE_RULE:
rule = new MaxTargetSizeRule();
break;
case RuleTypeEnum.MIN_TARGET_SIZE_RULE:
rule = new MinTargetSizeRule();
break;
case RuleTypeEnum.MAX_IMAGE_SIZE_RULE:
rule = new MaxImageSizeRule();
break;
case RuleTypeEnum.MIN_IMAGE_SIZE_RULE:
rule = new MinImageSizeRule();
break;
}
return(rule);
}
public override object Visit(ValueTypeRule expression, TypeAnalyzerEnvironment environment)
{
this.CheckWidgetTyping(expression.Widget, expression.ValueType);
return(base.Visit(expression, environment));
}
