/// <summary> /// Method that checks if bindings are correct for the validation method of this Validation rule /// and then invokes teh validation method. /// </summary> /// <param name="binding"></param> /// <returns></returns> internal ValidationOperation <TResult> EvaluateAsync(RuleBinding <TResult> binding) { var bindings = MakeArgumentBindings(binding); var result = ValidationMethod.Invoke(binding.ValidationRule, bindings); return((ValidationOperation <TResult>)result); }
/// <summary> /// Registrations the specified text box to valid. /// </summary> /// <param name="textBoxToValid">The text box to valid.</param> /// <param name="method">The method.</param> public void Registration(TextBox textBoxToValid, ValidationMethod method) { switch (method) { case ValidationMethod.Url: textBoxToValid.TextChanged += textBoxUrl_TextChanged; _registeredToValidationControls.Add(textBoxToValid, false); break; case ValidationMethod.CurrentDigits: textBoxToValid.TextChanged += textBoxCurrentDigits_TextChanged; _registeredToValidationControls.Add(textBoxToValid, false); break; case ValidationMethod.ThreadsCount: textBoxToValid.TextChanged += textBoxThreadsCount_TextChanged; _registeredToValidationControls.Add(textBoxToValid, false); break; case ValidationMethod.NotEmpty: textBoxToValid.TextChanged += textBoxNotEmpty_TextChanged; _registeredToValidationControls.Add(textBoxToValid, false); break; } }
/// <summary> /// Creates a new instance of a ParameterText box which is validated between two specified values /// </summary> public ParameterTextBox(int driverIndex, int parameterIndex, float initialValue, float _lowerBound, float _upperBound) { validationMethod = ValidationMethod.Between; lowerBound = _lowerBound; upperBound = _upperBound; InitialiseComponent(driverIndex, parameterIndex, initialValue); }
public AndConstraint <IbanNetOptionsBuilderStubAssertions <T> > HaveConfiguredValidationMethod ( ValidationMethod method, string because = "", params object[] becauseArgs ) { VerifyCalled(should => should.HaveValidationMethod(method, because, becauseArgs)); return(new AndConstraint <IbanNetOptionsBuilderStubAssertions <T> >(this)); }
/// <summary> /// Creates a new instance of a ParameterTextBox which is validated either greater than or less than a specified boundary. /// </summary> /// <param name="initialValue">The initial value to display in the text box</param> /// <param name="bound">The limiting value for validation of the input</param> /// <param name="boundIsUpperBound">True if the control must be less than the specified bound; otherwise false</param> public ParameterTextBox(int driverIndex, int parameterIndex, float initialValue, float bound, bool boundIsUpperBound) { if (boundIsUpperBound) { upperBound = bound; validationMethod = ValidationMethod.LessThan; } else { lowerBound = bound; validationMethod = ValidationMethod.GreaterThan; } InitialiseComponent(driverIndex, parameterIndex, initialValue); }
/// <summary> /// Base class for form fields /// </summary> /// <param name="Form">Form containing the field.</param> /// <param name="Var">Variable name</param> /// <param name="Label">Label</param> /// <param name="Required">If the field is required.</param> /// <param name="ValueStrings">Values for the field (string representations).</param> /// <param name="Options">Options, as (Label,Value) pairs.</param> /// <param name="Description">Description</param> /// <param name="DataType">Data Type</param> /// <param name="ValidationMethod">Validation Method</param> /// <param name="Error">Flags the field as having an error.</param> /// <param name="PostBack">Flags a field as requiring server post-back after having been edited.</param> /// <param name="ReadOnly">Flags a field as being read-only.</param> /// <param name="NotSame">Flags a field as having an undefined or uncertain value.</param> public Field(DataForm Form, string Var, string Label, bool Required, string[] ValueStrings, KeyValuePair <string, string>[] Options, string Description, DataType DataType, ValidationMethod ValidationMethod, string Error, bool PostBack, bool ReadOnly, bool NotSame) { this.form = Form; this.var = Var; this.label = Label; this.required = Required; this.valueStrings = ValueStrings; this.options = Options; this.description = Description; this.dataType = DataType; this.validationMethod = ValidationMethod; this.error = Error; this.postBack = PostBack; this.readOnly = ReadOnly; this.notSame = NotSame; }
public AndConstraint <IbanValidatorOptionsAssertions> HaveValidationMethod ( ValidationMethod method, string because = "", params object[] becauseArgs ) { Execute.Assertion .BecauseOf(because, becauseArgs) .Given(() => Subject.Method) .ForCondition(vm => vm == method) .FailWith("Expected {context:options} to use {0}{reason}, but found {1}.", _ => method, m => m); return(new AndConstraint <IbanValidatorOptionsAssertions>(this)); }
private static IIbanNetOptionsBuilder UseValidationMethod(this IIbanNetOptionsBuilder builder, ValidationMethod validationMethod) { if (builder is null) { throw new ArgumentNullException(nameof(builder)); } return(builder.Configure(options => options.Method = validationMethod)); }
/// <summary> /// Hidden form field. /// </summary> /// <param name="Form">Form containing the field.</param> /// <param name="Var">Variable name</param> /// <param name="Label">Label</param> /// <param name="Required">If the field is required.</param> /// <param name="ValueStrings">Values for the field (string representations).</param> /// <param name="Options">Options, as (Label,Value) pairs.</param> /// <param name="Description">Description</param> /// <param name="DataType">Data Type</param> /// <param name="ValidationMethod">Validation Method</param> /// <param name="Error">Flags the field as having an error.</param> /// <param name="PostBack">Flags a field as requiring server post-back after having been edited.</param> /// <param name="ReadOnly">Flags a field as being read-only.</param> /// <param name="NotSame">Flags a field as having an undefined or uncertain value.</param> public HiddenField(DataForm Form, string Var, string Label, bool Required, string[] ValueStrings, KeyValuePair <string, string>[] Options, string Description, DataType DataType, ValidationMethod ValidationMethod, string Error, bool PostBack, bool ReadOnly, bool NotSame) : base(Form, Var, Label, Required, ValueStrings, Options, Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame) { }
[InlineData(false, ValidationMethod.Loose)] // Loose mode. public void Given_validation_method_when_adding_it_should_use_correct_method(bool?strict, ValidationMethod expectedValidationMethod) { // Act Fixture.Configure(builder => { switch (strict) { case null: break; case true: builder.UseStrictValidation(); break; case false: builder.UseLooseValidation(); break; } }); DependencyResolverAdapter adapter = Fixture.Build(); // Assert IIbanValidator validator = adapter.GetRequiredService <IIbanValidator>(); validator.Should() .BeOfType <IbanValidator>() .Which.Options.Method.Should() .Be(expectedValidationMethod); }
/// <summary> /// Sets parameters from a data form in an object. /// </summary> /// <param name="e">IQ Event Arguments describing the request.</param> /// <param name="EditableObject">Object whose parameters will be set.</param> /// <param name="Form">Data Form.</param> /// <param name="OnlySetChanged">If only changed parameters are to be set.</param> /// <returns>Any errors encountered, or null if parameters was set properly.</returns> public static async Task <SetEditableFormResult> SetEditableForm(IqEventArgs e, object EditableObject, DataForm Form, bool OnlySetChanged) { Type T = EditableObject.GetType(); string DefaultLanguageCode = GetDefaultLanguageCode(T); List <KeyValuePair <string, string> > Errors = null; PropertyInfo PropertyInfo; FieldInfo FieldInfo; Language Language = await ConcentratorServer.GetLanguage(e.Query, DefaultLanguageCode); Namespace Namespace = null; Namespace ConcentratorNamespace = await Language.GetNamespaceAsync(typeof(ConcentratorServer).Namespace); LinkedList <Tuple <PropertyInfo, FieldInfo, object> > ToSet = null; ValidationMethod ValidationMethod; OptionAttribute OptionAttribute; RegularExpressionAttribute RegularExpressionAttribute; RangeAttribute RangeAttribute; DataType DataType; Type PropertyType; string NamespaceStr; string LastNamespaceStr = null; object ValueToSet; object ValueToSet2; object[] Parsed; bool ReadOnly; bool Alpha; bool DateOnly; bool HasHeader; bool HasOptions; bool ValidOption; bool Nullable; if (Namespace is null) { Namespace = await Language.CreateNamespaceAsync(T.Namespace); } if (ConcentratorNamespace is null) { ConcentratorNamespace = await Language.CreateNamespaceAsync(typeof(ConcentratorServer).Namespace); } foreach (Field Field in Form.Fields) { PropertyInfo = T.GetRuntimeProperty(Field.Var); FieldInfo = PropertyInfo is null?T.GetRuntimeField(Field.Var) : null; if (PropertyInfo is null && FieldInfo is null) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(1, "Property not found.")); continue; } if (PropertyInfo != null && (!PropertyInfo.CanRead || !PropertyInfo.CanWrite)) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable.")); continue; } NamespaceStr = (PropertyInfo?.DeclaringType ?? FieldInfo.DeclaringType).Namespace; if (Namespace is null || NamespaceStr != LastNamespaceStr) { Namespace = await Language.GetNamespaceAsync(NamespaceStr); LastNamespaceStr = NamespaceStr; } ValidationMethod = null; ReadOnly = Alpha = DateOnly = HasHeader = HasOptions = ValidOption = false; foreach (Attribute Attr in (PropertyInfo?.GetCustomAttributes() ?? FieldInfo.GetCustomAttributes())) { if (Attr is HeaderAttribute) { HasHeader = true; } else if ((OptionAttribute = Attr as OptionAttribute) != null) { HasOptions = true; if (Field.ValueString == OptionAttribute.Option.ToString()) { ValidOption = true; } } else if ((RegularExpressionAttribute = Attr as RegularExpressionAttribute) != null) { ValidationMethod = new RegexValidation(RegularExpressionAttribute.Pattern); } else if ((RangeAttribute = Attr as RangeAttribute) != null) { ValidationMethod = new RangeValidation(RangeAttribute.Min, RangeAttribute.Max); } else if (Attr is OpenAttribute) { ValidationMethod = new OpenValidation(); } else if (Attr is ReadOnlyAttribute) { ReadOnly = true; } else if (Attr is AlphaChannelAttribute) { Alpha = true; } else if (Attr is DateOnlyAttribute) { DateOnly = true; } } if (!HasHeader) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable.")); continue; } if (ReadOnly) { if (Field.ValueString != (PropertyInfo?.GetValue(EditableObject) ?? FieldInfo?.GetValue(EditableObject))?.ToString()) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(3, "Property is read-only.")); } continue; } if (HasOptions && !ValidOption) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option.")); continue; } PropertyType = PropertyInfo?.PropertyType ?? FieldInfo.FieldType; ValueToSet = null; ValueToSet2 = null; Parsed = null; DataType = null; Nullable = false; if (PropertyType.GetTypeInfo().IsGenericType) { Type GT = PropertyType.GetGenericTypeDefinition(); if (GT == typeof(Nullable <>)) { Nullable = true; PropertyType = PropertyType.GenericTypeArguments[0]; } } if (Nullable && string.IsNullOrEmpty(Field.ValueString)) { ValueToSet2 = null; } else { if (PropertyType == typeof(string[])) { if (ValidationMethod is null) { ValidationMethod = new BasicValidation(); } ValueToSet = ValueToSet2 = Parsed = Field.ValueStrings; DataType = StringDataType.Instance; } else if (PropertyType.GetTypeInfo().IsEnum) { if (ValidationMethod is null) { ValidationMethod = new BasicValidation(); } try { ValueToSet = ValueToSet2 = Enum.Parse(PropertyType, Field.ValueString); } catch (Exception) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option.")); continue; } } else if (PropertyType == typeof(bool)) { if (ValidationMethod is null) { ValidationMethod = new BasicValidation(); } if (!CommonTypes.TryParse(Field.ValueString, out bool b)) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(5, "Invalid boolean value.")); continue; } DataType = BooleanDataType.Instance; ValueToSet = ValueToSet2 = b; } else { if (PropertyType == typeof(string)) { DataType = StringDataType.Instance; } else if (PropertyType == typeof(sbyte)) { DataType = ByteDataType.Instance; } else if (PropertyType == typeof(short)) { DataType = ShortDataType.Instance; } else if (PropertyType == typeof(int)) { DataType = IntDataType.Instance; } else if (PropertyType == typeof(long)) { DataType = LongDataType.Instance; } else if (PropertyType == typeof(byte)) { DataType = ShortDataType.Instance; if (ValidationMethod is null) { ValidationMethod = new RangeValidation(byte.MinValue.ToString(), byte.MaxValue.ToString()); } } else if (PropertyType == typeof(ushort)) { DataType = IntDataType.Instance; if (ValidationMethod is null) { ValidationMethod = new RangeValidation(ushort.MinValue.ToString(), ushort.MaxValue.ToString()); } } else if (PropertyType == typeof(uint)) { DataType = LongDataType.Instance; if (ValidationMethod is null) { ValidationMethod = new RangeValidation(uint.MinValue.ToString(), uint.MaxValue.ToString()); } } else if (PropertyType == typeof(ulong)) { DataType = IntegerDataType.Instance; if (ValidationMethod is null) { ValidationMethod = new RangeValidation(ulong.MinValue.ToString(), ulong.MaxValue.ToString()); } } else if (PropertyType == typeof(DateTime)) { if (DateOnly) { DataType = DateDataType.Instance; } else { DataType = DateTimeDataType.Instance; } } else if (PropertyType == typeof(decimal)) { DataType = DecimalDataType.Instance; } else if (PropertyType == typeof(double)) { DataType = DoubleDataType.Instance; } else if (PropertyType == typeof(float)) { DataType = DoubleDataType.Instance; // Use xs:double anyway } else if (PropertyType == typeof(TimeSpan)) { DataType = TimeDataType.Instance; } else if (PropertyType == typeof(Uri)) { DataType = AnyUriDataType.Instance; } else if (PropertyType == typeof(SKColor)) { if (Alpha) { DataType = ColorAlphaDataType.Instance; } else { DataType = ColorDataType.Instance; } } else { DataType = null; } if (ValidationMethod is null) { ValidationMethod = new BasicValidation(); } try { if (DataType is null) { ValueToSet = Field.ValueString; ValueToSet2 = Activator.CreateInstance(PropertyType, ValueToSet); } else { ValueToSet = DataType.Parse(Field.ValueString); if (ValueToSet.GetType() == PropertyType) { ValueToSet2 = ValueToSet; } else { ValueToSet2 = Convert.ChangeType(ValueToSet, PropertyType); } } } catch (Exception) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(6, "Invalid value.")); continue; } } if (Parsed is null) { Parsed = new object[] { ValueToSet } } ; ValidationMethod.Validate(Field, DataType, Parsed, Field.ValueStrings); if (Field.HasError) { AddError(ref Errors, Field.Var, Field.Error); continue; } } if (ToSet is null) { ToSet = new LinkedList <Tuple <PropertyInfo, FieldInfo, object> >(); } ToSet.AddLast(new Tuple <PropertyInfo, FieldInfo, object>(PropertyInfo, FieldInfo, ValueToSet2)); } if (Errors is null) { SetEditableFormResult Result = new SetEditableFormResult() { Errors = null, Tags = new List <KeyValuePair <string, object> >() }; foreach (Tuple <PropertyInfo, FieldInfo, object> P in ToSet) { try { if (OnlySetChanged) { object Current = P.Item1?.GetValue(EditableObject) ?? P.Item2?.GetValue(EditableObject); if (Current is null) { if (P.Item3 is null) { continue; } } else if (P.Item3 != null && Current.Equals(P.Item3)) { continue; } } if (P.Item1 != null) { P.Item1.SetValue(EditableObject, P.Item3); Result.Tags.Add(new KeyValuePair <string, object>(P.Item1.Name, P.Item3)); } else { P.Item2.SetValue(EditableObject, P.Item3); Result.Tags.Add(new KeyValuePair <string, object>(P.Item2.Name, P.Item3)); } } catch (Exception ex) { AddError(ref Errors, P.Item1?.Name ?? P.Item2.Name, ex.Message); } } return(Result); } else { return(new SetEditableFormResult() { Errors = Errors.ToArray(), Tags = null }); } }
/// <summary> /// Sets parameters from a data form in an object. /// </summary> /// <param name="e">IQ Event Arguments describing the request.</param> /// <param name="EditableObject">Object whose parameters will be set.</param> /// <param name="Form">Data Form.</param> /// <returns>Any errors encountered, or null if parameters was set properly.</returns> public static async Task <KeyValuePair <string, string>[]> SetEditableForm(IqEventArgs e, object EditableObject, DataForm Form) { Type T = EditableObject.GetType(); string DefaultLanguageCode = GetDefaultLanguageCode(T); List <KeyValuePair <string, string> > Errors = null; PropertyInfo PI; Language Language = await ConcentratorServer.GetLanguage(e.Query, DefaultLanguageCode); Namespace Namespace = await Language.GetNamespaceAsync(T.Namespace); Namespace ConcentratorNamespace = await Language.GetNamespaceAsync(typeof(ConcentratorServer).Namespace); LinkedList <KeyValuePair <PropertyInfo, object> > ToSet = null; ValidationMethod ValidationMethod; OptionAttribute OptionAttribute; RegularExpressionAttribute RegularExpressionAttribute; RangeAttribute RangeAttribute; DataType DataType; Type PropertyType; string Header; object ValueToSet; object[] Parsed; bool ReadOnly; bool Alpha; bool DateOnly; bool HasHeader; bool HasOptions; bool ValidOption; if (Namespace == null) { Namespace = await Language.CreateNamespaceAsync(T.Namespace); } if (ConcentratorNamespace == null) { ConcentratorNamespace = await Language.CreateNamespaceAsync(typeof(ConcentratorServer).Namespace); } foreach (Field Field in Form.Fields) { PI = T.GetRuntimeProperty(Field.Var); if (PI == null) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(1, "Property not found.")); continue; } if (!PI.CanRead || !PI.CanWrite) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable.")); continue; } Header = null; ValidationMethod = null; ReadOnly = Alpha = DateOnly = HasHeader = HasOptions = ValidOption = false; foreach (Attribute Attr in PI.GetCustomAttributes()) { if (Attr is HeaderAttribute) { HasHeader = true; } else if ((OptionAttribute = Attr as OptionAttribute) != null) { HasOptions = true; if (Field.ValueString == OptionAttribute.Option.ToString()) { ValidOption = true; } } else if ((RegularExpressionAttribute = Attr as RegularExpressionAttribute) != null) { ValidationMethod = new RegexValidation(RegularExpressionAttribute.Pattern); } else if ((RangeAttribute = Attr as RangeAttribute) != null) { ValidationMethod = new RangeValidation(RangeAttribute.Min, RangeAttribute.Max); } else if (Attr is OpenAttribute) { ValidationMethod = new OpenValidation(); } else if (Attr is ReadOnlyAttribute) { ReadOnly = true; } else if (Attr is AlphaChannelAttribute) { Alpha = true; } else if (Attr is DateOnlyAttribute) { DateOnly = true; } } if (Header == null) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable.")); continue; } if (ReadOnly) { if (Field.ValueString != PI.GetValue(EditableObject).ToString()) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(3, "Property is read-only.")); } continue; } if (HasOptions && !ValidOption) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option.")); continue; } PropertyType = PI.PropertyType; ValueToSet = null; Parsed = null; DataType = null; if (PropertyType == typeof(string[])) { if (ValidationMethod == null) { ValidationMethod = new BasicValidation(); } ValueToSet = Parsed = Field.ValueStrings; DataType = StringDataType.Instance; } else if (PropertyType == typeof(Enum)) { if (ValidationMethod == null) { ValidationMethod = new BasicValidation(); } try { ValueToSet = Enum.Parse(PropertyType, Field.ValueString); } catch (Exception) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option.")); continue; } } else if (PropertyType == typeof(bool)) { if (ValidationMethod == null) { ValidationMethod = new BasicValidation(); } if (!CommonTypes.TryParse(Field.ValueString, out bool b)) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(5, "Invalid boolean value.")); continue; } DataType = BooleanDataType.Instance; } else { if (PropertyType == typeof(string)) { DataType = StringDataType.Instance; } else if (PropertyType == typeof(byte)) { DataType = ByteDataType.Instance; } else if (PropertyType == typeof(short)) { DataType = ShortDataType.Instance; } else if (PropertyType == typeof(int)) { DataType = IntDataType.Instance; } else if (PropertyType == typeof(long)) { DataType = LongDataType.Instance; } else if (PropertyType == typeof(sbyte)) { DataType = ShortDataType.Instance; if (ValidationMethod == null) { ValidationMethod = new RangeValidation(sbyte.MinValue.ToString(), sbyte.MaxValue.ToString()); } } else if (PropertyType == typeof(ushort)) { DataType = IntDataType.Instance; if (ValidationMethod == null) { ValidationMethod = new RangeValidation(ushort.MinValue.ToString(), ushort.MaxValue.ToString()); } } else if (PropertyType == typeof(uint)) { DataType = LongDataType.Instance; if (ValidationMethod == null) { ValidationMethod = new RangeValidation(uint.MinValue.ToString(), uint.MaxValue.ToString()); } } else if (PropertyType == typeof(ulong)) { DataType = IntegerDataType.Instance; if (ValidationMethod == null) { ValidationMethod = new RangeValidation(ulong.MinValue.ToString(), ulong.MaxValue.ToString()); } } else if (PropertyType == typeof(DateTime)) { if (DateOnly) { DataType = DateDataType.Instance; } else { DataType = DateTimeDataType.Instance; } } else if (PropertyType == typeof(decimal)) { DataType = DecimalDataType.Instance; } else if (PropertyType == typeof(double)) { DataType = DoubleDataType.Instance; } else if (PropertyType == typeof(float)) { DataType = DoubleDataType.Instance; // Use xs:double anyway } else if (PropertyType == typeof(TimeSpan)) { DataType = TimeDataType.Instance; } else if (PropertyType == typeof(Uri)) { DataType = AnyUriDataType.Instance; } else if (PropertyType == typeof(SKColor)) { if (Alpha) { DataType = ColorAlphaDataType.Instance; } else { DataType = ColorDataType.Instance; } } else { DataType = null; } if (ValidationMethod == null) { ValidationMethod = new BasicValidation(); } try { ValueToSet = DataType.Parse(Field.ValueString); } catch (Exception) { AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(6, "Invalid value.")); continue; } } if (Parsed == null) { Parsed = new object[] { ValueToSet } } ; ValidationMethod.Validate(Field, DataType, Parsed, Field.ValueStrings); if (Field.HasError) { AddError(ref Errors, Field.Var, Field.Error); continue; } if (ToSet == null) { ToSet = new LinkedList <KeyValuePair <PropertyInfo, object> >(); } ToSet.AddLast(new KeyValuePair <PropertyInfo, object>(PI, ValueToSet)); } if (Errors == null) { foreach (KeyValuePair <PropertyInfo, object> P in ToSet) { try { P.Key.SetValue(EditableObject, P.Value); } catch (Exception ex) { AddError(ref Errors, P.Key.Name, ex.Message); } } } if (Errors == null) { return(null); } else { return(Errors.ToArray()); } }
public ValidationRule(ValidationTarget targetName, ValidationMethod validationMethod) { TargetName = targetName; ValidationMethods.Add(validationMethod); }
private Field ParseField(XmlElement E) { string Label = XML.Attribute(E, "label"); string Type = XML.Attribute(E, "type"); string Var = XML.Attribute(E, "var"); List <string> ValueStrings = null; List <KeyValuePair <string, string> > OptionStrings = null; string Description = string.Empty; string DataTypeName = null; DataType DataType = null; ValidationMethod ValidationMethod = null; Media Media = null; Field Field; string Error = null; bool Required = false; bool PostBack = false; bool ReadOnly = false; bool NotSame = false; foreach (XmlNode N2 in E.ChildNodes) { switch (N2.LocalName) { case "desc": Description = N2.InnerText; break; case "required": Required = true; break; case "value": if (ValueStrings == null) { ValueStrings = new List <string>(); } ValueStrings.Add(N2.InnerText); break; case "option": if (OptionStrings == null) { OptionStrings = new List <KeyValuePair <string, string> >(); } string OptionLabel = XML.Attribute((XmlElement)N2, "label"); string OptionValue = string.Empty; foreach (XmlNode N3 in N2.ChildNodes) { if (N3.LocalName == "value") { OptionValue = N3.InnerText; break; } } OptionStrings.Add(new KeyValuePair <string, string>(OptionLabel, OptionValue)); break; case "validate": DataTypeName = XML.Attribute((XmlElement)N2, "datatype"); foreach (XmlNode N3 in N2.ChildNodes) { switch (N3.LocalName) { case "basic": ValidationMethod = new BasicValidation(); break; case "open": ValidationMethod = new OpenValidation(); break; case "range": XmlElement E3 = (XmlElement)N3; ValidationMethod = new RangeValidation( XML.Attribute(E3, "min"), XML.Attribute(E3, "max")); break; case "regex": ValidationMethod = new RegexValidation(N3.InnerText); break; case "list-range": E3 = (XmlElement)N3; ValidationMethod = new ListRangeValidation(ValidationMethod, XML.Attribute(E3, "min", 0), XML.Attribute(E3, "max", int.MaxValue)); break; } } break; case "media": Media = new Media((XmlElement)N2); break; case "postBack": PostBack = true; break; case "readOnly": ReadOnly = true; break; case "notSame": NotSame = true; break; case "error": Error = N2.InnerText; break; } } if (string.IsNullOrEmpty(DataTypeName)) { if (Type == "boolean") { DataTypeName = "xs:boolean"; } else { DataTypeName = "xs:string"; } } switch (DataTypeName.ToLower()) { case "xs:boolean": DataType = BooleanDataType.Instance; break; case "xs:string": default: DataType = StringDataType.Instance; break; case "anyuri": DataType = AnyUriDataType.Instance; break; case "xs:byte": DataType = ByteDataType.Instance; break; case "xs:date": DataType = DateDataType.Instance; break; case "xs:datetime": DataType = DateTimeDataType.Instance; break; case "xs:decimal": DataType = DecimalDataType.Instance; break; case "xs:double": DataType = DoubleDataType.Instance; break; case "xs:int": DataType = IntDataType.Instance; break; case "xs:integer": DataType = IntegerDataType.Instance; break; case "xs:language": DataType = LanguageDataType.Instance; break; case "xs:long": DataType = LongDataType.Instance; break; case "xs:short": DataType = ShortDataType.Instance; break; case "xs:time": DataType = TimeDataType.Instance; break; case "xdc:Color": DataType = ColorDataType.Instance; break; case "xdc:ColorAlpha": DataType = ColorAlphaDataType.Instance; break; } if (ValidationMethod == null) { ValidationMethod = new BasicValidation(); } switch (Type) { case "boolean": Field = new BooleanField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "fixed": Field = new FixedField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "hidden": Field = new HiddenField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "jid-multi": Field = new JidMultiField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "jid-single": Field = new JidSingleField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "list-multi": Field = new ListMultiField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "list-single": Field = new ListSingleField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "text-multi": Field = new TextMultiField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "text-private": Field = new TextPrivateField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; case "text-single": Field = new TextSingleField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); break; default: if (Media == null) { Field = new TextSingleField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Error, PostBack, ReadOnly, NotSame); } else { Field = new MediaField(this, Var, Label, Required, ValueStrings?.ToArray(), OptionStrings?.ToArray(), Description, DataType, ValidationMethod, Media, Error, PostBack, ReadOnly, NotSame); } break; } return(Field); }
public void Given_custom_rules_for_any_method_when_getting_rules_it_should_append_custom_rules(ValidationMethod method) { _options.Method = method; IIbanValidationRule rule1 = Mock.Of <IIbanValidationRule>(); IIbanValidationRule rule2 = Mock.Of <IIbanValidationRule>(); _options.Rules.Add(rule1); _options.Rules.Add(rule2); // Act IEnumerable <IIbanValidationRule> rules = _sut.GetRules(); // Assert rules.Should() .EndWith(new[] { rule1, rule2 }); }