private void AddTextControl(FormControlSettingsDescriptor setting)
{
if (setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.TextTemplate) ||
setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.PasswordTemplate) ||
setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.DateTemplate))
{
formLayout.Add(CreateTextFieldReadOnlyObject(setting), this.groupBoxSettings);
}
else if (setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.HiddenTemplate))
{
formLayout.Add(CreateHiddenReadOnlyObject(setting), this.groupBoxSettings);
}
else if (setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.CheckboxTemplate))
{
formLayout.Add(CreateCheckboxReadOnlyObject(setting), this.groupBoxSettings);
}
else if (setting.TextTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.SwitchTemplate))
{
formLayout.Add(CreateSwitchReadOnlyObject(setting), this.groupBoxSettings);
}
else
{
throw new ArgumentException($"{nameof(setting.TextTemplate.TemplateName)}: 537C774B-91B8-490D-8F47-38834614C383");
}
}
private IReadOnly CreateHiddenReadOnlyObject(FormControlSettingsDescriptor setting)
=> (IReadOnly)Activator.CreateInstance
(
typeof(HiddenReadOnlyObject <>).MakeGenericType(Type.GetType(setting.Type)),
GetFieldName(setting.Field),
setting.TextTemplate.TemplateName,
this.contextProvider
);
public PickerValidatableObject(string name, FormControlSettingsDescriptor setting, IHttpService httpService, IEnumerable <IValidationRule> validations, UiNotificationService uiNotificationService)
: base(name, setting.DropDownTemplate.TemplateName, validations, uiNotificationService)
{
this.Title = setting.Title;
this._dropDownTemplate = setting.DropDownTemplate;
this.httpService = httpService;
GetItemSource();
}
private IReadOnly CreateSwitchReadOnlyObject(FormControlSettingsDescriptor setting)
=> (IReadOnly)Activator.CreateInstance
(
typeof(SwitchReadOnlyObject),
GetFieldName(setting.Field),
setting.TextTemplate.TemplateName,
setting.Title,
this.contextProvider
);
private static T _GetValue <T>(FormControlSettingsDescriptor setting, object defaultValue)
{
if (setting.ValidationSetting?.DefaultValue != null &&
setting.ValidationSetting.DefaultValue.GetType() != typeof(T))
{
throw new ArgumentException($"{nameof(setting.ValidationSetting.DefaultValue)}: 323DA51E-BCA1-4017-A32F-A9FEF6477393");
}
return((T)(setting.ValidationSetting?.DefaultValue ?? defaultValue));
}
private IReadOnly CreatePickerReadOnlyObject(FormControlSettingsDescriptor setting)
=> (IReadOnly)Activator.CreateInstance
(
typeof(PickerReadOnlyObject <>).MakeGenericType(Type.GetType(setting.Type)),
GetFieldName(setting.Field),
setting.Title,
setting.StringFormat,
setting.DropDownTemplate,
this.contextProvider
);
protected void AddDropdownControl(FormControlSettingsDescriptor setting)
{
if (setting.DropDownTemplate.TemplateName == nameof(QuestionTemplateSelector.PickerTemplate))
{
formLayout.Add(CreatePickerValidatableObject(setting, setting.DropDownTemplate), this.groupBoxSettings);
}
else
{
throw new ArgumentException($"{nameof(setting.DropDownTemplate.TemplateName)}: 8A0325D9-E9B0-487D-B569-7E92CDBD4F30");
}
}
private void AddDropdownControl(FormControlSettingsDescriptor setting, string name)
{
if (setting.DropDownTemplate.TemplateName == nameof(QuestionTemplateSelector.PickerTemplate))
{
properties.Add(CreatePickerValidatableObject(setting, name));
}
else
{
throw new ArgumentException($"{nameof(setting.DropDownTemplate.TemplateName)}: 8A0325D9-E9B0-487D-B569-7E92CDBD4F30");
}
}
private void AddDropdownControl(FormControlSettingsDescriptor setting)
{
if (setting.DropDownTemplate.TemplateName == nameof(ReadOnlyControlTemplateSelector.PickerTemplate))
{
formLayout.Add(CreatePickerReadOnlyObject(setting), this.groupBoxSettings);
}
else
{
throw new ArgumentException($"{nameof(setting.DropDownTemplate.TemplateName)}: E3D30EE3-4AFF-4706-A1D2-BB5FA852258E");
}
}
protected void AddTextControl(FormControlSettingsDescriptor setting, TextFieldTemplateDescriptor textTemplate)
{
if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.TextTemplate) ||
textTemplate.TemplateName == nameof(QuestionTemplateSelector.PasswordTemplate))
{
formLayout.Add
(
CreateEntryValidatableObject
(
setting,
textTemplate.TemplateName,
setting.Placeholder,
setting.StringFormat
),
this.groupBoxSettings
);
}
else if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.DateTemplate))
{
formLayout.Add(CreateDatePickerValidatableObject(setting, textTemplate.TemplateName), this.groupBoxSettings);
}
else if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.HiddenTemplate))
{
formLayout.Add(CreateHiddenValidatableObject(setting, textTemplate.TemplateName), this.groupBoxSettings);
}
else if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.CheckboxTemplate))
{
formLayout.Add(CreateCheckboxValidatableObject(setting, textTemplate.TemplateName, setting.Title), this.groupBoxSettings);
}
else if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.SwitchTemplate))
{
formLayout.Add(CreateSwitchValidatableObject(setting, textTemplate.TemplateName, setting.Title), this.groupBoxSettings);
}
else if (textTemplate.TemplateName == nameof(QuestionTemplateSelector.LabelTemplate))
{
formLayout.Add
(
CreateLabelValidatableObject
(
setting,
textTemplate.TemplateName,
setting.Title,
setting.Placeholder,
setting.StringFormat
),
this.groupBoxSettings
);
}
else
{
throw new ArgumentException($"{nameof(setting.TextTemplate.TemplateName)}: BFCC0C85-244A-4896-BAB2-0D29AD0F86D8");
}
}
private IValidatable CreateDatePickerValidatableObject(FormControlSettingsDescriptor setting, string templateName)
=> ValidatableObjectFactory.GetValidatable
(
Activator.CreateInstance
(
typeof(DatePickerValidatableObject <>).MakeGenericType(Type.GetType(setting.Type)),
GetFieldName(setting.Field),
templateName,
GetValidationRules(setting),
this.uiNotificationService
),
setting
);
private IValidatable CreatePickerValidatableObject(FormControlSettingsDescriptor setting, DropDownTemplateDescriptor dropDownTemplate)
=> ValidatableObjectFactory.GetValidatable
(
Activator.CreateInstance
(
typeof(PickerValidatableObject <>).MakeGenericType(Type.GetType(setting.Type)),
GetFieldName(setting.Field),
ValidatableObjectFactory.GetValue(setting),
dropDownTemplate,
GetValidationRules(setting),
this.contextProvider
),
setting
);
private IValidatable CreateSwitchValidatableObject(FormControlSettingsDescriptor setting, string templateName, string title)
=> ValidatableObjectFactory.GetValidatable
(
Activator.CreateInstance
(
typeof(SwitchValidatableObject),
GetFieldName(setting.Field),
templateName,
title,
GetValidationRules(setting),
this.uiNotificationService
),
setting
);
private void AddFormControl(FormControlSettingsDescriptor setting, string name)
{
if (setting.TextTemplate != null)
{
AddTextControl(setting, name);
}
else if (setting.DropDownTemplate != null)
{
AddDropdownControl(setting, name);
}
else
{
throw new ArgumentException($"{nameof(setting)}: 0556AEAF-C851-44F1-A2A2-66C8814D0F54");
}
}
public static object GetValue(FormControlSettingsDescriptor setting)
=> typeof(ValidatableObjectFactory)
.GetMethod
(
"_GetValue",
1,
BindingFlags.NonPublic | BindingFlags.Static,
null,
new Type[]
{
typeof(FormControlSettingsDescriptor)
},
null
)
.MakeGenericMethod(Type.GetType(setting.Type))
.Invoke(null, new object[] { setting });
private IValidatable CreateLabelValidatableObject(FormControlSettingsDescriptor setting, string templateName, string title, string placeholder, string stringFormat)
=> ValidatableObjectFactory.GetValidatable
(
Activator.CreateInstance
(
typeof(LabelValidatableObject <>).MakeGenericType(Type.GetType(setting.Type)),
GetFieldName(setting.Field),
templateName,
title,
placeholder,
stringFormat,
GetValidationRules(setting),
this.uiNotificationService
),
setting
);
protected virtual void AddFormControl(FormControlSettingsDescriptor setting)
{
ValidateSettingType(GetFieldName(setting.Field), setting.Type);
if (setting.TextTemplate != null)
{
AddTextControl(setting, setting.TextTemplate);
}
else if (setting.DropDownTemplate != null)
{
AddDropdownControl(setting);
}
else
{
throw new ArgumentException($"{nameof(setting)}: 0556AEAF-C851-44F1-A2A2-66C8814D0F54");
}
}
private void AddFormControl(FormControlSettingsDescriptor setting)
{
ValidateSettingType(GetFieldName(setting.Field), setting.Type);
if (setting.TextTemplate != null)
{
AddTextControl(setting);
}
else if (setting.DropDownTemplate != null)
{
AddDropdownControl(setting);
}
else
{
throw new ArgumentException($"{nameof(setting)}: 88225DC7-F14A-4CB5-AC97-3FE63BFCC298");
}
}
protected override void AddFormControl(FormControlSettingsDescriptor setting)
{
if (setting.UpdateOnlyTextTemplate != null)
{
AddTextControl(setting, setting.UpdateOnlyTextTemplate);
}
else if (setting.TextTemplate != null)
{
AddTextControl(setting, setting.TextTemplate);
}
else if (setting.DropDownTemplate != null)
{
AddDropdownControl(setting);
}
else
{
throw new ArgumentException($"{nameof(setting)}: 32652CB4-2574-4E5B-9B3F-7E47B37425AD");
}
}
private IValidationRule GetAtLeastOneRequiredRule <T>(FormControlSettingsDescriptor setting, string validationMessage, ObservableCollection <IValidatable> fields) where T : IEnumerable <object>
{
return((IValidationRule)Activator.CreateInstance
(
typeof(AtLeastOneRequiredRule <>).MakeGenericType
(
typeof(ObservableCollection <>).MakeGenericType
(
typeof(T).GetGenericArguments()[0]
)
),
new object[]
{
GetFieldName(setting.Field),
validationMessage,
fields
}
));
}
private void AddTextControl(FormControlSettingsDescriptor setting, string name)
{
if (setting.TextTemplate.TemplateName == nameof(QuestionTemplateSelector.TextTemplate) ||
setting.TextTemplate.TemplateName == nameof(QuestionTemplateSelector.PasswordTemplate))
{
properties.Add(CreateEntryValidatableObject(setting, name));
}
else if (setting.TextTemplate.TemplateName == nameof(QuestionTemplateSelector.DateTemplate))
{
properties.Add(CreateDatePickerValidatableObject(setting, name));
}
else if (setting.TextTemplate.TemplateName == nameof(QuestionTemplateSelector.HiddenTemplate))
{
properties.Add(CreateHiddenValidatableObject(setting, name));
}
else
{
throw new ArgumentException($"{nameof(setting.TextTemplate.TemplateName)}: BFCC0C85-244A-4896-BAB2-0D29AD0F86D8");
}
}
private IValidationRule _GetValidatorRule <T>(ValidatorDefinitionDescriptor validator, FormControlSettingsDescriptor setting, Dictionary <string, List <ValidationRuleDescriptor> > validationMessages, ObservableCollection <IValidatable> fields)
{
if (validationMessages == null)
{
throw new ArgumentException($"{nameof(validationMessages)}: C1BDA4F7-B684-438F-B5BB-B61F01B625CE");
}
if (!validationMessages.TryGetValue(setting.Field, out List <ValidationRuleDescriptor> methodList))
{
throw new ArgumentException($"{nameof(setting.Field)}: 4FF12AAC-DF7F-4346-8747-52413FCA808F");
}
Dictionary <string, string> methodDictionary = methodList.ToDictionary(vr => vr.ClassName, vr => vr.Message);
if (!methodDictionary.TryGetValue(validator.ClassName, out string validationMessage))
{
throw new ArgumentException($"{nameof(validator.ClassName)}: 8A45F637-347D-4578-9F9C-72E9026FBCEB");
}
if (validator.ClassName == nameof(RequiredRule <T>))
{
return(GetRequiredRule());
}
else if (validator.ClassName == nameof(IsMatchRule <T>))
{
return(GetIsMatchRule());
}
else if (validator.ClassName == nameof(RangeRule <int>))
{
return(GetRangeRule());
}
else if (validator.ClassName == nameof(MustBeNumberRule <T>))
{
return(GetMustBeNumberRule());
}
else if (validator.ClassName == nameof(MustBePositiveNumberRule <T>))
{
return(GetMustBePositiveNumberRule());
}
else if (validator.ClassName == nameof(MustBeIntegerRule <T>))
{
return(GetMustBeIntegerRule());
}
else if (validator.ClassName == nameof(IsLengthValidRule))
{
return(GetIsLengthValidRule());
}
else if (validator.ClassName == nameof(IsValidEmailRule))
{
return(GetIsValidEmailRule());
}
else if (validator.ClassName == nameof(IsValidPasswordRule))
{
return(GetIsValidPasswordRule());
}
else if (validator.ClassName == nameof(IsPatternMatchRule))
{
return(GetIsPatternMatchRule());
}
else if (validator.ClassName == nameof(IsValueTrueRule))
{
return(GetIsValueTrueRule());
}
else if (validator.ClassName == nameof(AtLeastOneRequiredRule <List <string> >))
{
return(GetAtLeastOneRequiredRule());
}
else
{
throw new ArgumentException($"{nameof(validator.ClassName)}: CF4FDB4D-F135-40E0-BB31-14DBA624FC25");
}
IValidationRule GetIsValueTrueRule()
=> new IsValueTrueRule
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetIsValidPasswordRule()
=> new IsValidEmailRule
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetIsValidEmailRule()
=> new IsValidEmailRule
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetIsPatternMatchRule()
{
const string pattern = "pattern";
ValidatorArgumentDescriptor patternDescriptor = null;
if (validator.Arguments?.TryGetValue(pattern, out patternDescriptor) != true)
{
throw new ArgumentException($"{pattern}: 086E280E-03C7-4900-A8DB-2C570CEEC91A");
}
return(new IsPatternMatchRule
(
GetFieldName(setting.Field),
validationMessage,
fields,
(string)patternDescriptor?.Value
));
}
IValidationRule GetIsLengthValidRule()
{
const string argumentMin = "minimunLength";
const string argumentMax = "maximunLength";
if (!validator.Arguments.TryGetValue(argumentMin, out ValidatorArgumentDescriptor minDescriptor))
{
throw new ArgumentException($"{argumentMin}: 521CBE54-0677-4633-AB4F-35A355490D89");
}
if (!validator.Arguments.TryGetValue(argumentMax, out ValidatorArgumentDescriptor maxDescriptor))
{
throw new ArgumentException($"{argumentMax}: EEB2EC10-42B9-49EC-A7A3-86530D11C679");
}
return(new IsLengthValidRule
(
GetFieldName(setting.Field),
validationMessage,
fields,
(int)minDescriptor.Value,
(int)maxDescriptor.Value
));
}
IValidationRule GetMustBePositiveNumberRule()
=> new MustBePositiveNumberRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetMustBeNumberRule()
=> new MustBeNumberRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetMustBeIntegerRule()
=> new MustBeIntegerRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields
);
IValidationRule GetRequiredRule()
{
if (setting.ValidationSetting?.DefaultValue != null &&
!typeof(T).AssignableFrom(setting.ValidationSetting.DefaultValue.GetType()))
{
throw new ArgumentException($"{nameof(setting.ValidationSetting.DefaultValue)}: C96394B8-B26B-45B2-8C34-B9BA3FF95088");
}
return(new RequiredRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields,
setting.ValidationSetting?.DefaultValue == null ? default : (T)setting.ValidationSetting.DefaultValue
));
}
IValidationRule GetIsMatchRule()
{
const string argumentName = "otherFieldName";
if (!validator.Arguments.TryGetValue(argumentName, out ValidatorArgumentDescriptor validatorArgumentDescriptor))
{
throw new ArgumentException($"{argumentName}: ADB88D64-F9DA-4FC0-B9C0-CB910F86B735");
}
return(new IsMatchRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields,
GetFieldName((string)validatorArgumentDescriptor.Value)
));
}
IValidationRule GetRangeRule()
{
return((IValidationRule)typeof(ValidatorRuleFactory).GetMethod
(
"GetRangeRule",
1,
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new Type[]
{
typeof(ValidatorDefinitionDescriptor),
typeof(FormControlSettingsDescriptor),
typeof(string),
typeof(ObservableCollection <IValidatable>)
},
null
)
.MakeGenericMethod(Type.GetType(setting.Type)).Invoke
(
this,
new object[]
{
validator,
setting,
validationMessage,
fields
}
));
}
IValidationRule GetAtLeastOneRequiredRule()
{
return((IValidationRule)typeof(ValidatorRuleFactory).GetMethod
(
"GetAtLeastOneRequiredRule",
1,
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new Type[]
{
typeof(FormControlSettingsDescriptor),
typeof(string),
typeof(ObservableCollection <IValidatable>)
},
null
)
.MakeGenericMethod(Type.GetType(setting.Type)).Invoke
(
this,
new object[]
{
setting,
validationMessage,
fields
}
));
}
}
private IValidationRule GetRangeRule <T>(ValidatorDefinitionDescriptor validator, FormControlSettingsDescriptor setting, string validationMessage, ObservableCollection <IValidatable> fields) where T : IComparable <T>
{
const string argumentMin = "min";
const string argumentMax = "max";
if (!validator.Arguments.TryGetValue(argumentMin, out ValidatorArgumentDescriptor minDescriptor))
{
throw new ArgumentException($"{argumentMin}: 34965468-76E0-4FA0-A3EC-16F2BCCB2CE0");
}
if (!validator.Arguments.TryGetValue(argumentMax, out ValidatorArgumentDescriptor maxDescriptor))
{
throw new ArgumentException($"{argumentMax}: 6AA3A056-3ECA-4F48-B79A-A326B2188D14");
}
return(new RangeRule <T>
(
GetFieldName(setting.Field),
validationMessage,
fields,
(T)minDescriptor.Value,
(T)maxDescriptor.Value
));
}
public IValidationRule GetValidatorRule(ValidatorDefinitionDescriptor validator, FormControlSettingsDescriptor setting, Dictionary <string, List <ValidationRuleDescriptor> > validationMessages, ObservableCollection <IValidatable> fields)
=> (IValidationRule)typeof(ValidatorRuleFactory).GetMethod
(
"_GetValidatorRule",
1,
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new Type[]
{
typeof(ValidatorDefinitionDescriptor),
typeof(FormControlSettingsDescriptor),
typeof(Dictionary <string, List <ValidationRuleDescriptor> >),
typeof(ObservableCollection <IValidatable>)
},
null
)
.MakeGenericMethod(Type.GetType(setting.Type)).Invoke
(
this,
new object[]
{
validator,
setting,
validationMessages,
fields
}
);
private IValidationRule GetValidatorRule(ValidatorDefinitionDescriptor validator, FormControlSettingsDescriptor setting) => ValidatorRuleFactory.GetValidatorRule(validator, setting, this.formSettings.ValidationMessages, properties);
private IValidationRule[] GetValidationRules(FormControlSettingsDescriptor setting)
=> setting.ValidationSetting?.Validators?.Select
(
validator => GetValidatorRule(validator, setting)
).ToArray();
public static IValidatable GetValidatable(object validatable, FormControlSettingsDescriptor setting)
{
((IValidatable)validatable).Value = GetValue(setting);
return((IValidatable)validatable);
}
private static T _GetValue <T>(FormControlSettingsDescriptor setting)
=> _GetValue <T>
(
setting,
typeof(T) == typeof(DateTime) ? DefaultDateTime : default(T)
);
public EntryValidatableObject(string name, FormControlSettingsDescriptor setting, IEnumerable <IValidationRule> validations, UiNotificationService uiNotificationService)
: base(name, setting.TextTemplate.TemplateName, validations, uiNotificationService)
{
Placeholder = setting.Placeholder;
}
private IValidationRule GetValidatorRule(ValidatorDefinitionDescriptor validator, FormControlSettingsDescriptor setting)
=> new ValidatorRuleFactory(this.parentName).GetValidatorRule
(
validator,
setting,
this.validationMessages,
formLayout.Properties
);
