public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
var result = base.BindModel(controllerContext, bindingContext);
if (result == null)
{
return result;
}
var runner = new ValidatorRunner(new CachedValidationRegistry());
if (runner.IsValid(result))
{
return result;
}
var summary = runner.GetErrorSummary(result);
var modelState = bindingContext.ModelState;
foreach (var invalidProperty in summary.InvalidProperties)
{
foreach (var error in summary.GetErrorsForProperty(invalidProperty))
{
modelState.AddModelError(invalidProperty, error);
}
}
return result;
}
public CastleValidatorRulesProvider()
{
registry = new CachedValidationRegistry();
runner = new ValidatorRunner(registry);
ruleEmitters.AddSingle<NonEmptyValidator>(x => new RequiredRule());
ruleEmitters.AddSingle<CreditCardValidator>(x => new DataTypeRule(DataTypeRule.DataType.CreditCardLuhn));
ruleEmitters.AddMultiple<DateTimeValidator>(x => new Rule[] {
new RequiredRule(),
new DataTypeRule(DataTypeRule.DataType.DateTime)
});
ruleEmitters.AddMultiple<DateValidator>(x => new Rule[] {
new RequiredRule(),
new DataTypeRule(DataTypeRule.DataType.Date)
});
ruleEmitters.AddMultiple<IntegerValidator>(x => new Rule[] {
new RequiredRule(),
new DataTypeRule(DataTypeRule.DataType.Integer)
});
ruleEmitters.AddMultiple<IValidator>(x => {
if ((x is DecimalValidator) || (x is DoubleValidator) || (x is SingleValidator)) {
return new Rule[] {
new RequiredRule(),
new DataTypeRule(DataTypeRule.DataType.Decimal)
};
} else
return null;
});
ruleEmitters.AddSingle<LengthValidator>(ConstructStringLengthRule);
ruleEmitters.AddSingle<RangeValidator>(ConstructRangeRule);
ruleEmitters.AddSingle<EmailValidator>(x => new DataTypeRule(DataTypeRule.DataType.EmailAddress));
ruleEmitters.AddSingle<RegularExpressionValidator>(x => new RegularExpressionRule(x.Expression, x.RegexRule.Options));
ruleEmitters.AddSingle<SameAsValidator>(x => new ComparisonRule(x.PropertyToCompare, ComparisonRule.Operator.Equals));
ruleEmitters.AddSingle<NotSameAsValidator>(x => new ComparisonRule(x.PropertyToCompare, ComparisonRule.Operator.DoesNotEqual));
}
static void Main(string[] args)
{
var order = new Order
{
Product = new Product { Name = "Widget", MinQuantity = 5, MaxQuantity = 100 },
Quantity = 50
};
var runner = new ValidatorRunner(new CachedValidationRegistry());
if (runner.IsValid(order))
{
Console.WriteLine("The order is valid!");
}
else
{
ErrorSummary summary = runner.GetErrorSummary(order);
foreach (var invalidProperty in summary.InvalidProperties)
{
Console.WriteLine("{0} is invalid because:", invalidProperty);
foreach (var error in summary.GetErrorsForProperty(invalidProperty))
{
Console.WriteLine("\t * {0}", error);
}
}
}
Console.ReadLine();
}
/// <errorSummary>
/// Determines whether the specified instance is valid.
/// </errorSummary>
/// <param name="instance">The instance.</param>
/// <param name="fieldValue">The field value.</param>
/// <returns>
/// <c>true</c> if the specified instance is valid; otherwise, <c>false</c>.
/// </returns>
public override bool IsValid(object instance, object fieldValue)
{
ValidatorRunner runner = new ValidatorRunner(validationRegistry.BaseRegistry);
bool valid = runner.IsValid(instance);
if (!valid)
errorSummary = runner.GetErrorSummary(instance);
return valid;
}
/// <summary>
/// Constructs and configures an <see cref="IValidator"/>
/// instance based on the properties set on the attribute instance.
/// </summary>
/// <param name="validatorRunner"></param>
/// <param name="type"></param>
/// <returns></returns>
public override IValidator Build(ValidatorRunner validatorRunner, Type type)
{
GroupNotEmptyValidator validator = (GroupNotEmptyValidator)
validatorRunner.ExtendedProperties[group];
if (validator == null)
{
validatorRunner.ExtendedProperties[group] = validator
= new GroupNotEmptyValidator(group);
}
ConfigureValidatorMessage(validator);
return validator;
}
public void Index([DataBind("ContactRequest")] ContactRequest request)
{
var runner = new ValidatorRunner(new CachedValidationRegistry());
if (!runner.IsValid(request))
{
ErrorSummary summary = runner.GetErrorSummary(request);
PropertyBag["ContactRequest"] = request;
PropertyBag["error"] = summary;
}
else
{
var parameter = new Dictionary<string, object> { { "request", request } };
var message = RenderMailMessage("contact", null, (IDictionary)parameter);
message.Encoding = System.Text.Encoding.UTF8;
DeliverEmail(message);
RedirectToAction("Thanks");
}
}
/// <summary>
/// Gets all validators associated with a <see cref="Type"/>.
/// <para>
/// The validators returned are initialized.
/// </para>
/// </summary>
/// <param name="validatorRunner">The validator runner.</param>
/// <param name="targetType">Target type.</param>
/// <param name="runWhen">Restrict the set returned to the phase specified</param>
/// <returns>A Validator array</returns>
public IValidator[] GetValidators(ValidatorRunner validatorRunner, Type targetType, RunWhen runWhen)
{
PropertyInfo[] properties = (PropertyInfo[]) propertiesPerType[targetType];
if (properties == null)
{
propertiesPerType[targetType] = properties = ResolveProperties(targetType);
}
ArrayList list = new ArrayList();
foreach (PropertyInfo prop in properties)
{
list.AddRange(GetValidators(validatorRunner, targetType, prop, runWhen));
}
return (IValidator[]) list.ToArray(typeof (IValidator));
}
/// <summary>
/// Constructs and configures an <see cref="IValidator"/>
/// instance based on the properties set on the attribute instance.
/// </summary>
public virtual IValidator Build(ValidatorRunner validatorRunner, Type type)
{
return Build();
}
internal static void AddNestedPropertyValidationErrorMessages(List<string> errorMessages, object instance, ValidatorRunner runner)
{
foreach (PropertyInfo propinfo in GetNestedPropertiesToValidate(instance))
{
object propval = propinfo.GetValue(instance, null);
if (propval != null)
{
ErrorSummary summary = runner.GetErrorSummary(propval);
if (summary != null)
{
errorMessages.AddRange(summary.ErrorMessages);
}
}
}
}
/// <summary>
/// Invoked by the framework in order to give a chance to
/// obtain other services
/// </summary>
/// <param name="provider">The service proviver</param>
public virtual void Service(IServiceProvider provider)
{
var loggerFactory = (ILoggerFactory)provider.GetService(typeof(ILoggerFactory));
if (loggerFactory != null)
{
logger = loggerFactory.Create(typeof(FormHelper));
}
var config = (IMonoRailConfiguration)provider.GetService(typeof(IMonoRailConfiguration));
if (config != null)
{
var jsLibConfig = config.JSGeneratorConfiguration.DefaultLibrary;
if (jsLibConfig != null)
{
if (jsLibConfig.BrowserValidatorProvider != null)
{
ValidatorProvider = (IBrowserValidatorProvider)
Activator.CreateInstance(jsLibConfig.BrowserValidatorProvider);
}
}
}
ValidatorRegistry = (IValidatorRegistry)provider.GetService(typeof(IValidatorRegistry));
if (ValidatorRegistry != null)
{
ValidatorRunner = new ValidatorRunner(false, ValidatorRegistry);
}
else
{
ValidatorRunner = new ValidatorRunner(false, new CachedValidationRegistry());
}
}
private void Initialize()
{
ValidatorRegistry = new CachedValidationRegistry();
ValidatorRunner = new ValidatorRunner(false, ValidatorRegistry);
ValidatorProvider = new PrototypeWebValidator();
}
public IValidator[] GetValidators(ValidatorRunner validatorRunner, Type targetType, PropertyInfo property, RunWhen runWhen)
{
throw new NotSupportedException();
}
/// <summary>
/// Gets all validators associated with a property.
/// <para>
/// The validators returned are initialized.
/// </para>
/// </summary>
/// <param name="validatorRunner">The validator runner.</param>
/// <param name="targetType">Target type.</param>
/// <param name="property">The property.</param>
/// <param name="runWhen">Restrict the set returned to the phase specified</param>
/// <returns>A Validator array</returns>
public IValidator[] GetValidators(
ValidatorRunner validatorRunner, Type targetType, PropertyInfo property,
RunWhen runWhen)
{
object[] builders = (object[]) attrsPerProperty[property];
if (builders == null)
{
builders = property.GetCustomAttributes(typeof (IValidatorBuilder), true);
attrsPerProperty[property] = builders;
}
ArrayList validators = new ArrayList();
foreach (IValidatorBuilder builder in builders)
{
IValidator validator = builder.Build(validatorRunner, targetType);
if (!IsValidatorOnPhase(validator, runWhen)) continue;
validator.Initialize(this, property);
validators.Add(validator);
}
return (IValidator[]) validators.ToArray(typeof (IValidator));
}
public ActionResult Login(string username, string password, string redirectUrl)
{
var loginData = new LoginData(username, password);
var validationRunner = new ValidatorRunner(new CachedValidationRegistry());
if (!validationRunner.IsValid(loginData))
{
AddErrorMessages(validationRunner.GetErrorSummary(loginData).ErrorMessages);
return RedirectToAction("Login");
}
if (!authenticationService.SignIn(username, password))
{
AddErrorMessage("Invalid Login");
return RedirectToAction("Login");
}
if (redirectUrl != null)
return Redirect(redirectUrl);
return RedirectToAction("Index", "Account");
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractFormRelatedHelper"/> class.
/// </summary>
/// <param name="validatorRegistry">The validator registry.</param>
/// <param name="validatorRunner">The validator runner.</param>
protected AbstractFormRelatedHelper(IValidatorRegistry validatorRegistry, ValidatorRunner validatorRunner)
{
this.validatorRegistry = validatorRegistry;
this.validatorRunner = validatorRunner;
}
public void AccountInformation([DataBind("Register")] AccountInformationViewModel viewModel)
{
ValidatorRunner runner = new ValidatorRunner(new CachedValidationRegistry());
if (runner.IsValid(viewModel))
{
Session["AccountInfo"] = viewModel;
RedirectToAction("PersonalInformation");
}
else
{
var summary = runner.GetErrorSummary(viewModel);
Flash["summary"] = summary;
Flash["Register"] = viewModel;
}
}
public ActionResult Register(RegistrationData registrationData)
{
var validationRunner = new ValidatorRunner(new CachedValidationRegistry());
if (!validationRunner.IsValid(registrationData))
{
// there were errors, report them back to the user
foreach (var errorMessage in validationRunner.GetErrorSummary(registrationData).ErrorMessages)
AddErrorMessage(errorMessage);
TempData.Add(registrationData);
return RedirectToAction("Register");
}
Member member = memberService.GetByUsername(registrationData.UserName);
if (member != null)
{
userSession.PushUserMessage(FlashMessage.MessageType.Error, "A user with that username already exists, please try again");
TempData.Add(registrationData);
return RedirectToAction("Register");
}
member = new Member
{
Username = registrationData.UserName,
Email = registrationData.Email,
PasswordSalt = cryptographer.CreateSalt(),
FirstName = registrationData.FirstName,
LastName = registrationData.LastName
};
member.Password = cryptographer.Hash(registrationData.Password, member.PasswordSalt);
memberService.Add(member);
authenticator.SignIn(member);
return RedirectToAction("Index");
}
/// <summary>
/// Creates the validator runner.
/// </summary>
/// <returns></returns>
protected virtual IValidatorRunner CreateRunner()
{
IValidationContributor[] contributors = new IValidationContributor[] { contributor };
IValidatorRunner runner = new ValidatorRunner(contributors, new CachedValidationRegistry());
return runner;
}
public void PersonalInformation([DataBind("Personal")] PersonalInformationViewModel viewModel)
{
Flash["categories"] = Category.All;
var runner = new ValidatorRunner(new CachedValidationRegistry());
if (runner.IsValid(viewModel))
{
Session["PersonalInfo"] = viewModel;
RedirectToAction("Thanks");
}
else
{
Flash["Personal"] = viewModel;
Flash["summary"] = runner.GetErrorSummary(viewModel);
}
}
/// <summary>
/// Initializes this instance. Implementors
/// can use this method to perform initialization
/// </summary>
protected virtual void Initialize()
{
IValidatorRegistry validatorRegistry =
(IValidatorRegistry) serviceProvider.GetService(typeof(IValidatorRegistry));
validator = CreateValidatorRunner(validatorRegistry);
}
protected void OnSaveButtonClicked (object sender, System.EventArgs e)
{
mycase.Name = nameEntry.Text;
mycase.start_date = startDateSelector.SelectedDate ();
mycase.StartDateType = startDateSelector.SelectedDateType ();
mycase.AffectedPeople = System.Convert.ToInt32(affectedPeople.Text);
mycase.end_date = endDateSelector.SelectedDate ();
mycase.EndDateType = endDateSelector.SelectedDateType ();
mycase.NarrativeDescription = description.Text;
mycase.Summary = summary.Text;
mycase.Observations = observations.Text;
if (mycase.IsValid())
{
mycase.SaveAndFlush ();
this.IsEditing = false;
if (CaseSaved != null)
CaseSaved (mycase, e);
} else {
ResourceManager mgr = new ResourceManager("Castle.Components.Validator.Messages", Assembly.GetAssembly(typeof(Castle.Components.Validator.CachedValidationRegistry)));
var runner = new ValidatorRunner(new CachedValidationRegistry(mgr));
if (runner.IsValid(mycase) || !runner.HasErrors(mycase)) return;
//var summary = runner.GetErrorSummary(mycase);
Console.WriteLine( String.Join(",", mycase.ValidationErrorMessages) );
new ValidationErrorsDialog (mycase.PropertiesValidationErrorMessages, (Gtk.Window)this.Toplevel);
}
}
/// <summary>
/// Builds all of the validators for a given method, parameter position, with the defined RunWhen.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="parameterPosition">The parameter position.</param>
/// <param name="runner">The runner.</param>
/// <param name="runWhen">The run when.</param>
/// <param name="parameterInfoMeta">Metadata about the parameters such as whether or not it is params</param>
/// <returns></returns>
public IValidator[] GetValidatorsFor(MethodInfo method, int parameterPosition, ValidatorRunner runner, RunWhen runWhen,
out ParameterInfoMeta parameterInfoMeta)
{
MethodValidatorMetaInfo meta = type2MetaInfo[method.DeclaringType];
List<IValidator> validators = new List<IValidator>();
IValidatorBuilder[] builders = meta.GetBuilders(method, parameterPosition, out parameterInfoMeta);
ParameterInfo[] parameters = method.GetParameters();
foreach (IValidatorBuilder builder in builders)
{
IValidator validator = builder.Build(runner, typeof(MethodInfo));
if (!IsValidatorOnPhase(validator, runWhen)) continue;
if (string.IsNullOrEmpty(validator.FriendlyName))
validator.FriendlyName = parameters[parameterPosition].Name;
validator.Initialize(registry, null);
validators.Add(validator);
}
return validators.ToArray();
}