public void NegatedReturnsFailureForStringShorterThanMaxLengthForMaxLengthOnlyValidator()
{
Validator<string> validator = new StringLengthValidator(10, true);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString());
Assert.IsFalse(validationResults.IsValid);
}
public void ReturnFailureForNullStringThroughNonGenericInterface()
{
Validator<string> validator = new StringLengthValidator(1, 10);
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
}
public void ReturnsSuccessForStringAsLongAsMaxLengthForMaxLengthOnlyValidator()
{
Validator<string> validator = new StringLengthValidator(10);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 10).ToString());
Assert.IsTrue(validationResults.IsValid);
}
public void ConstructorWithBoundsAndBoundTypesAndMessageOverrideAndNegatedInitializesAppropriateInstance()
{
StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, "message template override", true);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType);
Assert.AreEqual("message template override", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void ConstructorWithBoundsAndBoundTypesAndNullMessageOverrideInitializesAndNegatedAppropriateInstanceWithDefaultMessage()
{
StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, null, true);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType);
Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void StringLengthValidator_WhenStringIsLongerThanMaxLength_IsValid()
{
const string INPUT = "a test string";
const bool EXPECTED = false;
StringLengthValidator validator = new StringLengthValidator(10);
bool result = validator.IsValid(INPUT);
Assert.AreEqual(EXPECTED, result);
}
public void ReturnsFailureForStringLongerThanMaxLengthForMaxLengthOnlyValidator()
{
Validator <string> validator = new StringLengthValidator(10);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString());
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void StringLengthValidator_WhenStringIsSmaller_IsValid()
{
const string INPUT = "a test";
const bool EXPECTED = true;
const int MAX_LENGTH = 13;
StringLengthValidator validator = new StringLengthValidator(MAX_LENGTH);
bool result = validator.IsValid(INPUT);
Assert.AreEqual(EXPECTED, result);
}
public void GetErrors_returns_error_for_length_greater_than_max()
{
var validator = new StringLengthValidator(10);
var errors = validator.GetErrors("12345678901").ToArray();
Assert.Equal(1, errors.Length);
var error = errors[0];
Assert.IsType <StringLengthValidationError>(error);
Assert.Equal(10, ((StringLengthValidationError)error).MaxLength);
}
public int TestValidation(string value, int minimumLength, int maximumLength)
{
// Arrange.
var validator = new StringLengthValidator<TestEntity>(minimumLength, maximumLength)
{
AllowNull = true
};
var instance = new TestEntity();
var context = DocumentValidationContext<TestEntity>.Create(instance, SaveType.Any);
// Act.
return validator.Validate(value, context).Count();
}
public int TestValidation(string value, int minimumLength, int maximumLength)
{
// Arrange.
var validator = new StringLengthValidator <TestEntity>(minimumLength, maximumLength)
{
AllowNull = true
};
var instance = new TestEntity();
var context = DocumentValidationContext <TestEntity> .Create(instance, SaveType.Any);
// Act.
return(validator.Validate(value, context).Count());
}
public void Should_Return_Valid_When_String_Is_Forty_Character_Long() {
// Arrange
var validator = new StringLengthValidator(40);
// Act
var result = validator.IsValid(new string('A', 40));
// Assert
result.ShouldNotBeNull();
result.Valid.ShouldBeTrue();
result.ErrorMessages.ShouldNotBeNull();
result.ErrorMessages.ShouldBeEmpty();
}
public IActionResult Index(StringLengthValidator model, string btnAction)
{
if (btnAction == "Submit")
{
if (ModelState.IsValid)
{
ViewBag.comment = model.comment;
}
}
if (btnAction == "Reset")
{
ModelState.Clear();
}
return(View());
}
public void Should_Return_Invalid_When_String_Lenghts_Dont_Match() {
// Arrange
var validator = new StringLengthValidator(40);
// Act
var result = validator.IsValid(new string('A', 39));
// Assert
result.ShouldNotBeNull();
result.Valid.ShouldBeFalse();
result.ErrorMessages.ShouldNotBeNull();
result.ErrorMessages.Count.ShouldEqual(1);
result.ErrorMessages.Single().ParamName.ShouldEqual("input");
result.ErrorMessages.Single().Message.ShouldEqual("Length of input string does not match expected. Expected: 40. Actual: 39.");
}
/// <summary>
/// String Length
/// </summary>
/// <typeparam name="T">DataType</typeparam>
/// <param name="maxLength">max length</param>
/// <param name="minLength">min length</param>
/// <param name="fields">fields</param>
public static void StringLength <T>(int maxLength, int minLength = 0, params ValidationField <T>[] fields)
{
string validatorKey = string.Format("{0}/{1}_{2}", typeof(StringLengthValidator).FullName, maxLength, minLength);
DataValidator validator = null;
if (_validatorList.ContainsKey(validatorKey))
{
validator = _validatorList[validatorKey];
}
else
{
validator = new StringLengthValidator(maxLength, minLength);
_validatorList.Add(validatorKey, validator);
}
SetValidation <T>(validator, fields);
}
public void AttributeWithUpperBoundOnlyCreatesAppropriateValidator()
{
ValidatorAttribute attribute = new StringLengthValidatorAttribute(20);
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
StringLengthValidator stringLengthValidator = validator as StringLengthValidator;
Assert.IsNotNull(stringLengthValidator);
Assert.AreEqual(RangeBoundaryType.Ignore, stringLengthValidator.LowerBoundType);
Assert.AreEqual(20, stringLengthValidator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.UpperBoundType);
Assert.AreEqual(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, stringLengthValidator.MessageTemplate);
Assert.AreEqual(false, stringLengthValidator.Negated);
}
public async Task InternValidators() {
await _emTask;
var vr2 = new RequiredValidator().Intern();
var vr3 = new RequiredValidator().Intern();
Assert.IsTrue(vr2 == vr3);
Assert.IsTrue(vr2.Equals(vr3));
var mlVr2 = new MaxLengthValidator(17).Intern();
var mlVr3 = new MaxLengthValidator(17).Intern();
Assert.IsTrue(mlVr2 == mlVr3);
Assert.IsTrue(mlVr2.Equals(mlVr3));
var slVr2 = new StringLengthValidator(3, 12).Intern();
var slVr3 = new StringLengthValidator(3, 12).Intern();
Assert.IsTrue(slVr2 == slVr3);
Assert.IsTrue(slVr2.Equals(slVr3));
}
public StringLengthValidatorOperation(
string keyToValidate,
string resultKey,
int lowerBound,
RangeBoundaryType lowerBoundaryType,
int upperBound,
RangeBoundaryType upperBoundaryType,
bool negated)
: base(keyToValidate, resultKey)
{
Validator = new StringLengthValidator(
lowerBound,
lowerBoundaryType,
upperBound,
upperBoundaryType,
string.Empty,
negated
);
}
public StringLengthValidatorOperation(
string keyToValidate,
string resultKey,
int lowerBound,
RangeBoundaryType lowerBoundaryType,
int upperBound,
RangeBoundaryType upperBoundaryType,
bool negated)
: base(keyToValidate, resultKey) {
Validator = new StringLengthValidator(
lowerBound,
lowerBoundaryType,
upperBound,
upperBoundaryType,
string.Empty,
negated
);
}
public void AttributeWithLowerAndUpperBoundsAndBoundTypesAndMessageTemplateCreatesAppropriateValidator()
{
ValidatorAttribute attribute = new StringLengthValidatorAttribute(10, RangeBoundaryType.Exclusive, 0, RangeBoundaryType.Ignore);
attribute.MessageTemplate = "my message template";
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
StringLengthValidator stringLengthValidator = validator as StringLengthValidator;
Assert.IsNotNull(stringLengthValidator);
Assert.AreEqual(10, stringLengthValidator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, stringLengthValidator.LowerBoundType);
Assert.AreEqual(0, stringLengthValidator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Ignore, stringLengthValidator.UpperBoundType);
Assert.AreEqual("my message template", stringLengthValidator.MessageTemplate);
Assert.AreEqual(false, stringLengthValidator.Negated);
}
public void AttributeWithLowerAndUpperBoundsOnlyAndNegatedCreatesAppropriateValidator()
{
ValueValidatorAttribute attribute = new StringLengthValidatorAttribute(10, 20);
attribute.Negated = true;
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
StringLengthValidator stringLengthValidator = validator as StringLengthValidator;
Assert.IsNotNull(stringLengthValidator);
Assert.AreEqual(10, stringLengthValidator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.LowerBoundType);
Assert.AreEqual(20, stringLengthValidator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.UpperBoundType);
Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, stringLengthValidator.MessageTemplate);
Assert.AreEqual(true, stringLengthValidator.Negated);
}
public void CreateColumn()
{
var finalMember = Member.FinalMemberInfo;
Column = new Column()
{
Table = DataType.Table,
Name = Member.Expression.Replace('.', '_'),
DbType = Sql.DbTypeMapper.Parse(MemberExpression.GetReturnType(finalMember)),
IsNullable = !RequiredValidator.IsRequired(finalMember),
IsPrimaryKey = IsPrimaryKey(finalMember),
};
Column.IsAutoNumber = Column.IsNumeric && Column.IsPrimaryKey && DataType.BaseDataType == null;
if (Column.IsString)
{
Column.Length = StringLengthValidator.GetMaxLength(finalMember);
}
DataType.Table.Columns.Add(Column);
}
public async Task InternValidators()
{
var em1 = await TestFns.NewEm(_serviceName);
var vr2 = new RequiredValidator().Intern();
var vr3 = new RequiredValidator().Intern();
Assert.IsTrue(vr2 == vr3);
Assert.IsTrue(vr2.Equals(vr3));
var mlVr2 = new MaxLengthValidator(17).Intern();
var mlVr3 = new MaxLengthValidator(17).Intern();
Assert.IsTrue(mlVr2 == mlVr3);
Assert.IsTrue(mlVr2.Equals(mlVr3));
var slVr2 = new StringLengthValidator(3, 12).Intern();
var slVr3 = new StringLengthValidator(3, 12).Intern();
Assert.IsTrue(slVr2 == slVr3);
Assert.IsTrue(slVr2.Equals(slVr3));
}
public void NegatedReturnsSuccessForValidationForNonStringTargetThroughNonGenericInterface()
{
Validator validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true);
Assert.IsFalse(validator.Validate(3).IsValid);
}
public void ConstructorWithBoundsAndBoundTypesAndNullMessageOverrideInitializesAndNegatedAppropriateInstanceWithDefaultMessage()
{
StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, null, true);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType);
Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
/// <summary>
/// Creates a field for a DataMember
/// </summary>
public FormField AddField(MemberInfo member)
{
//if there's no values defined, exit
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
//field
FormField field;
Type returnType = MemberExpression.GetReturnType(member);
//String
if (returnType.Equals(typeof(string)))
{
field = new StringField();
//set max lenght, if defined
int maxLenght = (int)StringLengthValidator.GetMaxLength(member);
if (maxLenght == 0)
{
field.TableWide = true;
}
else
{
((StringField)field).MaxLenght = maxLenght;
}
//set regular expression validation, if defined
var regex = member.CustomAttributes.Where(att => att.AttributeType.Equals(typeof(RegexValidator))).SingleOrDefault();
if (regex != null)
{
((StringField)field).RegularExpression = (string)regex.ConstructorArguments[0].Value;
}
}
//DataType
else if (returnType.Equals(typeof(DataType)))
{
field = new DataTypeField();
}
//otherwise delegate to the static method to create the field from the return type
else
{
field = CreateField(returnType);
}
field.Name = member.Name;
field.Container = this;
field.Required = RequiredValidator.IsRequired(member);
field.CaptionControl.Text = Translator.Translate(member);
//if (member.Column.IsPrimaryKey) field.SortOrder = 0;
//add to fields collection
Fields.Add(field);
return(field);
}
public void NegatedReturnsFailureForStringShorterThanLowerBound()
{
Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 3).ToString());
Assert.IsTrue(validationResults.IsValid);
}
public void CreateValidationMetadata(ValidationMetadataProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Key.ContainerType != null && !context.Key.ContainerType.IsValueType)
{
var viewConfig = ServiceLocator.GetViewConfigure(context.Key.ContainerType);
if (viewConfig != null && context.Key.Name.IsNotNullAndWhiteSpace())
{
var descriptor = viewConfig.GetViewPortDescriptor(context.Key.Name);
if (descriptor != null)
{
descriptor.Validator.Each(v =>
{
if (v.DisplayName == null)
{
v.DisplayName = () => descriptor.DisplayName;
}
string encodeError = Convert.ToBase64String(JsonConvert.SerializeObject(new Mapping(v.Name, v.Property)).ToByte());
if (v is RangeValidator)
{
RangeValidator valid = (RangeValidator)v;
RangeAttribute range = new RangeAttribute(valid.Min, valid.Max);
range.ErrorMessage = encodeError;
context.ValidationMetadata.ValidatorMetadata.Add(range);
}
else if (v is RegularValidator)
{
RegularValidator valid = (RegularValidator)v;
RegularExpressionAttribute regular = new RegularExpressionAttribute(valid.Expression);
regular.ErrorMessage = encodeError;
context.ValidationMetadata.ValidatorMetadata.Add(regular);
}
else if (v is RemoteValidator)
{
RemoteValidator valid = (RemoteValidator)v;
RemoteAttribute remote = new RemoteAttribute(valid.Action, valid.Controller, valid.Area);
remote.ErrorMessage = encodeError;
context.ValidationMetadata.ValidatorMetadata.Add(remote);
}
else if (v is RequiredValidator)
{
RequiredValidator valid = (RequiredValidator)v;
RequiredAttribute required = new RequiredAttribute();
required.ErrorMessage = encodeError;
context.ValidationMetadata.ValidatorMetadata.Add(required);
}
else if (v is StringLengthValidator)
{
StringLengthValidator valid = (StringLengthValidator)v;
StringLengthAttribute stringLength = new StringLengthAttribute(valid.Max);
stringLength.ErrorMessage = encodeError;
context.ValidationMetadata.ValidatorMetadata.Add(stringLength);
}
});
}
}
}
}
public void ReturnsSuccessForStringWithLengthOneShoterThanLowerBoundIfLUpperBoundIsInclusive()
{
Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 9).ToString());
Assert.IsTrue(validationResults.IsValid);
}
public void ConstructorWithBoundsAndBoundTypesAndMessageOverrideAndNegatedInitializesAppropriateInstance()
{
StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, "message template override", true);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType);
Assert.AreEqual("message template override", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void ConstructorWithBoundsAndBoundTypesInitializesAppropriateInstance()
{
StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType);
Assert.AreEqual(false, validator.Negated);
}
public StringLengthModelValidator(EasyModelMetaData metadata, ControllerContext context, StringLengthValidator stringlengthvalidator)
: base(metadata, context)
{
minLength = stringlengthvalidator.Min;
this.Attribute = new StringLengthAttribute(stringlengthvalidator.Max);
//this.Attribute.ErrorMessageResourceType = Metadata.ContainerType;
//this.Attribute.ErrorMessageResourceName = Metadata.PropertyName;
this.Attribute.ErrorMessage = stringlengthvalidator.ErrorMessage;
}
public void SuppliesAppropriateParametersToDefaultNegatedMessage()
{
StringLengthValidator validator = new StringLengthValidator(10, RangeBoundaryType.Exclusive, 20, RangeBoundaryType.Inclusive, true);
validator.Tag = "tag";
object target = "not so short";
string key = "key";
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, null, key, validationResults);
Assert.IsFalse(validationResults.IsValid);
ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);
Assert.IsTrue(match.Success);
Assert.IsFalse(match.Groups["param0"].Success);
Assert.IsFalse(match.Groups["param1"].Success);
Assert.IsFalse(match.Groups["param2"].Success);
Assert.IsTrue(match.Groups["param3"].Success);
Assert.AreEqual("10", match.Groups["param3"].Value);
Assert.IsTrue(match.Groups["param4"].Success);
Assert.AreEqual("Exclusive", match.Groups["param4"].Value);
Assert.IsTrue(match.Groups["param5"].Success);
Assert.AreEqual("20", match.Groups["param5"].Value);
Assert.IsTrue(match.Groups["param6"].Success);
Assert.AreEqual("Inclusive", match.Groups["param6"].Value);
}
public void NegatedReturnsFailureForStringAsLongAsMinLengthForMinAndMaxLengthValidator()
{
Validator<string> validator = new StringLengthValidator(5, 10, true);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString());
Assert.IsFalse(validationResults.IsValid);
}
public void NegatedReturnsSuccessForValidationForNonStringTargetThroughNonGenericInterface()
{
Validator validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true);
Assert.IsFalse(validator.Validate(3).IsValid);
}
public void ReturnsFailureForStringWithLengthOneLongerThanUpperBoundIfUpperBoundIsExclusive()
{
Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Exclusive);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString());
Assert.IsFalse(validationResults.IsValid);
}
/// <summary>
/// Creates a list of new DataTypes, creating as well a list of new Tables with all members of type as columns
/// </summary>
public static IEnumerable <DataType> DefaultMap(IEnumerable <Type> types)
{
//we will store here all types that are actually persistent
List <DataType> persistentTypes = new List <DataType>();
Random random = new Random();
//map primary keys first, so we allow to foreign keys and inheritance to be correctly mapped
foreach (Type type in types)
{
//skip enums and interfaces
if (type.GetTypeInfo().IsEnum || type.GetTypeInfo().IsInterface)
{
continue;
}
//ignore types with no primary key
var pk = GetMappableMembers(type).Where(m => DataMember.IsPrimaryKey(m));
if (pk.Count() == 0)
{
continue;
}
DataType dtype = new DataType(type);
AllDataTypes.Add(dtype);
foreach (var memberInfo in pk)
{
//create datamember
dtype.AddMember(memberInfo.Name);
}
persistentTypes.Add(dtype);
}
foreach (DataType dtype in persistentTypes)
{
//create inheritance foreign keys
if (dtype.BaseDataType != null)
{
ForeignKey foreignKey = new ForeignKey();
foreignKey.Table = dtype.Table;
foreignKey.RemoteTable = dtype.BaseDataType.Table;
foreignKey.Name = "FK_" + dtype.Name + "_" + dtype.BaseDataType.Name + "_" + random.Next();
//we asume that primary keys on parent and child tables have the same number and order of related columns
for (int i = 0; i < dtype.PrimaryKey.Count(); i++)
{
DataMember pk = dtype.PrimaryKey.ToArray()[i];
DataMember basePk = dtype.BaseDataType.PrimaryKey.ToArray()[i];
foreignKey.Columns.Add(new Tuple <Column, Column>(pk.Column, basePk.Column));
}
dtype.Table.ForeignKeys.Add(foreignKey);
}
//map non primary key members now
foreach (var memberInfo in GetMappableMembers(dtype.InnerType).Where(m => !DataMember.IsPrimaryKey(m)))
{
Type returnType = MemberExpression.GetReturnType(memberInfo);
//is this a collection of a mapped type? if so, ignore since this must be a 1-1, 1-many or many-many relationship and must be mapped somewhere else
if (DataType.IsCollection(returnType) && IsMapped(returnType.GetCollectionItemType()))
{
continue;
}
//its a persistent type, with it's own table, map as a foreign key with one or more columns for the primary key
if (IsMapped(returnType))
{
//we asume this datatype is already mapped along with it's primery key
DataType returnDataType = returnType;
ForeignKey foreignKey = new ForeignKey();
foreignKey.Table = dtype.Table;
foreignKey.RemoteTable = returnDataType.Table;
foreignKey.Name = "FK_" + dtype.Name + "_" + memberInfo.Name + "_" + random.Next();
foreach (DataMember pk in returnDataType.PrimaryKey.ToList())
{
Column column = new Column();
column.Name = memberInfo.Name + "_" + pk.Member.Expression.Replace('.', '_');
column.Table = dtype.Table;
column.IsPrimaryKey = false;
column.IsNullable = !RequiredValidator.IsRequired(memberInfo);
column.DbType = DbTypeMapper.Parse(pk.Member.ReturnType);
if (column.IsString)
{
column.Length = StringLengthValidator.GetMaxLength(pk.Member.FinalMemberInfo);
}
dtype.Table.Columns.Add(column);
foreignKey.Columns.Add(new Tuple <Column, Column>(column, pk.Column));
//create datamember
dtype.AddMember(memberInfo.Name + "." + pk.Member, column);
}
dtype.Table.ForeignKeys.Add(foreignKey);
}
//just map as a atomic value
else
{
Column column = new Column();
column.Name = memberInfo.Name;
column.Table = dtype.Table;
column.IsNullable = !RequiredValidator.IsRequired(memberInfo);
column.IsPrimaryKey = false;
//create datamember
DataMember dmember = dtype.AddMember(memberInfo.Name, column);
//is this a regular atomic value?
if (DbTypeMapper.DbTypeMap.ContainsValue(returnType) && returnType != typeof(object))
{
column.DbType = DbTypeMapper.Parse(returnType);
}
else if (returnType.GetTypeInfo().IsEnum)
{
column.DbType = DbType.Int32;
}
//this is an non-atomic object, but its not mapped as a DataType, so we serialize it as json
else
{
column.DbType = DbType.String;
dmember.Converter = new Conversions.Json <object>();
}
if (column.IsString)
{
column.Length = Data.Validation.StringLengthValidator.GetMaxLength(memberInfo);
}
dtype.Table.Columns.Add(column);
}
}
yield return(dtype);
}
}
static void Main(string[] args)
{
var lengthValidator = new StringLengthValidator(18);
var regexValidator = new RegexStringValidator("^[A-Z ]+$");
var rangeRaceMarginValidator = new RangeDecimalValidator(110, 140);
var numOfRunnersValidator = new RangeIntValidator(4, 16);
int capacity;
ValidateResult rangeResult;
do
{
Console.WriteLine("How many runners do you want for the race [4-16]:");
var numOfRunners = Console.ReadLine();
int.TryParse(numOfRunners, out capacity);
rangeResult = numOfRunnersValidator.Validate(capacity);
if (!rangeResult.Succeeded)
{
Console.WriteLine(string.Concat(rangeResult.Errors.Select(e => e)));
Console.WriteLine();
}
} while (capacity == 0 || !rangeResult.Succeeded);
var runners = new IRunner[capacity];
Console.WriteLine();
for (int i = 0; i < capacity; i++)
{
var currentRunnerId = i + 1;
ValidateResult lengthResult;
ValidateResult regexResult;
var runnerName = string.Empty;
do
{
Console.WriteLine($"Please give me the name of runner{currentRunnerId}:");
runnerName = Console.ReadLine();
lengthResult = lengthValidator.Validate(runnerName);
regexResult = regexValidator.Validate(runnerName);
if (!lengthResult.Succeeded)
{
Console.WriteLine(string.Concat(lengthResult.Errors.Select(e => e)));
}
if (!regexResult.Succeeded)
{
Console.WriteLine(string.Concat(regexResult.Errors.Select(e => e)));
}
Console.WriteLine();
} while (!lengthResult.Succeeded || !regexResult.Succeeded);
var fractionIsValid = true;
do
{
Console.WriteLine($"Please give me the fractional odd for runner{currentRunnerId}:");
var fractionalOdd = Console.ReadLine();
try
{
var fraction = new Fraction(fractionalOdd);
var runner = new Runner(runnerName, fraction);
runners[i] = runner;
fractionIsValid = true;
}
catch (InvalidFractionException ex)
{
fractionIsValid = false;
Console.WriteLine(ex.Message);
Console.WriteLine();
}
} while (fractionIsValid == false);
Console.WriteLine();
}
var calculator = new RaceMarginCalculator();
IRace race = new Race(runners, calculator);
var raceMargin = race.CalculateRaceMargin();
Console.WriteLine(raceMargin);
ValidateResult raceMarginResult = rangeRaceMarginValidator.Validate(raceMargin);
if (!raceMarginResult.Succeeded)
{
Console.WriteLine(string.Concat(raceMarginResult.Errors.Select(e => e)));
}
Console.WriteLine();
race.CalculateRunnersWinningPercentage();
var appearances = new List <RunnerAppearance>();
foreach (var runner in runners)
{
appearances.Add(new RunnerAppearance(runner.Name, runner.WinningPercentage, 0));
}
string menuOption;
do
{
Console.WriteLine();
Console.WriteLine("============Menu==============");
Console.WriteLine();
Console.WriteLine("Choose P to pick a winner (P)");
Console.WriteLine("Choose A to display the number of appearances for each runner based on winning percentage (A)");
Console.WriteLine("Choose W to display the winning percentage for each runner (A)");
Console.WriteLine("Choose Q to exit (Q)");
Console.WriteLine();
Console.WriteLine("Select an option:");
menuOption = Console.ReadLine();
var rnd = new Random();
switch (menuOption)
{
case "P":
Console.WriteLine();
Console.WriteLine("Please select how many iterations do you want ?");
Console.WriteLine();
Console.WriteLine("Select 1 for 1 iteration (1):");
Console.WriteLine("Select 10 for 10 iterations (10):");
Console.WriteLine("Select 100 for 100 iterations (100):");
Console.WriteLine("Select 1,000 for 1,000 iterations (1,000):");
Console.WriteLine("Select 10,000 for 10,000 iterations (10,000):");
Console.WriteLine("Select 100,000 for 100,000 iterations (100,000):");
Console.WriteLine("Select 1,000,000 for 1,000,000 iterations (1,000,000):");
menuOption = Console.ReadLine();
int.TryParse(menuOption, out int iterations);
switch (menuOption)
{
case "1":
case "10":
case "100":
case "1000":
case "10000":
case "100000":
case "1000000":
for (int i = 0; i < iterations; i++)
{
var randomNum = rnd.Next(1, 101);
PickWinner(randomNum, race, appearances);
}
break;
default:
break;
}
break;
case "A":
DisplayRunnerAppearances(appearances);
break;
case "W":
DisplayWinningPercentages(runners);
break;
case "Q":
break;
}
} while (menuOption != null && !menuOption.Equals("Q"));
Environment.Exit(0);
Console.ReadKey();
}
public void NegatedReturnsFailureForStringWithLengthEqualToLowerBoundIfLowerBoundIsInclusive()
{
Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString());
Assert.IsFalse(validationResults.IsValid);
}
private string ToHtmlString(bool widthLabel)
{
if (string.IsNullOrEmpty(this.DisplayName))
{
this.DisplayName = this.Name;
}
string val = this.Value == null ? "" : this.Value.ToString().HtmlEncode();
StringBuilder builder = new StringBuilder();
if (widthLabel && this.TagType != HTMLEnumerate.HTMLTagTypes.Hidden && !this.IsHidden && !this.IsIgnore)
{
builder.AppendFormat("<span class=\"input-group-addon {1}\">{0}</span>", this.DisplayName, this.IsRequired ? "required" : "");
}
if (this.TagType == HTMLEnumerate.HTMLTagTypes.File)
{
builder.AppendFormat("<input type=\"hidden\" name=\"{0}{1}\" id=\"{0}{1}\" value=\"{2}\" />", this.NamePreFix, this.Name, val);
}
builder.Append(StartStr);
switch (this.TagType)
{
case HTMLEnumerate.HTMLTagTypes.PassWord:
case HTMLEnumerate.HTMLTagTypes.Input:
case HTMLEnumerate.HTMLTagTypes.Hidden: builder.AppendFormat(" value=\"{0}\" ", val); break;
case HTMLEnumerate.HTMLTagTypes.CheckBox:
{
bool check = false;
if (val == "")
{
check = false;
}
else
{
check = Convert.ToBoolean(val);
}
builder.AppendFormat(" {0} ", check ? "checked=\"checked\"" : "");
builder.Append(" value=\"true\" ");
break;
}
}
builder.AppendFormat(" id=\"{1}{0}\" name=\"{1}{0}\"", this.Name, this.NamePreFix);
if (Validator.Count > 0)
{
this.AddProperty("data-val", "true");
}
foreach (ValidatorBase item in Validator)
{
item.DisplayName = this.DisplayName;
if (item is RequiredValidator)
{
this.AddProperty("data-val-required", item.ErrorMessage);
this.AddClass("required");
}
else if (item is RegularValidator)
{
this.AddProperty("data-val-regex", item.ErrorMessage);
this.AddProperty("data-val-regex-pattern", (item as RegularValidator).Expression);
}
else if (item is RemoteValidator)
{
RemoteValidator temp = item as RemoteValidator;
this.AddProperty("data-val-remote", temp.ErrorMessage);
this.AddProperty("data-val-remote-additionalfields", temp.AdditionalFields);
this.AddProperty("data-val-remote-type", "");
this.AddProperty("data-val-remote-url", temp.Url);
}
else if (item is RangeValidator)
{
RangeValidator temp = item as RangeValidator;
this.AddProperty("data-val-range", temp.ErrorMessage);
this.AddProperty("data-val-range-max", temp.Max.ToString());
this.AddProperty("data-val-range-min", temp.Min.ToString());
}
else if (item is StringLengthValidator)
{
StringLengthValidator temp = item as StringLengthValidator;
this.AddProperty("data-val-length", temp.ErrorMessage);
this.AddProperty("data-val-length-max", temp.Max.ToString());
}
}
foreach (var item in this.Properties)
{
builder.AppendFormat(" {0}=\"{1}\"", item.Key, item.Value);
}
if (Styles.Count > 0)
{
builder.Append(" style=\"");
foreach (var item in Styles)
{
builder.AppendFormat("{0}:{1};", item.Key, item.Value);
}
builder.Append("\"");
}
if (Classes.Count > 0)
{
builder.Append(" class=\"");
int i = 0;
foreach (var item in Classes)
{
if (i == 0)
{
builder.AppendFormat("{0}", item);
}
else
{
builder.AppendFormat(" {0}", item);
}
i++;
}
builder.Append("\"");
}
builder.Append(EndStr);
if (!this.IsHidden && this.TagType != HTMLEnumerate.HTMLTagTypes.Hidden)
{
builder.AppendFormat(errorMsgPlace, this.Name);
}
return(builder.ToString());
}
public void ConstructorWithUpperBoundOnlyInitializesAppropriateInstance()
{
StringLengthValidator validator = new StringLengthValidator(10);
Assert.AreEqual(0, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Ignore, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, validator.UpperBoundType);
Assert.AreEqual(false, validator.Negated);
}
public void ReturnsFailureForStringLongerThanMaxLengthForMaxLengthOnlyValidator()
{
Validator<string> validator = new StringLengthValidator(10);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString());
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void ConstructorWithLowerAndUpperBoundAndNegatedInitializesAppropriateInstance()
{
StringLengthValidator validator = new StringLengthValidator(5, 10, true);
Assert.AreEqual(5, validator.LowerBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, validator.LowerBoundType);
Assert.AreEqual(10, validator.UpperBound);
Assert.AreEqual(RangeBoundaryType.Inclusive, validator.UpperBoundType);
Assert.AreEqual(true, validator.Negated);
}
public async Task InternValidators() {
var em1 = await TestFns.NewEm(_serviceName);
var vr2 = new RequiredValidator().Intern();
var vr3 = new RequiredValidator().Intern();
Assert.IsTrue(vr2 == vr3);
Assert.IsTrue(vr2.Equals(vr3));
var mlVr2 = new MaxLengthValidator(17).Intern();
var mlVr3 = new MaxLengthValidator(17).Intern();
Assert.IsTrue(mlVr2 == mlVr3);
Assert.IsTrue(mlVr2.Equals(mlVr3));
var slVr2 = new StringLengthValidator(3, 12).Intern();
var slVr3 = new StringLengthValidator(3, 12).Intern();
Assert.IsTrue(slVr2 == slVr3);
Assert.IsTrue(slVr2.Equals(slVr3));
}
public void ReturnsSuccessForStringLongerThanUpperBoundIfUpperBoundIsIgnored()
{
Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Ignore);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 12).ToString());
Assert.IsTrue(validationResults.IsValid);
}
