public FornecedorValidation()
{
string txtObrigatoriedade = "O campo {PropertyName} precisa ser fornecido";
string txtMinMax = "O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres";
RuleFor(f => f.Nome)
.NotEmpty().WithMessage(txtObrigatoriedade)
.Length(min: 2, max: 100)
.WithMessage(txtMinMax);
When(predicate: f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, action: () =>
{
RuleFor(expression: f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(expression: f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido");
});
When(predicate: f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, action: () =>
{
RuleFor(expression: f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(expression: f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido");
});
}
public FornecedorValidation()
{
RuleFor(f => f.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 100)
.WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
When(f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage(
"O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
When(f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage(
"O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
}
public FornecedorValidation()
{
RuleFor(f => f.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(min: 2, max: 100)
.WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
// Quando ele for uma pessoa fisica.
When(f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, action: () =>
{
// Caso o tamanho do documento não seja igual ao valor da propriedade, retorna a mensagem.
RuleFor(f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
// Caso o resultado do método não seja verdadeiro, retorna a mensagem.
RuleFor(f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
// Quando ele for uma pessoa Juridica.
When(f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, action: () =>
{
// Caso o tamanho do documento não seja igual ao valor da propriedade, retorna a mensagem.
RuleFor(f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
// Caso o resultado do método não seja verdadeiro, retorna a mensagem.
RuleFor(f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
}
public FornecedorValidation()
{
RuleFor(f => f.Nome)
.Length(2, 100).WithMessage("Nome precisa ter entre 2 e 100 caracteres")
.NotEmpty().WithMessage("Nome precisa ser fornecido");
When(f => f.TipoFornecedor == TipoFornecedor.Fisica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O documento precisa ter 11 caracteres");
RuleFor(f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("CPF inválido");
});
When(f => f.TipoFornecedor == TipoFornecedor.Juridica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O documento precisa ter 14 caracteres");
RuleFor(f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("CNPJ inválido");
});
}
public FornecedorValidacao()
{
RuleFor(expression: f => f.Nome)
.NotEmpty().WithMessage("O campo nome precisa ser fornecido")
.Length(min: 2, max: 100)
.WithMessage("O campo nome precisa ter entre {MinLength} e {MaxLength} caracteres");
When(predicate: f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, action: () =>
{
RuleFor(expression: f => f.Documento.Length).Equal(toCompare: CpfValidacao.TamanhoCpf)
.WithMessage("O campo documento precisa ser {ComparisonValue} caracteres");
RuleFor(expression: f => CpfValidacao.Validar(f.Documento)).Equal(toCompare: true)
.WithMessage("O documento fornecido é inválido");
});
When(predicate: f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, action: () =>
{
RuleFor(expression: f => f.Documento.Length).Equal(toCompare: CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo documento precisa ser {ComparisonValue} caracteres");
RuleFor(expression: f => CnpjValidacao.Validar(f.Documento)).Equal(toCompare: true)
.WithMessage("O documento fornecido é inválido");
});
}
// public virtual Contatos Contatos { get; set; }
// public virtual Enderecos Enderecos { get; set; }
public override bool EhValido()
{
RuleFor(c => c.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(4, 200).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(c => c.Proprietario)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(4, 200).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(c => c.TPO)
.Length(2, 10).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
When(f => f.TipoPessoa == 1, () =>
{
RuleFor(f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
When(f => f.TipoPessoa == 2, () =>
{
RuleFor(f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
ValidationResult = Validate(this);
return(ValidationResult.IsValid);
}
public FornecedorValidation()
{
//Validacoes para o campo nome
RuleFor(f => f.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 100).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres.");
//Validacao condicional para pessoa fisica
When(f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, () => {
//Validando tamanho do documento
RuleFor(f => f.Documento.Length)
.Equal(CpfValidacao.TamanhoCpf).WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}");
//Validando formato do documento
RuleFor(f => CpfValidacao.Validar(f.Documento))
.Equal(true)
.WithMessage("O documento fornecido nao eh valido.");
});
//Validacao condicional para pessoa juridica
When(f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, () => {
//Validando tamanho do documento
RuleFor(f => f.Documento.Length)
.Equal(CnpjValidacao.TamanhoCnpj).WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}");
//Validando formato do documento
RuleFor(f => CnpjValidacao.Validar(f.Documento))
.Equal(true)
.WithMessage("O documento fornecido nao eh valido.");
});
}
private bool Validate()
{
if ((Type == EDocumentType.CNPJ) && (CnpjValidacao.Validar(Number)))
{
return(true);
}
if ((Type == EDocumentType.CPF) && (CpfValidacao.Validar(Number)))
{
return(true);
}
return(false);
}
public FornecedorValidation()
{
RuleFor(f => f.nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 100)
.WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(f => f.cnpj.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo cnpj precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CnpjValidacao.Validar(f.cnpj)).Equal(true)
.WithMessage("O cnpj fornecido é inválido.");
}
public FornecedorValidation()
{
RuleFor(x => x.Nome)
.NotEmpty().WithMessage(REQUIREDFIELDMESSAGE)
.Length(2, 100).WithMessage(SIZEFIELDMESSAGE);
When(x => x.TipoFornecedor == TipoFornecedor.PessoaFisica, () =>
{
RuleFor(x => x.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage(DOCUMENTSIZEMESSAGE);
RuleFor(x => CpfValidacao.Validar(x.Documento)).Equal(true)
.WithMessage(INVALIDDOCUMENTMESSAGE);
});
When(x => x.TipoFornecedor == TipoFornecedor.PessoaJuridica, () =>
{
RuleFor(x => x.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage(DOCUMENTSIZEMESSAGE);
RuleFor(x => CnpjValidacao.Validar(x.Documento)).Equal(true)
.WithMessage(INVALIDDOCUMENTMESSAGE);
});
}
public ProviderValidation()
{
RuleFor(p => p.Name)
.NotEmpty().WithMessage("The field {PropertyName} needs to be informed")
.Length(2, 100).WithMessage("The field {PropertyName} must be between {MinLength} e {MaxLength} characteres");
When(p => p.TypeProvider == TypeProvider.NaturalPerson, () =>
{
RuleFor(p => p.Document.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("The Document field must be {ComparisonValue} characters and {PropertyValue} has been provided.");
RuleFor(p => CpfValidacao.Validar(p.Document)).Equal(true)
.WithMessage("Document Invalid.");
});
When(p => p.TypeProvider == TypeProvider.LegalPerson, () =>
{
RuleFor(p => p.Document.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("The Document field must be {ComparisonValue} characters and {PropertyValue} has been provided.");
RuleFor(p => CnpjValidacao.Validar(p.Document)).Equal(true)
.WithMessage("Document Invalid.");
});
}
public VendorValidation()
{
RuleFor(n => n.Name)
.NotEmpty()
.Length(2, 100).WithMessage("The field {PropertyName} shoud be between {MinLength} and {MaxLength} caracters.");
When(d => d.VendorType == VendorType.Física,
() => {
RuleFor(d => d.IdentifiyDocument.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("The field document must have {ComparisonValue} caracters and was informed {PropertyValue}.");
RuleFor(d => CpfValidacao.Validar(d.IdentifiyDocument)).Equal(true)
.WithMessage("The Document informed is invalid.");
});
When(d => d.VendorType == VendorType.Jurídica,
() => {
RuleFor(d => d.IdentifiyDocument.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("The field document must have {ComparisonValue} caracters and was informed {PropertyValue}.");
RuleFor(d => CnpjValidacao.Validar(d.IdentifiyDocument)).Equal(true)
.WithMessage("The Document informed is invalid.");
});
}
public ClienteValidation()
{
string defaultMessage = "O campo {PropertyName} precisa ser fornecido";
string lengthMessage = "O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres";
RuleFor(
c => c.Nome)
.NotEmpty().WithMessage(defaultMessage)
.Length(3, 100)
.WithMessage(lengthMessage);
RuleFor(
c => c.Genero)
.NotEmpty().WithMessage(defaultMessage);
RuleFor(
c => c.DataNascimento)
.NotEmpty().WithMessage(defaultMessage);
RuleFor(c => c.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
When(f => f.TipoPessoa == TipoPessoa.PessoaFisica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
When(f => f.TipoPessoa == TipoPessoa.PessoaJuridica, () =>
{
RuleFor(f => f.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CnpjValidacao.Validar(f.Documento)).Equal(true)
.WithMessage("O documento fornecido é inválido.");
});
}
public ProviderValidation()
{
RuleFor(x => x.Name)
.NotEmpty().WithMessage("The field {PropertyName} is required")
.Length(2, 100).WithMessage("The field {PropertyName} must have between {MinLength} and {MaxLength}");
When(x => x.TypeProvider == TypeProvider.PhysicalPerson, () =>
{
RuleFor(x => x.Document.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("The fiel Document need to have {ComparisonValue} characters and was supplied {PropertyValue}.");
RuleFor(x => CpfValidacao.Validar(x.Document)).Equal(true)
.WithMessage("Invalid Document!");
});
When(x => x.TypeProvider == TypeProvider.LegalPerson, () =>
{
RuleFor(x => x.Document.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage("The fiel Document need to have {ComparisonValue} characters and was supplied {PropertyValue}.");
RuleFor(x => CnpjValidacao.Validar(x.Document)).Equal(true)
.WithMessage("Invalid document!");
});
}
public FornecedorValidation()
{
RuleFor(cd => cd.Nome)
.NotEmpty().WithMessage(ValidationsMessages.MessageNotEmpty)
.Length(2, 100).WithMessage(ValidationsMessages.MessageMinAndMaxLength);
When(cd => cd.TipoFornecedor == TipoDocumento.PessoaFisica, () =>
{
RuleFor(cd => cd.Documento.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage(MessageInvalidLengthCnpjCpf);
RuleFor(cd => CpfValidacao.Validar(cd.Documento)).Equal(true)
.WithMessage(MessageInvalidCnpjCpf);
});
When(cd => cd.TipoFornecedor == TipoDocumento.PessoaJuridica, () =>
{
RuleFor(cd => cd.Documento.Length).Equal(CnpjValidacao.TamanhoCnpj)
.WithMessage(MessageInvalidLengthCnpjCpf);
RuleFor(cd => CnpjValidacao.Validar(cd.Documento)).Equal(true)
.WithMessage(MessageInvalidCnpjCpf);
});
}