public void CanRegister()
{
var validationFactory = new ValidationFactory();
var validator = new FishValidator();
validationFactory.Register(validator);
validationFactory.GetValidatorFor<Fish>().Should().Be.EqualTo(validator);
}
private static void BootStrap()
{
AutoMapperConfiguration.Configure(typeof(SearchContactDtoToSearchContactFilterProfile).Assembly);
Database.SetInitializer(new PhoneBookDbContextSeedInitializer());
var unitOfWorkFactory = new EntityFrameworkUnitOfWorkFactory(new PhoneBookDbContext());
var mapper = new AutoMapperMapping();
var validationFactory = new ValidationFactory();
validationFactory.Register(new SearchContactFilterValidator());
_contactCrudService = new ContactCrudService(unitOfWorkFactory, mapper, validationFactory);
}
public static void ResetCaches()
{
CreatedValidators.Clear();
ValidationFactory.ResetCaches();
PropertyValidationFactory.ResetCaches();
}
private void MainForm_Load(object sender, EventArgs e)
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
customerValidator = ValidationFactory.CreateValidator <Customer>();
}
/// <summary>
/// 测试初始化
/// </summary>
public ValidationTest()
{
_sample = AggregateRootSample.CreateSample();
_validation = ValidationFactory.Create();
}
public ValidationResults GetErrors <TValidation>()
{
Validator <TValidation> validator = ValidationFactory.CreateValidator <TValidation>();
return(validator.Validate(this));
}
public void TestCleanup()
{
ValidationFactory.Reset();
}
protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
{
var gallery = arguments.GetOrThrow <string>(Arguments.Gallery);
var index = arguments.GetOrThrow <string>(Arguments.Index);
var packageBaseAddress = arguments.GetOrThrow <string>(Arguments.ContentBaseAddress);
var source = arguments.GetOrThrow <string>(Arguments.Source);
var requireRepositorySignature = arguments.GetOrDefault(Arguments.RequireRepositorySignature, false);
var verbose = arguments.GetOrDefault(Arguments.Verbose, false);
var timeoutInSeconds = arguments.GetOrDefault(Arguments.SqlCommandTimeoutInSeconds, 300);
var sqlTimeout = TimeSpan.FromSeconds(timeoutInSeconds);
var connectionString = arguments.GetOrThrow <string>(Arguments.ConnectionString);
var galleryDbConnection = new AzureSqlConnectionFactory(
connectionString,
SecretInjector,
LoggerFactory.CreateLogger <AzureSqlConnectionFactory>());
var packageContentUriBuilder = new PackageContentUriBuilder(
arguments.GetOrThrow <string>(Arguments.PackageContentUrlFormat));
var galleryDatabase = new GalleryDatabaseQueryService(
galleryDbConnection,
packageContentUriBuilder,
TelemetryService,
timeoutInSeconds);
CommandHelpers.AssertAzureStorage(arguments);
var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);
var auditingStorageFactory = CommandHelpers.CreateSuffixedStorageFactory("Auditing", arguments, verbose);
var endpointConfiguration = CommandHelpers.GetEndpointConfiguration(arguments);
var messageHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);
Logger.LogInformation(
"CONFIG gallery: {Gallery} index: {Index} storage: {Storage} auditingStorage: {AuditingStorage} registration cursor uri: {RegistrationCursorUri} flat-container cursor uri: {FlatContainerCursorUri}",
gallery, index, monitoringStorageFactory, auditingStorageFactory, endpointConfiguration.RegistrationCursorUri, endpointConfiguration.FlatContainerCursorUri);
var validatorConfig = new ValidatorConfiguration(
packageBaseAddress,
requireRepositorySignature);
_packageValidator = ValidationFactory.CreatePackageValidator(
gallery,
index,
auditingStorageFactory,
validatorConfig,
endpointConfiguration,
messageHandlerFactory,
galleryDatabase,
LoggerFactory);
_queue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);
_statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);
_notificationService = new LoggerMonitoringNotificationService(LoggerFactory.CreateLogger <LoggerMonitoringNotificationService>());
_client = new CollectorHttpClient(messageHandlerFactory());
_queueLoopDuration = TimeSpan.FromHours(
arguments.GetOrDefault(
Arguments.QueueLoopDurationHours,
DefaultQueueLoopDurationHours));
_queueDelay = TimeSpan.FromSeconds(
arguments.GetOrDefault(
Arguments.QueueDelaySeconds,
DefaultQueueDelaySeconds));
_workerCount = arguments.GetOrDefault(Arguments.WorkerCount, DefaultWorkerCount);
SetUserAgentString();
}
public ValidationStepsBase(IObjectContainer objectContainer) : base(objectContainer)
{
ValidationFactory = new ValidationFactory(base.Interpeter);
}
public ValidationResults ValidateEntity <TEntity>(TEntity entity)
{
return(ValidationFactory.CreateValidatorFromAttributes(entity.GetType(), string.Empty).Validate(entity));
}
protected virtual ValidationResults DoValidation(object value)
{
var factory = ValidationFactory.CreateValidator(value.GetType());
return(factory.Validate(value));
}
public Validator ProvideValidator(Type type, string ruleset)
{
return(ValidationFactory.CreateValidator(type, ruleset));
}
public void TestInitialize()
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
valueToConvert = null;
originalConvertedValue = null;
}
private static ValidationResults ValidateObject(object o)
{
return(ValidationFactory.CreateValidator(o.GetType()).Validate(o));
}
protected Validator BuildValidator() {
return ValidationFactory.CreateValidator<Account>();
} // method::BuildValidator
protected void Application_Start(object sender, EventArgs e)
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
}
//public Response<List<Model.Address>> Create(IEnumerable<Model.Address> addresses)
//{
// Response<List<Model.Address>> response = null;
// if (addresses.IsNullOrEmpty())
// {
// response = new Response<List<Model.Address>>();
// response.Result = new List<Model.Address>();
// foreach (Model.Address address in addresses)
// {
// var resp = Create(address);
// response.Result.Add(resp.Result);
// }
// }
// return response;
//}
public Response <Model.Address> Create(Model.Address address)
{
IAddressRepository addressRepository = null;
Validator <Model.Address> validator = ValidationFactory.CreateValidator <Model.Address>("Create");
try
{
#region Validation
if (!validator.Validate(address).IsValid)
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
foreach (var result in validator.Validate(address))
{
if (!response.Validations.ContainsKey(result.Key))
{
response.Validations.Add(result.Key, result.Message);
}
}
return(response);
}
else // Validate Email
{
if (!address.PrimaryEmail.IsNullOrEmpty())
{
Validator <Model.Address> valEmail = ValidationFactory.CreateValidator <Model.Address>("Email");
if (!valEmail.Validate(address).IsValid)
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
foreach (var result in valEmail.Validate(address))
{
if (!response.Validations.ContainsKey(result.Key))
{
response.Validations.Add(result.Key, result.Message);
}
}
return(response);
}
}
}
#endregion Validation
#region Create
using (var ctx = new ChickenScratchContext())
{
addressRepository = new AddressRepository(ctx);
addressRepository.Insert(address);
addressRepository.Save();
response.Result = address;
response.Status = ResponseStatus.Success;
}
#endregion Create
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
public void TestInitialize()
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
}
/// <summary>
/// Validates this instance.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
protected bool Validate <T>()
{
Errors = ValidationFactory.CreateValidator <T>().Validate(this);
return(Errors.IsValid);
}
public static ValidatorResults Validator <T>(T entity)
where T : BaseEntity
{
return(ValidationFactory.CreateValidator(entity.GetType()).Validate(entity));
}
public void TestInitialize()
{
MockValidator <object> .ResetCaches();
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
}
