/// <summary>
/// Registers IbanNet services.
/// </summary>
/// <param name="services">The service collection.</param>
/// <param name="preserveStaticValidator"><see langword="true" /> to preserve the static validator in <see cref="Iban.Validator" />, or <see langword="false" /> to replace with the configured instance.</param>
/// <returns>The service collection extended with IbanNet services.</returns>
public static IServiceCollection AddIbanNet(this IServiceCollection services, bool preserveStaticValidator)
{
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
services.AddOptions();
services.TryAddTransient <DependencyResolverAdapter, ServiceProviderDependencyResolverAdapter>();
services.TryAddTransient <IIbanParser, IbanParser>();
services.TryAddSingleton <IIbanValidator>(s =>
{
IbanValidatorOptions options = s.GetRequiredService <IOptions <IbanValidatorOptions> >().Value;
var validator = new IbanValidator(options);
if (!preserveStaticValidator)
{
Iban.Validator = validator;
}
return(validator);
});
return(services);
}
public override bool IsValid(object value)
{
if (value == null)
{
return(true);
}
var valueAsAString = value as string;
if (valueAsAString == null)
{
return(true);
}
var validator = new IbanValidator();
var ibanWithoutWhitespace = Regex.Replace(valueAsAString, @"\s+", "");
var ibanValidationResult = validator.Validate(ibanWithoutWhitespace);
if (ibanValidationResult == IbanValidationResult.IsValid)
{
return(true);
}
return(false);
}
static void Main()
{
Console.WriteLine("1. Validate using Library");
Console.WriteLine("2. Validate using regex");
string input = Console.ReadLine();
Console.WriteLine("enter IBAN");
string IBAN = Console.ReadLine();
if (input == "1")
{
IIbanValidator validator = new IbanValidator();
ValidationResult validationResult = validator.Validate(IBAN);
if (validationResult.IsValid)
{
Console.WriteLine("IBAN is valid");
}
else if (!validationResult.IsValid)
{
Console.WriteLine("IBAN is invalid");
}
}
if (input == "2")
{
if (CheckIBAN(IBAN))
{
Console.WriteLine("IBAN is valid");
}
else
{
Console.WriteLine("IBAN is invalid");
}
}
}
public UpdateAccountCommandValidator()
{
var ibanValidator = new IbanValidator();
RuleFor(v => v.BankAccountNumber)
.Iban(ibanValidator);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ErrorMessageTranslationService errorTranslation = validationContext.GetService(typeof(ErrorMessageTranslationService)) as ErrorMessageTranslationService;
return(IbanValidator.Validate(value as string)
? ValidationResult.Success
: new ValidationResult(errorTranslation.GetLocalizedError(_errorMessage)));
}
public void ValidateTest()
{
IbanValidator v = new IbanValidator();
Assert.IsFalse(v.Validate("222223600001111111111"));
Assert.IsFalse(v.Validate("HR223600001111111111"));
Assert.IsTrue(v.Validate("HR2223600001111111111"));
}
public void ValidateIban_EmptyIban()
{
var ibanValidator = new IbanValidator();
var emptyIban = "";
var result = ibanValidator.ValidateIban(emptyIban);
Assert.IsFalse(result);
}
public void ValidateIban_IncorrectIban()
{
var ibanValidator = new IbanValidator();
var incorrectIban = "CC051245445454552117989";
var result = ibanValidator.ValidateIban(incorrectIban);
Assert.IsFalse(result);
}
public void ValidateIban_CorrectIban()
{
var ibanValidator = new IbanValidator();
var correctIban = "LT647044001231465456";
var result = ibanValidator.ValidateIban(correctIban);
Assert.IsTrue(result);
}
public IntegrationTests()
{
_validator = new IbanValidator(new IbanValidatorOptions
{
Rules =
{
new HasValidNationalCheckDigitsRule()
}
});
}
public void GlobalSetup()
{
// IbanNet setup
_strictValidator = new IbanValidator();
_looseValidator = new IbanValidator(new IbanValidatorOptions
{
Method = ValidationMethod.Loose
});
_testData = TestSamples.GetIbanSamples(1);
}
public void Iban_Should_Be_Valid_With_Spaces(string country, string iban)
{
// Assert
var validator = new IbanValidator();
// Act
var result = validator.Validate(iban);
// Assert
Assert.That(IbanValidationResult.IsValid, Is.EqualTo(result));
}
public void It_should_return_valid_when_a_valid_value_is_provided()
{
// Assert
const string value = "BE18001654923565";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.IsValid, Is.EqualTo(result));
}
public void It_should_return_an_error_when_an_unkown_country_prefix_used()
{
// Assert
const string value = "XX82WEST12345698765432";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.CountryCodeNotKnown, Is.EqualTo(result));
}
public void It_should_return_an_error_when_there_is_no_value_provided()
{
// Assert
const string value = "";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.ValueMissing, result);
}
public void It_should_return_an_error_when_the_value_fails_the_module_check()
{
// Assert
const string value = "BE18001654923566";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.ValueFailsModule97Check, Is.EqualTo(result));
}
public void It_should_return_an_error_when_the_value_length_is_to_big()
{
// Assert
const string value = "BE180016549235656";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.ValueTooBig, Is.EqualTo(result));
}
public void It_should_return_valid_when_a_valid_foreign_value_is_provided()
{
// Assert
const string value = "GB82WEST12345698765432";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.IsValid, Is.EqualTo(result));
}
public void It_should_return_an_error_when_the_value_fails_the_module_check()
{
// Assert
const string value = "BE18001654923566";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.ValueFailsModule97Check, result);
}
public void It_should_return_an_error_when_the_value_length_is_to_short()
{
// Assert
const string value = "BE1800165492356";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.ValueTooSmall, result);
}
public void It_should_return_an_error_when_an_unkown_country_prefix_used()
{
// Assert
const string value = "XX82WEST12345698765432";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.CountryCodeNotKnown, result);
}
public void It_should_return_an_error_when_the_value_length_is_to_short()
{
// Assert
const string value = "BE1800165492356";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.ValueTooSmall, result);
}
public void It_should_return_an_error_when_there_is_only_whitespace()
{
// Assert
const string value = " ";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.ValueMissing, Is.EqualTo(result));
}
public void It_should_return_valid_when_a_valid_foreign_value_is_provided()
{
// Assert
const string value = "GB82WEST12345698765432";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.IsValid, result);
}
public void It_should_return_an_error_when_there_is_no_value_provided()
{
// Assert
const string value = null;
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.That(IbanValidationResult.ValueMissing, Is.EqualTo(result));
}
public void IbanValidator_Validator()
{
IbanValidator testSubject = new IbanValidator("message {0}", "tag", false);
string input = this.TestContext.DataRow["AccountNumber"].ToString();
bool expected = Convert.ToBoolean(this.TestContext.DataRow["IsValid"]);
EntLib.ValidationResults results = testSubject.Validate(input);
Assert.AreEqual(expected, results.IsValid, input);
testSubject = new IbanValidator("message {0}", "tag", true);
results = testSubject.Validate(input);
Assert.AreEqual(!expected, results.IsValid, input);
}
public void GlobalSetup()
{
// IbanNet setup
_strictValidator = new IbanValidator();
_looseValidator = new IbanValidator(new IbanValidatorOptions {
Method = ValidationMethod.Loose
});
#if VALIDATOR_COMPARISONS
_nugetIbanValidator = new IbanValidation.IbanValidator();
#endif
_testData = TestSamples.GetIbanSamples(Count);
}
public static bool ValidateIBAN(string IBANValue)
{
IIbanValidator validator = new IbanValidator();
ValidationResult validationResult = validator.Validate(IBANValue);
if (validationResult.IsValid)
{
return(true);
}
else
{
return(false);
}
}
public override string this[string columnName]
{
get
{
if (columnName == "Name" && string.IsNullOrWhiteSpace(Name))
{
return("Artist name is required!");
}
if (columnName == "Phone" && (Phone.Length < 8 || !new PhoneAttribute().IsValid(Phone)))
{
return("the specified phone number is incorrect!");
}
if (columnName == "Email")
{
if (string.IsNullOrWhiteSpace(Email))
{
return("Email is a required field!");
}
else
{
var task = ValidateMail.MailIsValidAsync(Email);
task.Wait();
if (!task.Result)
{
return("the specified Email is incorrect!");
}
}
}
if (columnName == "BankAccountNo")
{
IIbanValidator validator = new IbanValidator();
IbanNet.ValidationResult validationResult = validator.Validate(BankAccountNo);
if (string.IsNullOrWhiteSpace(BankAccountNo))
{
return("IBAN is a required field!");
}
else if (!validationResult.IsValid)
{
return("the specified IBAN is incorrect!");
}
}
return("");
}
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterSource(new RuleRegistrationSource());
IRegistrationBuilder <IbanValidatorOptions, ConcreteReflectionActivatorData, SingleRegistrationStyle> optionsRegistration = builder
.RegisterType <IbanValidatorOptions>()
.AsSelf()
.InstancePerDependency();
foreach (Action <IActivatingEventArgs <IbanValidatorOptions> > handler in _ibanValidatorOptionsHandlers)
{
optionsRegistration.OnActivating(handler);
}
builder
.RegisterType <AutofacDependencyResolverAdapter>()
.As <DependencyResolverAdapter>()
.IfNotRegistered(typeof(DependencyResolverAdapter))
.InstancePerDependency();
builder
.RegisterType <IbanParser>()
.As <IIbanParser>()
.IfNotRegistered(typeof(IIbanParser))
.InstancePerDependency();
builder
.Register(context =>
{
IbanValidatorOptions options = context.Resolve <IbanValidatorOptions>();
var validator = new IbanValidator(options);
if (!_preserveStaticValidator)
{
Iban.Validator = validator;
}
return(validator);
})
.As <IIbanValidator>()
.IfNotRegistered(typeof(IIbanValidator))
.SingleInstance();
}
public override bool IsValid(object value)
{
var ibanValidator = new IbanValidator();
return(ibanValidator.Validate((string)value).IsValid);
}
public void It_should_return_valid_when_a_valid_value_is_provided()
{
// Assert
const string value = "BE18001654923565";
var validator = new IbanValidator();
// Act
var result = validator.Validate(value);
// Assert
Assert.Equal(ValidationResult.IsValid, result);
}
public void InvalidIbansReturnsFalse(string ibanValue, string reason)
{
Assert.IsFalse(IbanValidator.IsValid(ibanValue), string.Format("Valid when {0}. ", reason));
}
public void TestValidNorwegianIban(string ibanValue, string country)
{
Assert.IsTrue(IbanValidator.IsValid(ibanValue), string.Format("Invalid for {0}", country));
}
public void TestIban4_NOK()
{
string iban = "LT227044077788877777";
Assert.IsFalse(IbanValidator.IsValidIban(iban));
}
public void TestIban5_NOK()
{
string iban = "CC051245445454552117989";
Assert.IsFalse(IbanValidator.IsValidIban(iban));
}
