/// <summary>
 /// Definição base dos valores padrões
 /// </summary>
 private void DefinirValoresBase()
 {
     this.usuario.SNome  = this.TxtNome.Text;
     this.usuario.SCPF   = ValidadorCpf.RemoverMascaraCpf(this.usuario.SCPF);
     this.usuario.SEmail = this.txtEmail.Text;
     this.usuario.SLogin = this.txtLogin.Text;
     this.usuario.Perfil = this.listaPerfis[this.CmbPerfil.SelectedIndex];
 }
 private bool ValidaGravar()
 {
     try
     {
         if (string.IsNullOrEmpty(TxtNome.Text))
         {
             MessageBox.Show("Favor preencher o campo de Nome!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             TxtNome.Focus();
             return(false);
         }
         if (string.IsNullOrEmpty(txtCpf.Text))
         {
             MessageBox.Show("Favor preencher o campo de CPF!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtCpf.Focus();
             return(false);
         }
         if (ValidadorCpf.ValidaCpf(txtCpf.Text) == false)
         {
             MessageBox.Show("CPF Inválido : " + txtCpf.Text, "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtCpf.Focus();
             return(false);
         }
         if (string.IsNullOrEmpty(txtEmail.Text))
         {
             MessageBox.Show("Favor preencher o campo de E-mail!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtEmail.Focus();
             return(false);
         }
         if (CmbPerfil.SelectedIndex == -1)
         {
             MessageBox.Show("Favor selecionar um perfil!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             CmbPerfil.Focus();
             return(false);
         }
         if (txtSenha.Text != txtConfirma.Text)
         {
             MessageBox.Show("As senhas não são iguais!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtSenha.Focus();
             return(false);
         }
         return(true);
     }
     catch (Exception e)
     {
         MessageBox.Show("Erro - ValidaGravar " + e.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return(false);
     }
 }
        public void CpfDeveSerValido(String input)
        {
            // Arrange
            var validador = new ValidadorCpf();
            var resultado = validador.CpfValido(input);

            // Assert
            resultado
            .Should()
            .BeTrue();
        }
Beispiel #4
0
 public bool VerificaCpfExist()
 {
     try
     {
         return(this.dbService.CpfCadastrado(ValidadorCpf.RemoverMascaraCpf(this.txtCpf.Text)));
     }
     catch (Exception e)
     {
         MessageBox.Show("Erro VerificaCpfExist - " + e.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return(false);
     }
 }
        private long ObterCpf()
        {
            string cpfSemMascara = txtCpf.Text.Replace(".", "").Replace("-", "");
            long   cpf;

            if (!long.TryParse(cpfSemMascara, out cpf) || ValidadorCpf.NaoEhValido(cpf))
            {
                txtCpf.BorderColor = Color.Red;
                throw new ExcecaoFormularioInvalido("Informe um CPF válido");
            }
            return(cpf);
        }
Beispiel #6
0
 public Aluno(string nome, string email, string cpf, PublicoAlvo publicoAlvo)
 {
     ValidadorDeRegra.Novo()
     .Quando(string.IsNullOrEmpty(nome), Resource.NomeInvalido)
     .Quando(!ValidadorCpf.IsCpf(cpf), Resource.CpfInvalido)
     .Quando(string.IsNullOrEmpty(cpf), Resource.CpfInvalido)
     .Quando(!ValidadorEmail.IsEmail(email), Resource.EmailInvalido)
     .DispararExcecaoSeExistir();
     Nome        = nome;
     Email       = email;
     Cpf         = cpf;
     PublicoAlvo = publicoAlvo;
 }
Beispiel #7
0
 public void SetDadosUsuario()
 {
     try
     {
         this.user.SNome  = TxtNome.Text;
         this.user.SCPF   = ValidadorCpf.RemoverMascaraCpf(txtCpf.Text);
         this.user.SEmail = txtEmail.Text;
         this.user.Perfil = this.BuscarPerfiSelecionado();
         this.user.SLogin = txtLogin.Text;
         this.user.SSenha = txtSenha.Text;
     }
     catch (Exception e)
     {
         MessageBox.Show("Erro - SetDadosUsuario " + e.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }
        public Funcionario ObterDadosPessoais()
        {
            bool faltaCamposObrigatorios = this.VerificarSeFaltamCamposObrigatorios(txtNome, txtDataNascimento, txtCpf,
                                                                                    txtTelefone, txtRg, txtOrgaoEmissor);

            if (faltaCamposObrigatorios)
            {
                throw new ExcecaoFormularioInvalido("Preencha todos os campos obrigatórios");
            }
            string   nome = txtNome.Text;
            DateTime dataNascimento;

            if (!DateTime.TryParse(txtDataNascimento.Text, out dataNascimento))
            {
                txtDataNascimento.BorderColor = Color.Red;
                throw new ExcecaoFormularioInvalido("Informe uma data válida");
            }
            string telefoneSemMascara = txtTelefone.Text.Replace("(", "").Replace(")", "").Replace("-", "");
            long   telefone;

            if (!long.TryParse(telefoneSemMascara, out telefone))
            {
                txtTelefone.BorderColor = Color.Red;
                throw new ExcecaoFormularioInvalido("Informe um telefone válido");
            }
            string rg            = txtRg.Text.Replace(".", "").Replace("-", "");
            string cpfSemMascara = txtCpf.Text.Replace(".", "").Replace("-", "");
            long   cpf;

            if (!long.TryParse(cpfSemMascara, out cpf) || ValidadorCpf.NaoEhValido(cpf))
            {
                txtCpf.BorderColor = Color.Red;
                throw new ExcecaoFormularioInvalido("Informe um CPF válido");
            }
            return(new Funcionario
            {
                Nome = nome,
                Cpf = cpf,
                DataNascimento = dataNascimento,
                OrgaoEmissor = txtOrgaoEmissor.Text,
                Telefone = telefone,
                Rg = rg,
                Sexo = drpSexo.SelectedValue
            });
        }
Beispiel #9
0
        private void ValidarCpf(PessoaFisicaEntity entity, string id = null)
        {
            if (!ValidadorCpf.CPFValido(entity.Cpf))
            {
                throw new Exception("O CPF informado não é válido.");
            }

            if (id is null)
            {
                if (GetAll().Count(item => item.Cpf == entity.Cpf) > 0)
                {
                    throw new Exception("O CPF informado já esta sendo utilizado em outro registro.");
                }
            }
            else
            {
                if (GetAll().Count(item => item.Cpf == entity.Cpf && item.Id.ToString() != id) > 0)
                {
                    throw new Exception("O CPF informado já esta sendo utilizado em outro registro.");
                }
            }
        }
Beispiel #10
0
 private bool ValidaGravar()
 {
     try
     {
         if (string.IsNullOrEmpty(TxtNome.Text))
         {
             MessageBox.Show("Favor preencher o campo de Nome!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             TxtNome.Focus();
             return(false);
         }
         if (string.IsNullOrEmpty(txtCpf.Text))
         {
             MessageBox.Show("Favor preencher o campo de CPF!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtCpf.Focus();
             return(false);
         }
         if (ValidadorCpf.ValidaCpf(txtCpf.Text) == false)
         {
             MessageBox.Show("CPF Inválido : " + txtCpf.Text, "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtCpf.Focus();
             return(false);
         }
         if (this.user.PkUsuario == 0 && this.VerificaCpfExist())
         {
             MessageBox.Show("Já existe um usuário com este CPF:" + txtCpf.Text, "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtCpf.Focus();
             return(false);
         }
         if (string.IsNullOrEmpty(txtEmail.Text))
         {
             MessageBox.Show("Favor preencher o campo de E-mail!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtEmail.Focus();
             return(false);
         }
         if (CmbPerfil.SelectedIndex == -1)
         {
             MessageBox.Show("Favor selecionar um perfil!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             CmbPerfil.Focus();
             return(false);
         }
         if ((string.IsNullOrEmpty(txtSenha.Text) && string.IsNullOrEmpty(txtConfirma.Text)))
         {
             MessageBox.Show("Favor preencher o campo de senha e confirmar senha!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtSenha.Focus();
             return(false);
         }
         if (txtSenha.Text != txtConfirma.Text)
         {
             MessageBox.Show("Os campos de senha e confirma senha estão diferentes!", "Campo faltando",
                             MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             txtSenha.Focus();
             return(false);
         }
         return(true);
     }
     catch (Exception e)
     {
         MessageBox.Show("Erro - ValidaGravar " + e.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
         return(false);
     }
 }
Beispiel #11
0
        public void EhValido_QuandoCpfNaoForValido_DeveRetornarFalse(long cpf)
        {
            bool resultado = ValidadorCpf.EhValido(cpf);

            Assert.IsFalse(resultado);
        }
Beispiel #12
0
        public Facade()
        {
            daos = new Dictionary <string, IDAO>();
            rns  = new Dictionary <string, Dictionary <string, List <IStrategy> > >();

            #region Produto
            ProdutoDAO produtoDAO = new ProdutoDAO();

            daos.Add(nameof(Livro), produtoDAO);

            //Regras de salvar
            ValidadorDadosObrigatoriosProduto validadorDadosObrgProd = new ValidadorDadosObrigatoriosProduto();
            InclusaoDataCadastro inclusaoDataCadastro = new InclusaoDataCadastro();
            //Regra genérica
            ValidadorIsbn validadorIsbn = new ValidadorIsbn();
            //Regras de alterar
            ValidadorDadosObrigatoriosProdutoEdicao validadorDadosObrgProdEdicao = new ValidadorDadosObrigatoriosProdutoEdicao();

            List <IStrategy> rnsSalvarProduto  = new List <IStrategy>();
            List <IStrategy> rnsAlterarProduto = new List <IStrategy>();

            rnsSalvarProduto.Add(validadorDadosObrgProd);
            rnsSalvarProduto.Add(inclusaoDataCadastro);

            rnsAlterarProduto.Add(validadorDadosObrgProdEdicao);
            rnsAlterarProduto.Add(validadorIsbn);

            Dictionary <string, List <IStrategy> > rnsProduto = new Dictionary <string, List <IStrategy> >();

            rnsProduto.Add("SALVAR", rnsSalvarProduto);
            rnsProduto.Add("ALTERAR", rnsAlterarProduto);

            rns.Add(nameof(Livro), rnsProduto);
            #endregion

            #region Pedido
            PedidoDAO pedidoDAO = new PedidoDAO();

            daos.Add(nameof(Pedido), pedidoDAO);

            //Regras de salvar
            CalculoValorTotalPedido          calculoValorTotalPedido          = new CalculoValorTotalPedido();
            ValidadorDadosObrigatoriosPedido validadorDadosObrigatoriosPedido = new ValidadorDadosObrigatoriosPedido();
            ValidadorCartoesDiferentes       validadorCartoesDiferentes       = new ValidadorCartoesDiferentes();
            ValidadorNecessidadePgtoCartao   validadorNecessidadePgtoCartao   = new ValidadorNecessidadePgtoCartao();
            ValidadorValorMinimoCartao       validadorValorMinimoCartao       = new ValidadorValorMinimoCartao();
            ValidadorCupons validadorCupons = new ValidadorCupons();
            ValidadorDivisaoValorCartoes            validadorDivisaoValorCartoes            = new ValidadorDivisaoValorCartoes();
            VerificadorNecessidadeGeracaoCupomTroca verificadorNecessidadeGeracaoCupomTroca = new VerificadorNecessidadeGeracaoCupomTroca();

            //Regras de alterar
            ValidadorRetornoOperadora validadorRetornoOperadora = new ValidadorRetornoOperadora();

            List <IStrategy> rnsSalvarPedido  = new List <IStrategy>();
            List <IStrategy> rnsAlterarPedido = new List <IStrategy>();

            rnsSalvarPedido.Add(calculoValorTotalPedido);
            rnsSalvarPedido.Add(validadorDadosObrigatoriosPedido);
            rnsSalvarPedido.Add(validadorCartoesDiferentes);
            rnsSalvarPedido.Add(validadorNecessidadePgtoCartao);
            rnsSalvarPedido.Add(validadorValorMinimoCartao);
            rnsSalvarPedido.Add(validadorCupons);
            rnsSalvarPedido.Add(validadorDivisaoValorCartoes);
            rnsSalvarPedido.Add(verificadorNecessidadeGeracaoCupomTroca);
            rnsSalvarPedido.Add(inclusaoDataCadastro);

            rnsAlterarPedido.Add(validadorRetornoOperadora);

            Dictionary <string, List <IStrategy> > rnsPedido = new Dictionary <string, List <IStrategy> >();

            rnsPedido.Add("SALVAR", rnsSalvarPedido);
            rnsPedido.Add("ALTERAR", rnsAlterarPedido);

            rns.Add(nameof(Pedido), rnsPedido);
            #endregion

            #region Troca
            TrocaDAO trocaDAO = new TrocaDAO();

            daos.Add(nameof(Troca), trocaDAO);

            //Regras de salvar
            ValidadorDadosObrigatoriosTroca       validadorDadosObrigatoriosTroca      = new ValidadorDadosObrigatoriosTroca();
            ValidadorQtdeTrocaCompativelComPedido validadorQtdeTrocaCompativelComTroca = new ValidadorQtdeTrocaCompativelComPedido();

            //Regras de alterar
            ValidadorGeracaoCupomTrocaRecebida validadorGeracaoCupomTrocaRecebida = new ValidadorGeracaoCupomTrocaRecebida();

            List <IStrategy> rnsSalvarTroca  = new List <IStrategy>();
            List <IStrategy> rnsAlterarTroca = new List <IStrategy>();

            rnsSalvarTroca.Add(inclusaoDataCadastro);
            rnsSalvarTroca.Add(validadorDadosObrigatoriosTroca);
            rnsSalvarTroca.Add(validadorQtdeTrocaCompativelComTroca);

            rnsAlterarTroca.Add(validadorGeracaoCupomTrocaRecebida);

            Dictionary <string, List <IStrategy> > rnsTroca = new Dictionary <string, List <IStrategy> >();

            rnsTroca.Add("SALVAR", rnsSalvarTroca);
            rnsTroca.Add("ALTERAR", rnsAlterarTroca);

            rns.Add(nameof(Troca), rnsTroca);
            #endregion

            #region ItemPedido
            ItemPedidoDAO itemPedidoDAO = new ItemPedidoDAO();

            daos.Add(nameof(ItemPedido), itemPedidoDAO);

            rns.Add(nameof(ItemPedido), null);
            #endregion

            #region ItemBloqueado
            ItemBoqueadoDAO itemBoqueadoDAO = new ItemBoqueadoDAO();

            daos.Add(nameof(ItemBloqueado), itemBoqueadoDAO);

            rns.Add(nameof(ItemBloqueado), null);
            #endregion

            #region Cupom
            CupomDAO cupomDAO = new CupomDAO();

            daos.Add(nameof(Cupom), cupomDAO);

            rns.Add(nameof(Cupom), null);
            #endregion

            #region Estoque
            EstoqueDAO estoqueDAO = new EstoqueDAO();

            daos.Add(nameof(Estoque), estoqueDAO);

            rns.Add(nameof(Estoque), null);
            #endregion

            #region EntradaEstoque
            EntradaEstoqueDAO entradaEstoqueDAO = new EntradaEstoqueDAO();

            daos.Add(nameof(EntradaEstoque), entradaEstoqueDAO);

            //Regras de salvar
            ValidadorDadosObrigatoriosEntradaEstoque validadorDadosObrigatoriosEntradaEstoque = new ValidadorDadosObrigatoriosEntradaEstoque();
            ValidadorDataEntradaEstoque validadorDataEntradaEstoque = new ValidadorDataEntradaEstoque();

            List <IStrategy> rnsSalvarEntradaEstoque = new List <IStrategy>();

            rnsSalvarEntradaEstoque.Add(validadorDadosObrigatoriosEntradaEstoque);
            rnsSalvarEntradaEstoque.Add(validadorDataEntradaEstoque);

            Dictionary <string, List <IStrategy> > rnsEntradaEstoque = new Dictionary <string, List <IStrategy> >();

            rnsEntradaEstoque.Add("SALVAR", rnsSalvarEntradaEstoque);

            rns.Add(nameof(EntradaEstoque), rnsEntradaEstoque);
            #endregion

            #region Venda
            VendaDAO vendaDAO = new VendaDAO();

            daos.Add(nameof(Venda), vendaDAO);

            //Regras de consultar
            ValidadorPeriodoVenda validadorPeriodoVenda = new ValidadorPeriodoVenda();

            List <IStrategy> rnsConsultarVenda = new List <IStrategy>();

            rnsConsultarVenda.Add(validadorPeriodoVenda);

            Dictionary <string, List <IStrategy> > rnsVenda = new Dictionary <string, List <IStrategy> >();

            rnsVenda.Add("CONSULTAR", rnsConsultarVenda);

            rns.Add(nameof(Venda), rnsVenda);
            #endregion

            #region Faturamento
            FaturamentoDAO faturamentoDAO = new FaturamentoDAO();

            daos.Add(nameof(Faturamento), faturamentoDAO);

            //Regras de consultar
            ValidadorPeriodoFaturamento validadorPeriodoFaturamento = new ValidadorPeriodoFaturamento();

            List <IStrategy> rnsConsultarFaturamento = new List <IStrategy>();

            rnsConsultarFaturamento.Add(validadorPeriodoFaturamento);

            Dictionary <string, List <IStrategy> > rnsFaturamento = new Dictionary <string, List <IStrategy> >();

            rnsFaturamento.Add("CONSULTAR", rnsConsultarFaturamento);

            rns.Add(nameof(Faturamento), rnsFaturamento);
            #endregion

            #region Lucro
            LucroDAO lucroDAO = new LucroDAO();

            daos.Add(nameof(Lucro), lucroDAO);

            //Regras de consultar
            ValidadorPeriodoLucro validadorPeriodoLucro = new ValidadorPeriodoLucro();

            List <IStrategy> rnsConsultarLucro = new List <IStrategy>();

            rnsConsultarLucro.Add(validadorPeriodoLucro);

            Dictionary <string, List <IStrategy> > rnsLucro = new Dictionary <string, List <IStrategy> >();

            rnsLucro.Add("CONSULTAR", rnsConsultarLucro);

            rns.Add(nameof(Lucro), rnsLucro);
            #endregion

            #region Usuario
            UsuarioDAO usuarioDAO = new UsuarioDAO();

            daos.Add(nameof(Usuario), usuarioDAO);

            //Regras de salvar

            inclusaoDataCadastro = new InclusaoDataCadastro();
            ValidadorDadosObrigatoriosUsuario validadorDadosObrigatoriosUsuario = new ValidadorDadosObrigatoriosUsuario();
            ValidadorDataNascimento           validadorDataNascimento           = new ValidadorDataNascimento();
            ValidadorCpf           validadorCpf           = new ValidadorCpf();
            ValidadorSenha         validadorSenha         = new ValidadorSenha();
            ValidadorDadosCartao   validadorDadosCartao   = new ValidadorDadosCartao();
            ValidadorDadosEndereco validadorDadosEndereco = new ValidadorDadosEndereco();
            ValidadorEmail         validadorEmail         = new ValidadorEmail();

            List <IStrategy> rnsSalvarUsuario = new List <IStrategy>();

            rnsSalvarUsuario.Add(inclusaoDataCadastro);
            rnsSalvarUsuario.Add(validadorDadosObrigatoriosUsuario);
            rnsSalvarUsuario.Add(validadorDataNascimento);
            rnsSalvarUsuario.Add(validadorCpf);
            rnsSalvarUsuario.Add(validadorSenha);
            rnsSalvarUsuario.Add(validadorDadosCartao);
            rnsSalvarUsuario.Add(validadorEmail);

            //Regras de alterar

            ValidadorDadosObrigatoriosTrocaSenha validadorDadosObrigatoriosTrocaSenha = new ValidadorDadosObrigatoriosTrocaSenha();
            ValidadorSenhaAtual validadorSenhaAtual = new ValidadorSenhaAtual();
            ValidadorTrocaSenha validadorTrocaSenha = new ValidadorTrocaSenha();
            ValidadorDadosObrigatoriosUsuarioEdicao validadorDadosObrigatoriosUsuarioEdicao = new ValidadorDadosObrigatoriosUsuarioEdicao();

            List <IStrategy> rnsAlterarUsuario = new List <IStrategy>();

            rnsAlterarUsuario.Add(validadorDadosObrigatoriosTrocaSenha);
            rnsAlterarUsuario.Add(validadorSenhaAtual);
            rnsAlterarUsuario.Add(validadorTrocaSenha);
            rnsAlterarUsuario.Add(validadorDadosObrigatoriosUsuarioEdicao);

            Dictionary <string, List <IStrategy> > rnsUsuario = new Dictionary <string, List <IStrategy> >();

            rnsUsuario.Add("SALVAR", rnsSalvarUsuario);
            rnsUsuario.Add("ALTERAR", rnsAlterarUsuario);

            rns.Add(nameof(Usuario), rnsUsuario);
            #endregion

            #region Endereco
            EnderecoDAO enderecoDAO = new EnderecoDAO();

            daos.Add(nameof(Endereco), enderecoDAO);

            //Regras de salvar

            inclusaoDataCadastro = new InclusaoDataCadastro();
            ValidadorDadosObrigatoriosEndereco validadorDadosObrigatoriosEndereco = new ValidadorDadosObrigatoriosEndereco();
            validadorDadosEndereco = new ValidadorDadosEndereco();

            List <IStrategy> rnsSalvarEndereco = new List <IStrategy>();

            rnsSalvarEndereco.Add(inclusaoDataCadastro);
            rnsSalvarEndereco.Add(validadorDadosObrigatoriosEndereco);
            rnsSalvarEndereco.Add(validadorDadosEndereco);

            //Regras de alterar

            List <IStrategy> rnsAlterarEndereco = new List <IStrategy>();

            rnsAlterarEndereco.Add(validadorDadosObrigatoriosEndereco);
            rnsAlterarEndereco.Add(validadorDadosEndereco);

            Dictionary <string, List <IStrategy> > rnsEndereco = new Dictionary <string, List <IStrategy> >();

            rnsEndereco.Add("SALVAR", rnsSalvarEndereco);
            rnsEndereco.Add("ALTERAR", rnsAlterarEndereco);

            rns.Add(nameof(Endereco), rnsEndereco);
            #endregion

            #region Cartao
            CartaoDeCreditoDAO cartaoDeCreditoDAO = new CartaoDeCreditoDAO();

            daos.Add(nameof(CartaoDeCredito), cartaoDeCreditoDAO);

            //Regras de salvar

            inclusaoDataCadastro = new InclusaoDataCadastro();
            ValidadorDadosObrigatoriosCartao validadorDadosObrigatoriosCartao = new ValidadorDadosObrigatoriosCartao();
            validadorDadosCartao = new ValidadorDadosCartao();

            List <IStrategy> rnsSalvarCartaoDeCredito = new List <IStrategy>();

            rnsSalvarCartaoDeCredito.Add(inclusaoDataCadastro);
            rnsSalvarCartaoDeCredito.Add(validadorDadosObrigatoriosCartao);
            rnsSalvarCartaoDeCredito.Add(validadorDadosCartao);

            //Regras de alterar

            List <IStrategy> rnsAlterarCartaoDeCredito = new List <IStrategy>();

            rnsAlterarCartaoDeCredito.Add(validadorDadosObrigatoriosCartao);
            rnsAlterarCartaoDeCredito.Add(validadorDadosCartao);

            Dictionary <string, List <IStrategy> > rnsCartaoDeCredito = new Dictionary <string, List <IStrategy> >();

            rnsCartaoDeCredito.Add("SALVAR", rnsSalvarCartaoDeCredito);
            rnsCartaoDeCredito.Add("ALTERAR", rnsAlterarCartaoDeCredito);

            rns.Add(nameof(CartaoDeCredito), rnsCartaoDeCredito);
            #endregion

            #region Notificacao
            NotificacaoDAO notificacaoDAO = new NotificacaoDAO();

            daos.Add(nameof(Notificacao), notificacaoDAO);
            Dictionary <string, List <IStrategy> > rnsNotificacao = new Dictionary <string, List <IStrategy> >();

            rnsNotificacao.Add("CONSULTAR", null);

            rns.Add(nameof(Notificacao), rnsNotificacao);
            #endregion
        }
Beispiel #13
0
 public bool EhValido()
 {
     return(ValidadorCpf.Validar(this.Documento));
 }