private static IEnumerable<Action<XmlWriter, ValidationOptions>> GetIntegerConstraints(ValidationOptions options, ApplicableOptions optsToUse)
{
var integerDigitsDefined = HasValue(options.IntegerDigits);
var fractionalDigitsDefined = HasValue(options.FractionalDigits);
var minValueDefined = HasValue(options.MinimumValue);
var maxValueDefined = HasValue(options.MaximumValue);
if (optsToUse.IsSet(ApplicableOptions.Value) && (minValueDefined || maxValueDefined))
{
yield return (w, p) =>
{
w.WriteStartElement("range", "urn:nhibernate-validator-1.0");
if (minValueDefined)
w.WriteAttributeString("min", p.MinimumValue.Value.ToString(CultureInfo.InvariantCulture));
if (maxValueDefined)
w.WriteAttributeString("max", p.MaximumValue.Value.ToString(CultureInfo.InvariantCulture));
w.WriteEndElement();
};
}
if (optsToUse.IsSet(ApplicableOptions.Digits) && (integerDigitsDefined || fractionalDigitsDefined))
{
yield return (w, p) =>
{
w.WriteStartElement("digits", "urn:nhibernate-validator-1.0");
if (integerDigitsDefined)
w.WriteAttributeString("integerDigits", p.IntegerDigits.Value.ToString(CultureInfo.InvariantCulture));
if (fractionalDigitsDefined)
w.WriteAttributeString("fractionalDigits", p.FractionalDigits.Value.ToString(CultureInfo.InvariantCulture));
w.WriteEndElement();
};
}
}
private static IEnumerable<Action<XmlWriter, ValidationOptions>> GetDateConstraints(ValidationOptions options, ApplicableOptions optsToUse)
{
if (!optsToUse.IsSet(ApplicableOptions.Date))
yield break;
if (options.PastDate.HasValue && options.PastDate == true)
yield return (w, p) => w.WriteElementString("past", "urn:nhibernate-validator-1.0", "");
if (options.FutureDate.HasValue && options.FutureDate == true)
yield return (w, p) => w.WriteElementString("future", "urn:nhibernate-validator-1.0", "");
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="p"></param>
public PropertyImpl(Property p)
{
name = p.Name;
if (!string.IsNullOrEmpty(name))
OldNames.Add(name);
type = p.Type;
nhibernateType = p.NHibernateType;
readOnly = p.ReadOnly;
options = new ValidationOptions(p.ValidationOptions);
//isVirtual = p.IsVirtual;
isKeyProperty = p.IsKeyProperty;
}
public void SetValidationOptions(ValidationOptions options)
{
Clear();
_options = options;
if (options == null) { return; }
Utility.SuspendPainting(this);
AddNode("nhv_validate", "Validate", "", InputTypes.Boolean, options.Validate, true,
delegate(object value) { _options.Validate = (bool)value; } );
AddNode("nhv_nullable", "Nullable", "Check if the property is not null", InputTypes.Boolean, options.Nullable, options.Nullable.HasValue,
delegate(object value) { _options.Nullable = (bool?)value; } );
AddNode("nhv_min_value", "Minimum Value", "Checks if the value >= value", InputTypes.Integer, options.MinimumValue, options.MinimumValue.HasValue,
delegate(object value) { _options.MinimumValue = (int?)value; } );
AddNode("nhv_max_value", "Maximum Value", "Checks if the value <= value", InputTypes.Integer, options.MaximumValue, options.MaximumValue.HasValue,
delegate(object value) { _options.MaximumValue = (int?)value; } );
AddNode("nhv_int_digits", "Integer Digits", "Checks if the property has no more than this number of integer digits", InputTypes.Integer, options.IntegerDigits, options.IntegerDigits.HasValue,
delegate(object value) { _options.IntegerDigits = (int?)value; } );
AddNode("nhv_frac_digits", "Fractional Digits", "Checks if the property has no more than this number of fractional digits", InputTypes.Integer, options.FractionalDigits, options.FractionalDigits.HasValue,
delegate(object value) { _options.FractionalDigits = (int?)value; } );
AddNode("nhv_not_empty", "Not Empty", "Check if the string property is not null nor empty", InputTypes.Boolean, options.NotEmpty, options.NotEmpty.HasValue,
delegate(object value) { _options.NotEmpty = (bool?)value; } );
AddNode("nhv_min_length", "Minimum Length", "Checks if the string length >= value", InputTypes.Integer, options.MinimumLength, options.MinimumLength.HasValue,
delegate(object value) { _options.MinimumLength = (int?)value; } );
AddNode("nhv_max_length", "Maximum Length", "Checks if the string length <= value", InputTypes.Integer, options.MaximumLength, options.MaximumLength.HasValue,
delegate(object value) { _options.MaximumLength = (int?)value; } );
AddNode("nhv_reg_exp", "Regular Expression", "Check if the property matches the regular expression given a match flag.", InputTypes.String, options.RegexPattern, !string.IsNullOrEmpty(options.RegexPattern),
delegate(object value) { _options.RegexPattern = value == null ? null : (string) value; } );
AddNode("nhv_past_date", "Past Date", "Check if the date is in the past", InputTypes.Boolean, options.PastDate, options.PastDate.HasValue,
delegate(object value) { _options.PastDate = (bool?) value; } );
AddNode("nhv_future_date", "Future Date", "Check if the date is in the future", InputTypes.Boolean, options.FutureDate, options.FutureDate.HasValue,
delegate(object value) { _options.FutureDate = (bool?) value; } );
SetNodeVisibility();
advTree1.ExpandAll();
Utility.ResumePainting(this);
}
public ValidationOptions(ValidationOptions o)
{
_fractionalDigits = o.FractionalDigits;
_futureDate = o.FutureDate;
_integerDigits = o.IntegerDigits;
_maximumLength = o.MaximumLength;
_minimumLength = o.MinimumLength;
_maximumValue = o.MaximumValue;
_minimumValue = o.MinimumValue;
_notEmpty = o.NotEmpty;
_nullable = o.Nullable;
_pastDate = o.PastDate;
_regexPattern = o.RegexPattern;
_validate = o.Validate;
}
public void SetValidationOptions(ValidationOptions options)
{
validationPropertyGrid1.SetValidationOptions(options);
}
public PropertyImpl()
{
ValidationOptions = new ValidationOptions();
}
private static IEnumerable<Action<XmlWriter, ValidationOptions>> GetStringConstraints(ValidationOptions options, ApplicableOptions optsToUse)
{
var maxLengthDefined = options.MaximumLength.HasValue && options.MaximumLength > 0 && options.MaximumLength < int.MaxValue;
var minLengthDefined = options.MinimumLength.HasValue && options.MinimumLength > 0 && options.MinimumLength < int.MaxValue;
var notEmptyDefined = options.NotEmpty.HasValue && options.NotEmpty.Value;
var regexDefined = !string.IsNullOrEmpty(options.RegexPattern);
if (optsToUse.IsSet(ApplicableOptions.NotEmpty) && notEmptyDefined)
yield return (w, p) => w.WriteElementString("not-empty", "urn:nhibernate-validator-1.0", "");
if (optsToUse.IsSet(ApplicableOptions.RegexPattern) && regexDefined)
{
yield return (w, p) =>
{
w.WriteStartElement("pattern", "urn:nhibernate-validator-1.0");
w.WriteAttributeString("regex", options.RegexPattern);
w.WriteEndElement();
};
}
if (optsToUse.IsSet(ApplicableOptions.Value) && (maxLengthDefined || minLengthDefined))
{
yield return (w, p) =>
{
w.WriteStartElement("length", "urn:nhibernate-validator-1.0");
if (maxLengthDefined)
w.WriteAttributeString("max", p.MaximumLength.ToString());
if (minLengthDefined)
w.WriteAttributeString("min", p.MinimumLength.ToString());
w.WriteEndElement();
};
}
}
private static IEnumerable<Action<XmlWriter, ValidationOptions>> GetObjectConstraints(ValidationOptions options, ApplicableOptions optsToUse)
{
if (optsToUse.IsSet(ApplicableOptions.Nullable) && options.Nullable.HasValue && options.Nullable == false)
yield return (w, p) => w.WriteElementString("not-null", "urn:nhibernate-validator-1.0", "");
if (optsToUse.IsSet(ApplicableOptions.Validate) && options.Validate)
yield return (w, p) => w.WriteElementString("valid", "urn:nhibernate-validator-1.0", "");
}
public PropertyImpl()
{
ValidationOptions = new ValidationOptions();
}
private void Clear()
{
Utility.SuspendPainting(this);
advTree1.Nodes.Clear();
_options = null;
Utility.ResumePainting(this);
}
