public void TestMethod1()
{
//Arrange
var entityA = new EntityWithValidationAttribute();
entityA.RequiredProperty = null;
var entityB = new EntityWithValidatableObject();
entityB.RequiredProperty = null;
IEntityValidator entityValidator = EntityValidatorFactory.CreateValidator();
//Act
var entityAValidationResult = entityValidator.IsValid(entityA);
var entityAInvalidMessages = entityValidator.GetInvalidMessages(entityA);
var entityBValidationResult = entityValidator.IsValid(entityB);
var entityBInvalidMessages = entityValidator.GetInvalidMessages(entityB);
//Assert
Assert.IsFalse(entityAValidationResult);
Assert.IsFalse(entityBValidationResult);
Assert.IsTrue(entityAInvalidMessages.Any());
Assert.IsTrue(entityBInvalidMessages.Any());
}
void SaveBankAccount(BankAccount bankAccount, Customer customer = null)
{
Customer cu = null;
//validate bank account
var validator = EntityValidatorFactory.CreateValidator();
var ba = _bankAccountRepository.Get(bankAccount.Id);
if (customer != null)
{
cu = _customerRepository.Get(customer.Id);
}
if (validator.IsValid <BankAccount>(bankAccount)) // save entity
{
if (ba == null)
{
_bankAccountRepository.Add(bankAccount);
}
else
{
if (cu != null)
{
_customerRepository.Modify(cu);
}
_bankAccountRepository.Modify(ba);
}
_customerRepository.UnitOfWork.Commit();
_bankAccountRepository.UnitOfWork.Commit();
}
else //throw validation errors
{
throw new ApplicationValidationErrorsException(validator.GetInvalidMessages(bankAccount));
}
}
public PostsService(IPostRepository postRepository)
: base(postRepository)
{
_postRepository = postRepository;
_resources = _resources;
_validator = EntityValidatorFactory.CreateValidator();
}
public BlogsService(IBlogRepository blogRepository, IPostRepository postRepository)
: base(blogRepository)
{
_blogRepository = blogRepository;
_postRepository = postRepository;
_resources = LocalizationFactory.CreateLocalResources();
_validator = EntityValidatorFactory.CreateValidator();
}
private void ValideTenant(Tenant tenant)
{
var validationManager = new ValidationManager();
var validator = EntityValidatorFactory.CreateValidator();
validationManager.AddMessages(validator.GetInvalidMessages(tenant));
validationManager.Validate();
}
private void ValideUsuario(Usuario usuario)
{
var validationManager = new ValidationManager();
var validator = EntityValidatorFactory.CreateValidator();
validationManager.AddMessages(validator.GetInvalidMessages(usuario));
validationManager.Validate();
}
private void SalvarSocio(Socio socio)
{
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(socio))
{
throw new AppException(validator.GetInvalidMessages <Socio>(socio));
}
var specExisteSocio = SocioSpecification.ConsultaTexto(socio.Nome);
if (_socioRepository.AllMatching(specExisteSocio).Any())
{
throw new AppException("Já existe um sócio cadastrado com este nome.");
}
if (JaExisteCpf(socio.Cpf, socio.EntrevistaId, socio.Id))
{
throw new AppException("Já existe um sócio cadastrado com este CPF.");
}
if (socio.Administrador && socio.Assina)
{
bool x = JaExisteAdministrador(socio.EntrevistaId);
bool y = JaExisteAssinaNaReceita(socio.EntrevistaId);
if (!x && y)
{
throw new AppException("Já existe um sócio assinando na receita.");
}
else if (x && !y)
{
throw new AppException("Já existe um sócio administrador.");
}
}
if (socio.Administrador)
{
if (JaExisteAdministrador(socio.EntrevistaId))
{
throw new AppException("Já existe um sócio administrador.");
}
}
if (socio.Assina)
{
if (JaExisteAssinaNaReceita(socio.EntrevistaId))
{
throw new AppException("Já existe um sócio assinando na receita.");
}
}
_socioRepository.Add(socio);
_socioRepository.Commit();
}
private void AlterarUsoSolo(UsoSolo persistido, UsoSolo corrente)
{
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(corrente))
{
throw new AppException(validator.GetInvalidMessages <UsoSolo>(corrente));
}
_usoSoloRepository.Merge(persistido, corrente);
_usoSoloRepository.Commit();
}
void SalvarConfiguracaoServidorEmail(ConfiguracaoServidorEmail configuracaoServidorEmail)
{
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(configuracaoServidorEmail))
{
throw new AppException(validator.GetInvalidMessages(configuracaoServidorEmail));
}
_configuracaoServidorEmailRepository.Add(configuracaoServidorEmail);
_configuracaoServidorEmailRepository.Commit();
}
public static IEnumerable <string> DoIfIsValid <T>(this EntityBase entidadeASerValidada, ExecutarSeValido executarSeValido) where T : EntityBase
{
var validator = EntityValidatorFactory.CreateValidator();
if (validator.IsValid((T)entidadeASerValidada))
{
executarSeValido();
return(null);
}
return(validator.GetInvalidMessages((T)entidadeASerValidada));
}
private void SalvarUsoSolo(UsoSolo usoSolo)
{
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(usoSolo))
{
throw new AppException(validator.GetInvalidMessages <UsoSolo>(usoSolo));
}
_usoSoloRepository.Add(usoSolo);
_usoSoloRepository.Commit();
}
/// <summary>
/// Validate Entity calling IValidatableObject.Validate
/// </summary>
/// <param name="item">Entity to validate</param>
public static void Validate <TEntity>(this TEntity item)
where TEntity : class, new()
{
//Recover validator
var validator = EntityValidatorFactory.CreateValidator();
//Validate entity
if (!validator.IsValid(item))
{
throw new ApplicationValidationErrorsException(validator.GetInvalidMessages(item));
}
}
public static ExecuteResult <ValidatorResult> Validator <T>(this T val) where T : Entity
{
if (val == null)
{
new ExecuteResult <ValidatorResult>(false, "entity 为空", new ValidatorResult().SetSuccess(false).SetMessage(new string[] { "实体为空" }));
}
var validFactory = EntityValidatorFactory.CreateValidator();
var valid = validFactory.IsValid <T>(val);
var validMsg = validFactory.GetInvalidMessages(val);
return(new ExecuteResult <ValidatorResult>(valid, string.Join(";", validMsg), new ValidatorResult().SetSuccess(valid).SetMessage(validMsg)));
}
/// <summary>
/// Save Address
/// </summary>
/// <param name="newAddress"></param>
/// <returns></returns>
private Address SaveAddress(Address address)
{
IEntityValidator entityValidator = EntityValidatorFactory.CreateValidator();
if (entityValidator.IsValid(address))
{
_addressRepository.Add(address);
_addressRepository.UnitOfWork.Commit();
return(address);
}
throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(address));
}
void SaveProduct(Product product)
{
var entityValidator = EntityValidatorFactory.CreateValidator();
if (entityValidator.IsValid(product)) // if is valid
{
_productRepository.Add(product);
_productRepository.UnitOfWork.Commit();
}
else //if not valid, throw validation errors
{
throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(product));
}
}
/// <summary>
/// Save profile
/// </summary>
/// <param name="profile"></param>
/// <returns></returns>
private Profile SaveProfile(Profile profile)
{
IEntityValidator entityValidator = EntityValidatorFactory.CreateValidator();
if (entityValidator.IsValid(profile))
{
_profileRepository.Add(profile);
_profileRepository.UnitOfWork.Commit();
return(profile);
}
throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(profile));
}
User SaveUser(User usr)
{
var entityValidator = EntityValidatorFactory.CreateValidator();
if (entityValidator.IsValid(usr))
{
_userRepository.Add(usr);
_userRepository.UnitOfWork.Commit();
return(usr);
}
else
{
throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(usr));
}
}
public void ThrowExceptionIfInvalid()
{
_brokenRules.Clear();
Validate();
if (_validationResults.Count() > 0)
{
StringBuilder issues = new StringBuilder();
foreach (String businessRule in EntityValidatorFactory.CreateValidator().GetInvalidMessages(this))
{
issues.AppendLine(businessRule);
}
throw new ValueObjectIsInvalidException(issues.ToString());
}
}
void SaveOrder(Order order)
{
var entityValidator = EntityValidatorFactory.CreateValidator();
if (entityValidator.IsValid(order))//if entity is valid save.
{
//add order and commit changes
_orderRepository.Add(order);
_orderRepository.UnitOfWork.Commit();
}
else // if not valid throw validation errors
{
throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(order));
}
}
/// <summary>
/// 会员注册
/// </summary>
/// <param name="Id"></param>
/// <param name="memberName"></param>
/// <param name="password"></param>
public void SubmitMember(string Id, string memberName, string password)
{
var model = new Member()
{
MemberID = Guid.NewGuid().ToString().Replace("-", ""),
MemberName = memberName,
MemberPassword = password
};
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(model))
{
throw new NeedToShowFrontException("输入不合法");
}
Add(model);
}
private void SalvarNumeroOficial(NumeroOficial numeroOficial)
{
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(numeroOficial))
{
throw new AppException(validator.GetInvalidMessages <NumeroOficial>(numeroOficial));
}
//var specExisteNumeroOficial = NumeroOficialSpecification.ConsultaTexto(numeroOficial.Requerente);
//if (_numeroOficialRepository.AllMatching(specExisteNumeroOficial).Any())
// throw new AppException("Já existe um número oficial cadastrado com este nome.");
_numeroOficialRepository.Add(numeroOficial);
_numeroOficialRepository.Commit();
}
public void TestaValidatorDaEntidadeNula()
{
//Arrange
EntidadeValidavel entidadeA = null;
IEntityValidator entityValidator = EntityValidatorFactory.CreateValidator();
//Act
var entityAValidationResult = entityValidator.IsValid(entidadeA);
var entityAInvalidMessages = entityValidator.GetInvalidMessages(entidadeA);
//Assert
Assert.IsFalse(entityAValidationResult);
Assert.IsFalse(entityAInvalidMessages.Any());
}
void SalvarPessoa(Pessoa pessoa)
{
// Validando
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(pessoa))
{
throw new ApplicationValidationErrorsException(validator.GetInvalidMessages <Pessoa>(pessoa));
}
//var specExistePessoa = PessoaSpecifications.Consulta();
//if (_pessoaRepository.AllMatching(specExistePessoa).Any())
// throw new ApplicationValidationErrorsException("Já existe um usuário cadastrado com este e-mail.");
_pessoaRepository.Add(pessoa);
_pessoaRepository.Commit();
}