Esempio n. 1
0
        /// <summary>
        /// Exibe login do operador e pede usuário e senha
        /// </summary>
        /// <param name="pListOperadores">Lista de operadores</param>
        /// <returns></returns>
        public static Operador ExecutaLoginOperador(List <Operador> pListOperadores)
        {
            Operador operador = null;
            string   user     = null;

            do
            {
                Console.WriteLine();
                Console.WriteLine("---- LOGIN DO OPERADOR ----");
                Console.Write("Usuário: ");
                user     = EeS.ReadConsoleLine();
                operador = Operador.BuscaOperador(pListOperadores, user);
            } while (operador == null);

            string pass         = null;
            bool   senhaCorreta = true;

            do
            {
                if (!senhaCorreta)
                {
                    Console.WriteLine("Senha incorreta!");
                }
                Console.Write("Senha: ");
                pass = EeS.ReadConsoleLine();
            } while (!(senhaCorreta = Password.CompararSenhas(pass, operador.Salt, operador.Senha)));

            return(operador);
        }
Esempio n. 2
0
        /// <summary>
        /// Solicita dados e executa transferência entre contas
        /// </summary>
        private static void Transferir()
        {
            try
            {
                Console.WriteLine("Transferir");
                Cliente clienteOrigem = Cliente.PedeContaEBuscaCliente(listClientes, "Digite o número da conta de origem: ", false);
                if (clienteOrigem == null)
                {
                    return;
                }

                Cliente clienteDestino = Cliente.PedeContaEBuscaCliente(listClientes, "Digite o número da conta de destino: ", false);
                if (clienteDestino == null)
                {
                    return;
                }

                double valorTransferencia = EeS.PedeEvalidaDouble("Digite o valor a ser transferido: ");

                Console.Write("Digite a senha: ");
                string senha = EeS.ReadConsoleLine();

                if (clienteOrigem.Transferir(senha, valorTransferencia, clienteDestino))
                {
                    //salva o arquivo incluindo a nova conta
                    ArmazenaDados.SaveList(pathListClientesFile, listClientes);
                    logger.Trace($"Transferência de {valorTransferencia} realizada de conta [{clienteOrigem.NumConta} - {clienteOrigem.Nome}] para a conta [{clienteDestino.NumConta} - {clienteDestino.Nome}]");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Solicita dados e deposita valor
        /// </summary>
        private static void Depositar()
        {
            try
            {
                Console.WriteLine("Depositar");

                Cliente objCliente = Cliente.PedeContaEBuscaCliente(pListClientes: listClientes, pVerboseForAvailability: false);
                if (objCliente == null)
                {
                    return;
                }

                double valorDeposito = EeS.PedeEvalidaDouble("Digite o valor a ser depositado: ");

                if (!operadorLogado.SolicitarSenha())
                {
                    return;
                }

                objCliente.Depositar(valorDeposito);
                //salva o arquivo incluindo a nova conta
                ArmazenaDados.SaveList(pathListClientesFile, listClientes);
                logger.Trace($"Depósito de {valorDeposito} na conta [{objCliente.NumConta} - {objCliente.Nome}] realizado com sucesso!");
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Solicita dados e realiza saque
        /// </summary>
        private static void Sacar()
        {
            try
            {
                Console.WriteLine("Sacar");
                Cliente objConta = Cliente.PedeContaEBuscaCliente(listClientes, pVerboseForAvailability: false);
                if (objConta == null)
                {
                    return;
                }

                Console.Write("Digite o valor a ser sacado: ");
                double valorSaque = double.Parse(EeS.ReadConsoleLine());

                Console.Write("Digite a senha: ");
                string senha = EeS.ReadConsoleLine();

                if (objConta.Sacar(valorSaque, senha))
                {
                    //salva o arquivo incluindo a nova conta
                    ArmazenaDados.SaveList(pathListClientesFile, listClientes);
                    logger.Trace($"Saque de {valorSaque} realizado na conta [{objConta.NumConta} - {objConta.Nome}]");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 5
0
        private static void AlterarSenhaDoOperador()
        {
            try
            {
                Console.WriteLine("Alterar a Senha Do Operador");

                string senhaAntiga;
                if (!operadorLogado.SolicitarSenha(out senhaAntiga))
                {
                    Console.WriteLine("Senha incorreta!");
                    return;
                }

                Console.Write("Insira a nova senha: ");
                String senhaNova = EeS.ReadConsoleLine();

                if (operadorLogado.AlterarSenha(senhaAntiga, senhaNova))
                {
                    //salva o arquivo incluindo a nova conta
                    ArmazenaDados.SaveList(pathListOperadoresFile, listOperadores);
                    logger.Trace($"Senha do operador [{operadorLogado.Usuario} - {operadorLogado.Nome} ] alterada com sucesso!");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Solicita dados e insere nova conta de cliente.
        /// </summary>
        private static void InserirConta()
        {
            try
            {
                Console.WriteLine("Inserir nova conta");

                int entradaTipoConta = EeS.PedeEvalidaInteger("Digite 1 para Conta Física ou 2 para Jurídica: ");

                int entradaNumeroConta = EeS.PedeEvalidaInteger("Insira o número desejado para a conta: ");

                bool    contaDisponivel = false;
                Cliente cliente         = null;
                do
                {
                    contaDisponivel = true;
                    if ((cliente = Cliente.BuscaCliente(pListContas: listClientes,
                                                        entradaNumeroConta,
                                                        pVerboseForAvailability: true))
                        != null)
                    {
                        contaDisponivel    = false;
                        entradaNumeroConta = EeS.PedeEvalidaInteger("Insira outro número para a conta: ");
                    }
                } while (contaDisponivel == false);

                Console.Write("Digite o Nome do Cliente: ");
                string entradaNome = EeS.ReadConsoleLine();

                double entradaSaldo = EeS.PedeEvalidaDouble("Digite o saldo inicial: ");

                double entradaCredito = EeS.PedeEvalidaDouble("Digite o crédito concedido: ");

                Console.Write("Crie a senha com 6 dígitos numéricos: ");
                String entradaSenha = EeS.ReadConsoleLine();

                while (!Password.ValidaRegraSenha(entradaSenha))
                {
                    Console.WriteLine("Por favor, insira uma senha numérica de 6 dígitos.");
                    entradaSenha = EeS.ReadConsoleLine();
                }

                Cliente novaConta = new Cliente(pTipoConta: (TipoConta)entradaTipoConta,
                                                pSaldo: entradaSaldo,
                                                pCredito: entradaCredito,
                                                pNome: entradaNome,
                                                pNumConta: entradaNumeroConta,
                                                pSenha: entradaSenha);

                listClientes.Add(novaConta);
                //salva o arquivo incluindo a nova conta
                ArmazenaDados.SaveList(pathListClientesFile, listClientes);
                logger.Trace("Conta Criada: " + novaConta.ToString());
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Solicita senha ao operador e verifica. Retorna via  out a senha digitada.
        /// </summary>
        /// <param name="senha"></param>
        /// <returns>True se as senhas conferem</returns>
        internal bool SolicitarSenha(out string senha)
        {
            Console.WriteLine($"Operador [{this.Nome}], insira a senha: ");
            senha = EeS.ReadConsoleLine();

            bool senhasConferem = false;

            if (!(senhasConferem = Password.CompararSenhas(senha, this.Salt, this.Senha)))
            {
                Console.WriteLine("Senha incorreta!");
            }

            return(senhasConferem);
        }
Esempio n. 8
0
        /// <summary>
        /// Solicita dados e insere novo operador
        /// </summary>
        private static void InserirOperador()
        {
            try
            {
                Console.WriteLine("Inserir novo operador");

                Console.WriteLine("Digite o usuário: ");
                string entradaUsuario = EeS.ReadConsoleLine();

                bool     operadorDisponivel = false;
                Operador operador           = null;
                do
                {
                    operadorDisponivel = true;
                    if ((operador = Operador.BuscaOperador(pListOperadores: listOperadores,
                                                           entradaUsuario,
                                                           pVerboseForAvailability: true))
                        != null)
                    {
                        operadorDisponivel = false;
                        Console.WriteLine("Tente outro usuário: ");
                        entradaUsuario = EeS.ReadConsoleLine();
                    }
                } while (operadorDisponivel == false);

                Console.Write("Digite o Nome do Operador: ");
                string entradaNome = EeS.ReadConsoleLine();

                Console.Write("Crie a senha do operador: ");
                String entradaSenha = EeS.ReadConsoleLine();

                Operador novoOperador = new Operador(pUsuario: entradaUsuario,
                                                     pSenha: entradaSenha,
                                                     pNome: entradaNome);

                listOperadores.Add(novoOperador);
                //salva o arquivo incluindo o novo operador
                ArmazenaDados.SaveList(pathListOperadoresFile, listOperadores);
                logger.Trace("Operador Criado: " + novoOperador.ToString());
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 9
0
        /// <summary>
        /// Solicita dados e altera a senha da conta de cliente
        /// </summary>
        private static void AlterarSenhaDeConta()
        {
            try
            {
                Console.WriteLine("Alterar Senha De Conta");

                Cliente objCliente = Cliente.PedeContaEBuscaCliente(listClientes, pVerboseForAvailability: false);
                if (objCliente == null)
                {
                    return;
                }

                Console.Write("Digite a senha atual: ");
                string senhaAntiga = EeS.ReadConsoleLine();
                //Validação de senha
                if (!Password.CompararSenhas(senhaAntiga, objCliente.Salt, objCliente.Senha))
                {
                    Console.WriteLine("Senha incorreta!");
                    return;
                }

                Console.Write("Crie a nova senha com 6 dígitos numéricos: ");
                String senhaNova = EeS.ReadConsoleLine();

                while (!Password.ValidaRegraSenha(senhaNova))
                {
                    Console.WriteLine("Por favor, insira uma senha numérica de 6 dígitos.");
                    senhaNova = EeS.ReadConsoleLine();
                }

                if (objCliente.AlterarSenha(senhaAntiga, senhaNova))
                {
                    //salva o arquivo incluindo a nova conta
                    ArmazenaDados.SaveList(pathListClientesFile, listClientes);
                    logger.Trace($"Senha da conta [{objCliente.NumConta} - {objCliente.Nome} ] alterada com sucesso!");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }//fim AlterarSenhaDeConta()
Esempio n. 10
0
        /// <summary>
        /// solicita dados e exclui operador
        /// </summary>
        private static void ExcluirOperador()
        {
            try
            {
                Console.WriteLine("Excluir Operador");
                Operador operador = null;

                Console.WriteLine("Digite o usuário a ser excluído: ");
                string entradaUsuario = EeS.ReadConsoleLine();

                if (operadorLogado.Usuario.Equals(entradaUsuario))
                {
                    Console.WriteLine("Você não pode excluir a si mesmo.");
                    //todo incluir logoff automático em caso se autoexclusao
                    return;
                }

                if ((operador = Operador.BuscaOperador(pListOperadores: listOperadores,
                                                       pUsuario: entradaUsuario,
                                                       pVerboseForAvailability: false))
                    == null)
                {
                    return;
                }

                if (!operadorLogado.SolicitarSenha())
                {
                    return;
                }

                if (listOperadores.Remove(operador))
                {
                    //salva o arquivo incluindo o novo operador
                    ArmazenaDados.SaveList(pathListOperadoresFile, listOperadores);
                    logger.Trace($"Operador [{operador.Usuario}] removido com sucesso!");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Solicita ao usuário e valida uma entrada numérica int
        /// </summary>
        /// <param name="pMsg">Mensagem de pedido de entrada ao usuário</param>
        /// <param name="pLoopUntilValid">Solicitar entrada até receber entrada válida</param>
        /// <returns></returns>
        public static int PedeEvalidaInteger(string pMsg, bool pLoopUntilValid = true)
        {
            bool isInputOk        = false;
            int  entradaDoUsuario = 0;

            while (!isInputOk && pLoopUntilValid)
            {
                try
                {
                    Console.WriteLine(pMsg);
                    entradaDoUsuario = int.Parse(EeS.ReadConsoleLine());
                    isInputOk        = true;
                }
                catch (Exception)
                {
                    Console.WriteLine("Digite apenas números!");
                    isInputOk = false;
                }
            }
            return(entradaDoUsuario);
        }
Esempio n. 12
0
        /// <summary>
        /// Solicita o número da conta e retorna Objeto de Cliente na List
        /// </summary>
        /// <param name="pListClientes">List de clientes</param>
        /// <param name="pMsg">Mensagem a ser exibida solicitando conta</param>
        /// <param name="pVerboseForAvailability">Exibir mensagens de resultado informando de disponível/indisponível ou encontrada/não encontrada</param>
        /// <returns></returns>
        internal static Cliente PedeContaEBuscaCliente(List <Cliente> pListClientes, string pMsg = "Digite o número da conta: ", bool pVerboseForAvailability = true)
        {
            int conta = EeS.PedeEvalidaInteger(pMsg);

            return(Cliente.BuscaCliente(pListClientes, conta, pVerboseForAvailability));
        }
Esempio n. 13
0
        private static string ExibeMenu1()
        {
            try
            {
                bool   isValidOption = false;
                string opcaoUsuario  = "";

                do
                {
                    Console.WriteLine();

                    Console.WriteLine("OPERADOR: " + operadorLogado.Nome);
                    Console.WriteLine("Informe a opção desejada:");
                    Console.WriteLine("1- Depositar");
                    Console.WriteLine("2- Sacar");
                    Console.WriteLine("3- Transferir");
                    Console.WriteLine();
                    Console.WriteLine("A- Listar contas");
                    Console.WriteLine("B- Inserir nova conta");
                    Console.WriteLine("C- Excluir conta");
                    Console.WriteLine("D- Alterar senha de conta");
                    Console.WriteLine();
                    Console.WriteLine("E- Listar operadores");
                    Console.WriteLine("F- Inserir Operador");
                    Console.WriteLine("G- Remover Operador");
                    Console.WriteLine("H- Alterar senha do Operador");
                    Console.WriteLine();
                    Console.WriteLine("L- Limpar Tela");
                    Console.WriteLine("S- Sair/Fechar");
                    Console.WriteLine("Z- Fazer Logoff");
                    //todo implementar menu com setas

                    Console.WriteLine();
                    opcaoUsuario = EeS.ReadConsoleLine().ToUpper();

                    switch (opcaoUsuario)
                    {
                    case "1":
                        isValidOption = true;
                        Depositar();
                        break;

                    case "2":
                        isValidOption = true;
                        Sacar();
                        break;

                    case "3":
                        isValidOption = true;
                        Transferir();
                        break;

                    case "A":
                        isValidOption = true;
                        ListarContas();
                        break;

                    case "B":
                        isValidOption = true;
                        InserirConta();
                        break;

                    case "C":
                        isValidOption = true;
                        ExcluirConta();
                        break;

                    case "D":
                        isValidOption = true;
                        AlterarSenhaDeConta();
                        break;

                    case "E":
                        isValidOption = true;
                        ListarOperadores();
                        break;

                    case "F":
                        isValidOption = true;
                        InserirOperador();
                        break;

                    case "G":
                        isValidOption = true;
                        ExcluirOperador();
                        break;

                    case "H":
                        isValidOption = true;
                        AlterarSenhaDoOperador();
                        break;


                    case "L":
                        isValidOption = true;
                        Console.Clear();
                        break;

                    case "S":
                        isValidOption = true;
                        Environment.Exit(0);
                        break;

                    case "Z":
                        //logoff
                        isValidOption = true;
                        logger.Trace($"Operador [{operadorLogado.Nome}] fez logoff.");
                        operadorLogado = null;
                        break;

                    default:
                        isValidOption = false;
                        Console.WriteLine("Opção inválida!");
                        break;
                    }
                } while (isValidOption == false);

                return(opcaoUsuario);
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message);
                return("");
            }
        }