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 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.");
});
}
// 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()
{
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)
.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 IActionResult Registrar(Cliente cliente)
{
Result result = new Result();
try
{
CpfValidacao cpfValidacao = new CpfValidacao();
ClienteModel clienteModel = new ClienteModel();
if ((cpfValidacao.CpfJaCadastrado(cliente.CPF)) && (cpfValidacao.CpfValido(cliente.CPF)))
{
clienteModel.InserirCliente(cliente);
result.Sucesso = true;
result.ErrorMessage = string.Empty;
return(Ok());
}
else
{
result.Sucesso = false;
result.ErrorMessage = cpfValidacao.Erros.FirstOrDefault();
return(BadRequest(result.ErrorMessage));
}
}
catch (Exception ex)
{
result.Sucesso = false;
result.ErrorMessage = "Erro ao tentar inserir cliente: " + ex.Message;
return(BadRequest(result.ErrorMessage));
}
}
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)
.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 ManobristaValidation()
{
RuleFor(c => c.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 200).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(c => c.Cpf.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Cpf precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(c => CpfValidacao.Validar(c.Cpf)).Equal(true)
.WithMessage("O cpf fornecido é inválido.");
RuleFor(c => c.DataNascimento.Date).LessThan(DateTime.Now).WithMessage("A data é inválida.");
}
public FuncionarioValidation()
{
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.CPF.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo CPF precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.CPF)).Equal(true)
.WithMessage("O CPF fornecido é inválido.");
}
public void AtualizarCPF(string cpf)
{
if (cpf.EhVazio())
{
throw new Exception("CPF inválido!");
}
if (!CpfValidacao.Validar(cpf.Trim()))
{
throw new Exception("CPF inválido!");
}
CPF = cpf;
}
private bool Validate()
{
if ((Type == EDocumentType.CNPJ) && (CnpjValidacao.Validar(Number)))
{
return(true);
}
if ((Type == EDocumentType.CPF) && (CpfValidacao.Validar(Number)))
{
return(true);
}
return(false);
}
public PessoaValidation()
{
RuleFor(p => p.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido.")
.Length(2, 250).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MinLength} caracteres.");
RuleFor(f => f.Cpf.ToString().Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo CPF precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.Cpf.ToString())).Equal(true)
.WithMessage("O CPF fornecido é inválido.");
RuleFor(p => p.DataNascimento)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido.");
}
public ClienteValidation()
{
RuleFor(f => f.Cpf.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo Cpf precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => CpfValidacao.Validar(f.Cpf)).Equal(true)
.WithMessage("O Cpf fornecido é inválido.");
//RuleFor(c => c.DataNascimento)
// .NotEmpty().WithMessage("O campo { PropertyName} precisa ser fornecido")
// .Length(2, 40).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(c => c.Nome)
.NotEmpty().WithMessage("O campo { PropertyName} precisa ser fornecido")
.Length(2, 30).WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
}
public PessoaValidation()
{
RuleFor(f => f.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 200)
.WithMessage("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres");
RuleFor(f => f.DataNascimento)
.NotNull().WithMessage("O campo {PropertyName} precisa ser fornecido")
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido");
When(f => f.TipoPessoa == TipoPessoa.Monobrista, () =>
{
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.");
});
}
public UsuarioValidation()
{
RuleFor(u => u.Nome)
.NotEmpty().WithMessage("Por favor, preencha o nome")
.Length(2, 100).WithMessage("O nome deve conter entre 2 e 100 caracteres");
When(u => !String.IsNullOrEmpty(u.Telefone), () =>
{
RuleFor(u => u.Telefone)
.Length(9, 15).WithMessage("O telefone deve conter entre 9 e 15 caracteres");
});
RuleFor(u => CpfValidacao.Validar(u.CPF)).Equal(true)
.WithMessage("O CPF fornecido é inválido.");
RuleFor(u => u.Email)
.NotEmpty().WithMessage("Informe o e-mail")
.EmailAddress().WithMessage("O e-mail deve ser válido")
.Length(5, 100).WithMessage("O e-mail deve conter entre 5 e 100 caracteres");
}
public AutorValidation()
{
RuleFor(a => a.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 200).WithMessage("O campo {PropertyName} precisa ter {MinLength} e {MaxLength} caracteres");
RuleFor(a => a.DataNascimento)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.LessThan(a => DateTime.Now).WithMessage("A data precisa estar no passado");
RuleFor(a => a.PaisOrigem)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 50).WithMessage("O campo {PropertyName} precisa ter {MinLength} e {MaxLength} caracteres");
When(a => a.PaisOrigem == "Brasil", () =>
{
RuleFor(a => a.CPF.Length).Equal(CpfValidacao.TamanhoCpf)
.WithMessage("O campo CPF precisa ter {CompaarisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(a => CpfValidacao.Validar(a.CPF)).Equal(true)
.WithMessage("O CPF é inválido.");
});
RuleFor(a => a.Email)
.EmailAddress().WithMessage("Email inválido.")
.Length(2, 100).WithMessage("O campo {PropertyName} precisa ter no máximo {MaxLength} caracteres");
}
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 override void Validate()
{
LimparMensagemValidacao();
if (string.IsNullOrWhiteSpace(Email))
{
AdicionarMensagem("Email é de preenchimento obrigatório");
}
if (string.IsNullOrWhiteSpace(Senha))
{
AdicionarMensagem("Senha é de preenchimento obrigatório");
}
if ((int)TipoPessoa <= 0)
{
AdicionarMensagem("Informe o tipo de pessoa");
}
if (string.IsNullOrWhiteSpace(Documento))
{
AdicionarMensagem("Documento é de preenchimento obrigatório");
}
if (!string.IsNullOrWhiteSpace(Documento))
{
if (TipoPessoa == TipoDocumentoEnum.PessoaFisica && !CpfValidacao.IsCpf(Documento))
{
AdicionarMensagem("Cpf Inválido");
}
if (TipoPessoa == TipoDocumentoEnum.PessoaJuridica && !CnpjValidacao.IsCnpj(Documento))
{
AdicionarMensagem("Cnpj 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);
});
}
public static bool Validar(string cpf)
{
return(CpfValidacao.Validar(cpf));
}
public void CpfValidation_Validar_DeveSerInvalido(string str)
{
var ehValido = CpfValidacao.Validar(str);
ehValido.Should().BeFalse();
}
