public void Desbloquear_ContaCorrente()
{
ContaCorrente conta = new ContaCorrente();
ServicoConta.Bloquear(conta);
ServicoConta.Desbloquear(conta);
Assert.DoesNotThrow(() => ServicoConta.ExecutarDeposito(conta, 500));
}
public static void Desbloquear(ContaCorrente conta)
{
if (conta.Status == "Bloqueada")
conta.Status = "Ativa";
else
throw new InvalidOperationException("Não se pode desbloquear uma conta com o status=" + conta.Status);
}
public void Cancelar_ContaCorrente()
{
ContaCorrente conta = new ContaCorrente();
ServicoConta.Cancelar(conta);
Assert.AreEqual("Fechada", conta.Status);
}
public void CriarContaCorrente()
{
ContaCorrente conta = new ContaCorrente();
conta.DataAbertura = DateTime.Now;
Assert.IsNull(conta.Agencia);
Assert.AreEqual(DateTime.Now, conta.DataAbertura);
Assert.IsNull(conta.Cliente);
}
public void Deposito_transacoesBancarias()
{
RepositorioTransacaoBancaria.Limpar();
ContaCorrente conta = new ContaCorrente();
conta.Credita(1000);
var d = ServicoConta.ExecutarDeposito(conta, 500);
Assert.IsNotNull(d.Comprovante);
Assert.AreEqual(1500, conta.Saldo);
}
public void EmitirExtratos()
{
RepositorioTransacaoBancaria.Limpar();
ContaCorrente conta = new ContaCorrente();
RepositorioTransacaoBancaria.Adicionar(new Deposito(conta, 10000));
RepositorioTransacaoBancaria.Adicionar(new Saque(conta, 500));
RepositorioTransacaoBancaria.Adicionar(new Saque(conta, 500));
Assert.AreEqual(3, RepositorioTransacaoBancaria.EmiteExtrato(conta, 20).Count());
}
private void btnCadastrar_Click(object sender, EventArgs e)
{
OperacoesContas contaSelecionata = (OperacoesContas) cboTipo.SelectedItem;
ContaCorrente cc = new ContaCorrente();
cc.Numero = int.Parse(txtNumero.Text);
//aplicacaoPrincipal.AdicionaConta(conta);
}
public void testar_saque_transacoesBancarias1()
{
RepositorioTransacaoBancaria.Limpar();
ContaCorrente conta = new ContaCorrente();
conta.Credita(1000);
conta.Numero = 123;
ServicoSaque servicoSaque = new ServicoSaque(conta, 500);
Assert.AreEqual(1, RepositorioTransacaoBancaria.Listar().Count);
Assert.IsNotNull(RepositorioTransacaoBancaria.Listar().Cast<Saque>().FirstOrDefault());
}
public void Imprimir_Extrato_Conta_Inativa()
{
ContaCorrente conta = new ContaCorrente();
RepositorioTransacaoBancaria.Adicionar(new Deposito(conta, 1000));
RepositorioTransacaoBancaria.Adicionar(new Saque(conta, 200));
ServicoConta.Bloquear(conta);
Extrato extrato = new Extrato(conta, DateTime.Now.AddDays(-1), DateTime.Now);
Assert.Throws<InvalidOperationException>(() => extrato.Executa());
Assert.IsNotNull(extrato.Comprovante.Descricao);
}
public static ContaCorrente AbrirContaNormal(Cliente cliente, Agencia agencia)
{
var cc = new ContaCorrente()
{
Numero = Contas.Count > 0 ? Contas.Max(c => c.Numero) + 1 : 1,
DataAbertura = DateTime.Now,
Agencia = agencia,
Cliente = cliente,
};
Contas.Add(cc);
return cc;
}
public void Imprimir_Extrato()
{
ContaCorrente conta = new ContaCorrente();
RepositorioTransacaoBancaria.Adicionar(new Deposito(conta, 1000));
RepositorioTransacaoBancaria.Adicionar(new Saque(conta, 200));
Extrato extrato = new Extrato(conta, DateTime.Now.AddDays(-1), DateTime.Now);
extrato.Executa();
Assert.AreEqual(2, extrato.TransacoesBancarias.Count());
}
public static Saque ExecutarSaque(ContaCorrente conta, decimal valor)
{
Saque saque;
if (conta.Ativa && conta.Saldo >= valor)
{
saque = new Saque(conta, valor);
saque.Executa();
RepositorioTransacaoBancaria.Adicionar(saque);
}
else
{
throw new InvalidOperationException("Conta bloqueada ou saldo insuficiente!");
}
return saque;
}
public static Transferencia ExecutarTransferencia(ContaCorrente contaOrigem, ContaCorrente contaDestino, decimal valor)
{
Transferencia transacao;
if (contaOrigem.Ativa && contaDestino.Ativa)
{
transacao = new Transferencia(contaOrigem, contaDestino, valor);
transacao.Executa();
RepositorioTransacaoBancaria.Adicionar(transacao);
}
else
{
throw new InvalidOperationException("Conta bloqueada ou saldo insuficiente!");
}
return transacao;
}
private void botaoImpostos_Click(object sender, EventArgs e)
{
ContaCorrente conta = new ContaCorrente();
conta.Deposita(200.0);
SeguroDeVida sv = new SeguroDeVida();
TotalizadorDeTributos totalizador = new TotalizadorDeTributos();
totalizador.Adiciona(conta);
MessageBox.Show("Total = " + totalizador.Total);
totalizador.Adiciona(sv);
MessageBox.Show("Total = " + totalizador.Total);
}
public static Deposito ExecutarDeposito(ContaCorrente conta, decimal valor)
{
Deposito deposito = null;
if (conta.Ativa)
{
deposito = new Deposito(conta, valor);
deposito.Executa();
RepositorioTransacaoBancaria.Adicionar(deposito);
}
else
{
throw new InvalidOperationException("Conta bloqueada ou saldo insuficiente!");
}
return deposito;
}
public ContaCorrente Save(ContaCorrente entity)
{
using (var context = new RThomazDbEntities())
{
if (entity.ContaId == 0)
{
entity.DataCriacao = DateTime.Now;
context.Conta.AddObject(entity);
}
else
{
context.CreateObjectSet<Conta>().Attach(entity);
context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
}
context.SaveChanges();
}
return entity;
}
private void botaoCadastro_Click(object sender, EventArgs e)
{
string titular = textoTitular.Text;
bool ehDevedor = false;
for (int i = 0; i < 30000; i++)
{
ehDevedor = this.devedores.Contains(titular);
}
if (!ehDevedor)
{
ContaCorrente novaConta = new ContaCorrente();
novaConta.Titular = new Cliente(textoTitular.Text);
this.formPrincipal.AdicionaConta(novaConta);
}
else
{
MessageBox.Show("devedor");
}
}
public void testar_extrato()
{
var conta = new ContaCorrente();
conta.Credita(1000);
conta.Numero = 123;
var extrato = new Extrato(conta);
extrato.Executa();
RepositorioTransacaoBancaria.LimparRepositorio();
RepositorioTransacaoBancaria.Adicionar(extrato);
Assert.Contains(extrato, RepositorioTransacaoBancaria.Listar());
Extrato recuperado = RepositorioTransacaoBancaria.Listar().Cast<Extrato>().FirstOrDefault();
List<Extrato> extratos = RepositorioTransacaoBancaria.Listar()
.Where(t => t.GetType().Name == typeof(Extrato).Name)
.Cast<Extrato>()
.ToList();
Assert.AreEqual(extrato, recuperado);
}
public IEnumerable <ContaCorrente> List(ContaCorrente cc)
{
return(_contaCorrenteRepository.List(cc));
}
public string extrato(ContaCorrente conta)
{
return(conta.ToString());
}
public static void Main()
{
Console.OutputEncoding = Encoding.UTF8;
Console.WriteLine("Abrindo Contas...");
var contaCorrente1 = new ContaCorrente(6000, 15);
var contaCorrente2 = new ContaCorrente(5510, 10);
var contaEspecial1 = new ContaEspecial(5000, 10000);
var contaEspecial2 = new ContaEspecial(3000, 1000);
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Contas Criadas:");
contaCorrente1.MostrarDados();
contaCorrente2.MostrarDados();
contaEspecial1.MostrarDados();
contaEspecial2.MostrarDados();
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Depositando R$500,00 em Todas as contas...");
contaCorrente1.Depositar(500);
contaCorrente2.Depositar(500);
contaEspecial1.Depositar(500);
contaEspecial2.Depositar(500);
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Exibindo informações atualizadas:");
contaCorrente1.MostrarDados();
contaCorrente2.MostrarDados();
contaEspecial1.MostrarDados();
contaEspecial2.MostrarDados();
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Sacando R$1000,00 em Todas as contas...");
Console.WriteLine($"Saque na conta {contaCorrente1.Numero} foi {(contaCorrente1.Sacar(1000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaCorrente2.Numero} foi {(contaCorrente2.Sacar(1000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaEspecial1.Numero} foi {(contaEspecial1.Sacar(1000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaEspecial2.Numero} foi {(contaEspecial2.Sacar(1000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Exibindo informações atualizadas:");
contaCorrente1.MostrarDados();
contaCorrente2.MostrarDados();
contaEspecial1.MostrarDados();
contaEspecial2.MostrarDados();
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Sacando R$5000,00 em Todas as contas...");
Console.WriteLine($"Saque na conta {contaCorrente1.Numero} foi {(contaCorrente1.Sacar(5000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaCorrente2.Numero} foi {(contaCorrente2.Sacar(5000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaEspecial1.Numero} foi {(contaEspecial1.Sacar(5000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine($"Saque na conta {contaEspecial2.Numero} foi {(contaEspecial2.Sacar(5000) ? "Autorizado." : "Rejeitado.")}");
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("Exibindo informações atualizadas:");
contaCorrente1.MostrarDados();
contaCorrente2.MostrarDados();
contaEspecial1.MostrarDados();
contaEspecial2.MostrarDados();
}
public static void Cancelar(ContaCorrente conta)
{
if (conta.Saldo != 0)
throw new InvalidOperationException("Não se pode cancelar uma conta com saldo negativo ou positivo");
conta.Status = "Fechada";
}
public IEnumerable <ContaCorrente> Put([FromBody] ContaCorrente contaCorrente)
{
_repo.Alterar(contaCorrente);
return(_repo.SelecionarTudo());
}
public ClienteContaCorrente(Cliente cliente, ContaCorrente contaCorrente)
{
this._cliente = cliente;
this._contaCorrente = contaCorrente;
}
protected void Page_Load(object sender, EventArgs e)
{
txtMsg.Visible = false;
string primeiroLogin = Session["PrimeiroLogin"] as string;
if (primeiroLogin == null)
{
// Instanciação de Banco e Contas contábeis
Banco banco = new Banco()
{
Nome = "Banco Exemplo"
};
ContaContabilEmprestimo cce = new ContaContabilEmprestimo()
{
Emprestimos = new List <Emprestimo>(),
BancoProp = banco
};
ContaContabilInvestimento cci = new ContaContabilInvestimento()
{
Investimentos = new List <Investimento>(),
BancoProp = banco
};
banco.ContaEmprestimo = cce;
banco.ContaInvestimento = cci;
Session["Emprestimos"] = cce;
Session["Investimentos"] = cci;
Session["Banco"] = banco;
Cliente cliente = new Cliente()
{
Id = 1,
Nome = "Usuario",
//Cpf = "00000000000",
Cpf = "0",
Senha = "123"
};
Session["Cliente"] = cliente;
Session["ContaCorrente"] = new ContaCorrente()
{
Id = 1,
ClienteProp = cliente,
Limite = 1000.00,
Numero = "1",
Saldo = 1500.00,
Tipo = "Silver",
Transacoes = new List <Transacao>(),
BancoProp = Session["Banco"] as Banco
};
Cliente cliente2 = new Cliente()
{
Id = 2,
Nome = "Usuario 2",
//Cpf = "00000000000",
Cpf = "1",
Senha = "123"
};
Session["Cliente2"] = cliente2;
Session["ContaCorrente2"] = new ContaCorrente()
{
Id = 2,
ClienteProp = cliente2,
Limite = 6000.00,
Numero = "2",
Saldo = 8500.00,
Tipo = "Gold",
Transacoes = new List <Transacao>(),
BancoProp = Session["Banco"] as Banco
};
}
}
public ContaCorrente Update(ContaCorrente obj)
{
_repository.Update(obj);
return(obj);
}
public async Task Atualiza(ContaCorrente contaCorrente)
{
conta = contaCorrente;
await Task.CompletedTask;;
}
public ContaCorrente Insert(ContaCorrente obj)
{
_repository.Insert(obj);
return(obj);
}
static void Main(string[] args)
{
ContaCorrente cc = new ContaCorrente("Victor");
ContaPoupanca cp = new ContaPoupanca(5, new DateTime(1999, 02, 03), "Victor");
while (true)
{
Console.WriteLine("[1] - Depositar");
Console.WriteLine("[2] - Sacar");
Console.WriteLine("[3] - Verificar saldo");
Console.WriteLine("[4] - Verificar titular");
int firstOP = int.Parse(Console.ReadLine());
Console.WriteLine("\n");
Console.WriteLine("[1] - Conta corrente");
Console.WriteLine("[2] - Conta poupança");
int secondOP = int.Parse(Console.ReadLine());
if (firstOP == 1 && secondOP == 1)
{
Console.WriteLine("Digite o valor: ");
decimal vl = decimal.Parse(Console.ReadLine());
cc.Depositar(vl);
Console.WriteLine("deposito realizado");
}
else
{
if (firstOP == 1 && secondOP == 2)
{
Console.WriteLine("Digite o valor: ");
decimal vl = decimal.Parse(Console.ReadLine());
cp.Depositar(vl);
Console.WriteLine("deposito realizado");
}
}
if (firstOP == 2 && secondOP == 1)
{
Console.WriteLine("Digite o valor: ");
decimal vl = decimal.Parse(Console.ReadLine());
if (vl > cc.Saldo)
{
Console.WriteLine("Saldo insucifiente");
}
else
{
cc.Sacar(vl);
Console.WriteLine("saque realizado");
}
}
else
{
if (firstOP == 2 && secondOP == 2)
{
Console.WriteLine("Digite o valor: ");
decimal vl = decimal.Parse(Console.ReadLine());
if (vl > cp.Saldo)
{
Console.WriteLine("Saldo insucifiente");
}
else
{
cp.Sacar(vl);
Console.WriteLine("saque realizado");
}
}
}
if (firstOP == 3 && secondOP == 1)
{
Console.WriteLine("Saldo CC: {0}", cc.Saldo);
}
else
{
if (firstOP == 3 && secondOP == 2)
{
Console.WriteLine("Saldo CP: {0}", cp.Saldo);
}
}
if (firstOP == 4 && secondOP == 1)
{
Console.WriteLine("Titular CC: {0}", cc.Titular);
}
else
{
if (firstOP == 4 && secondOP == 2)
{
Console.WriteLine("Titular CP: {0}", cp.Titular);
}
}
Console.WriteLine("\npressione uma tecla para continuar.");
Console.ReadKey();
Console.Clear();
}
}
public void DeletarConta(ContaCorrente contaCorrente)
{
contaCorrenteDAO.DeletarConta(contaCorrente);
}
private void AtualizaLabels()
{
cc = Session["contaCorrente"] as ContaCorrente;
lblContaAtual.Text = cc.Numero.ToString();
lblSaldo.Text = ((float)cc.Saldo).ToString("c2");
}
public void ExcluirContaCorrente(ContaCorrente pContaCorrente)
{
_dataset.Delete(pContaCorrente);
}
public Transacao Depositar(ContaCorrente conta, Valor valor)
{
conta.Depositar(valor);
return(_LancamentoService.Registrar(new Lancamento(TipoLancamento.Credito, conta.Id, valor)));
}
private void btnIncluirConta_Click(object sender, EventArgs e)
{
Cliente cliente = (Cliente)cbxCliente.SelectedItem;
RespostaBase resposta = new RespostaBase()
{
Mensagem = "Houve algum problema",
Sucesso = false
};
if (rdbContaComum.Checked)
{
ContaCorrente cc = new ContaCorrente()
{
Agencia = int.Parse(txtAgencia.Text),
Banco = int.Parse(txtBanco.Text),
Correntista = (Cliente)cbxCliente.SelectedItem,
NumeroConta = txtConta.Text
};
if (_cCorrenteRepositorio.Buscar(cc.Agencia, cc.NumeroConta) == null)
{
resposta = _cCorrenteRepositorio.Incluir(cc);
cbxConta.Items.Add(cc);
}
else
{
resposta = new RespostaBase()
{
Sucesso = false,
Mensagem = "Conta já cadastrada"
};
}
}
else if (rdbContaEspecial.Checked)
{
ContaEspecial ce = new ContaEspecial()
{
Agencia = int.Parse(txtAgencia.Text),
Banco = int.Parse(txtBanco.Text),
Correntista = (Cliente)cbxCliente.SelectedItem,
NumeroConta = txtConta.Text,
Limite = double.Parse(txtLimite.Text)
};
if (_cEspecialRepositorio.Buscar(ce.Agencia, ce.NumeroConta) == null)
{
resposta = _cEspecialRepositorio.Incluir(ce);
cbxConta.Items.Add(ce);
}
else
{
resposta = new RespostaBase()
{
Sucesso = false,
Mensagem = "Conta já cadastrada."
};
}
}
MessageBox.Show(resposta.Mensagem, resposta.Sucesso ? "Sucesso" : "Falha", MessageBoxButtons.OK, resposta.Sucesso ? MessageBoxIcon.Information : MessageBoxIcon.Error);
}
public static IEnumerable<TransacaoBancaria> EmiteExtrato(ContaCorrente conta, DateTime ini, DateTime fim)
{
return transacoes.Where(t =>
t.Data >= ini && t.Data <= fim &&
t.Conta == conta);
}
public void Salvar(ContaCorrente conta)
{
_db[conta.Conta] = conta;
}
public void DebitoCredito(ContaCorrente contaCorrente, bool TipoConta)
{
contaCorrenteDAO.DebitoCredito(contaCorrente, TipoConta);
}
public void Transferencia_transacoesBancarias()
{
RepositorioTransacaoBancaria.Limpar();
ContaCorrente conta = new ContaCorrente();
conta.Credita(1000);
ContaCorrente contaDestino = new ContaCorrente();
var transf = ServicoConta.ExecutarTransferencia(conta,contaDestino, 500);
Assert.IsNotNull(transf.Comprovante);
Assert.AreEqual(500, conta.Saldo);
Assert.AreEqual(500, contaDestino.Saldo);
}
public void Desbloquear_ContaCorrente_Ativa_Deve_Falhar()
{
ContaCorrente conta = new ContaCorrente();
Assert.Throws<InvalidOperationException>(() => ServicoConta.Desbloquear(conta));
}
public void Transferencia_transacoesBancarias_ContaEspecial()
{
RepositorioTransacaoBancaria.Limpar();
ContaEspecial conta = new ContaEspecial();
conta.LimiteCredito = 7000;
ContaCorrente contaDestino = new ContaCorrente();
ServicoConta.ExecutarTransferencia(conta, contaDestino, 500);
Assert.AreEqual(-500, conta.Saldo);
Assert.AreEqual(500, contaDestino.Saldo);
}
public void Salvar(ContaCorrente origem)
{
throw new NotImplementedException();
}
public void EncerraConta(ContaCorrente contaOrigem)
{
ValidaSaldo(contaOrigem, 0, "Encerramento");
contaOrigem.Status = ContaCorrente.StatusConta.Encerrada.ToString();
}
public void ADD(ContaCorrente conta)
{
contas.Add(conta);
}
public void Bloquear_ContaCorrente()
{
ContaCorrente conta = new ContaCorrente();
ServicoConta.Bloquear(conta);
Assert.Throws<InvalidOperationException>(() => ServicoConta.ExecutarDeposito(conta, 500));
}
public int Add(ContaCorrente cc)
{
return(_contaCorrenteRepository.Add(cc));
}
public void Transferencia_transacoesBancarias_Conta_Debita_ValorNegativo()
{
RepositorioTransacaoBancaria.Limpar();
var conta = new ContaCorrente();
Assert.Throws<ArgumentException>(() => conta.Debita(-100));
}
public ActionResult Incluir()
{
var contaCorrente = new ContaCorrente();
return(View(contaCorrente));
}
public void Transferencia_transacoesBancarias_Saldo_Zerado()
{
RepositorioTransacaoBancaria.Limpar();
ContaCorrente conta = new ContaCorrente();
ContaCorrente contaDestino = new ContaCorrente();
Assert.Throws<InvalidOperationException>(() => ServicoConta.ExecutarTransferencia(conta, contaDestino, 500));
}
} // fim FormCadastroConta_Load
/// <summary>
/// Metodo executado quando o botao cadastrar é clicado.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void botaoCadastrar_Click(object sender, EventArgs e)
{
// Recupero o nome digitado no campo do formulário
string titular = this.textoTitular.Text;
// Verifico se o nome existe na lista. A não ser que você tenha digitado um nome como "devedor 1", não será encontrado.
// E não tem problema não encontrar! É de propósito. Queremos que o código percorra a coleção procurando pelo nome e não encontrar.
bool ehDevedor = false;
// Esse loop também não tem sentido prático nenhum, a não ser para testar a diferença de desempenho entre List e Set.
for (int i = 0; i < 30000; i++)
{
ehDevedor = this.devedores.Contains(titular);
} // fim for
// Se for um devedor...
if (ehDevedor)
{
// ...exibe mensagem de devedor
MessageBox.Show("Devedor!");
} // fim if
else // ...caso contrário, continuar a criar a nova conta.
{
// Declarando a variável da nova conta. Não foi incializada, pois vai depender do tipo de conta selecionado no formulário.
Conta novaConta;
// Recupera o índice selecionado na combo de tipo de conta.
var indiceTipo = comboTipo.SelectedIndex;
// Não falamos de switch no curso, mas ele é muito útil, principalmente nesses casos de tipo
// Passamos para o switch a opção a ser verificada...
switch (indiceTipo)
{
// ...caso o indiceTipo seja do mesmo indice da POUPANCA no enum (ou seja, 0)
case (int)TipoConta.POUPANCA:
// Instancio a nova conta como poupança.
novaConta = new ContaPoupanca();
// Preciso colocar break aqui, pois já encontrei a opção que queria. Se não colocar break, o código
// continuará testando as outras opções do switch. Não é o que queremos.
break;
// ...caso o indiceTipo seja do mesmo indice da CORRENTE no enum (ou seja, 1)
case (int)TipoConta.CORRENTE:
// Instancio a nova conta como corrente.
novaConta = new ContaCorrente();
// Preciso colocar break aqui, pois já encontrei a opção que queria. Se não colocar break, o código
// continuará testando as outras opções do switch. Não é o que queremos.
break;
// Se não cair em nenhum caso acima, temos o cenário default
default:
// Agora não podemos mais instanciar uma Conta. Temos que escolher um dos tipos para ser o default.
//novaConta = new Conta();
novaConta = new ContaPoupanca();
// Apesar do default sempre ser a última opção do switch, é uma boa prática colocar o break.
break;
} // fim switch
// Atribui o número digitado no formulário à propriedade da instância criada.
// Esse código agora não é mais utilizado. O número é gerado automaticamente.
// novaConta.Numero = Convert.ToInt32(textoNumero.Text);
// Cria uma nova instância do Cliente com o nome digitado no formulário.
novaConta.Titular = new Cliente(textoTitular.Text);
// Adiciona a nova conta criada ao vetor de contas em Form1
this.formPrincipal.Adiciona(novaConta);
// Exibe mensagem para o usuário informando que a conta foi criada com sucesso.
MessageBox.Show("Conta criada com sucesso!");
// Fecha o formulário de cadastro.
this.Close();
} // fim else
} // fim botaoCadastrar_Click
public ContaCorrente Remove(ContaCorrente entidade)
{
repository.Remove(entidade);
return(entidade);
}
public Transacao Sacar(ContaCorrente conta, Valor valor)
{
ContaCorrenteValidator.ExisteSaldoParaSaque(conta, valor);
conta.Debitar(valor);
return(_LancamentoService.Registrar(new Lancamento(TipoLancamento.Debito, conta.Id, valor)));
}
public ContaCorrenteTests()
{
_contaCorrente = new ContaCorrente();
}
public static IEnumerable<TransacaoBancaria> EmiteExtrato(ContaCorrente conta, int disParaTras)
{
var hoje = DateTime.Now;
return EmiteExtrato(conta, hoje.AddDays(-disParaTras), hoje);
}
public IEnumerable <ContaCorrente> Post([FromBody] ContaCorrente contaCorrente)
{
_repo.Incluir(contaCorrente);
return(_repo.SelecionarTudo());
}
public static void Bloquear(ContaCorrente conta)
{
conta.Status = "Bloqueada";
}
public async Task <ActionResult <IContaCorrente> > PostContaCorrente(ContaCorrente contaCorrente)
{
await _contaCorrenteService.SaveAsync(contaCorrente);
return(CreatedAtAction("GetContaCorrente", new { id = contaCorrente.Id }, contaCorrente));
}
public void Cancelar_ContaCorrente_Com_Saldo_Deve_Falhar()
{
ContaCorrente conta = new ContaCorrente();
ServicoConta.ExecutarDeposito(conta, 500);
Assert.Throws<InvalidOperationException>(() =>ServicoConta.Cancelar(conta));
}
public void CriarConta(ContaCorrente contaCorrente)
{
contaCorrenteDAO.CriarConta(contaCorrente);
}
public void Transferencia_transacoesBancarias_ContaEspecial_SemLimite()
{
RepositorioTransacaoBancaria.Limpar();
ContaEspecial conta = new ContaEspecial();
conta.LimiteCredito = 7000;
conta.Credita(1000);
ContaCorrente contaDestino = new ContaCorrente();
Assert.Throws<InvalidOperationException>(() => ServicoConta.ExecutarTransferencia(conta, contaDestino, 90000));
}
static void Main(String[] args)
{
Console.WriteLine("Programadores: Andrew de Oliveira Duchini\n\tCristóvão Olegário\n\n");
IConta[] vet = new IConta[100];//armazenamento das contas.
int indice = 0, i = 0;
string tipo_de_conta;
while (indice != 7)
{
Console.WriteLine("[1] - Criar uma nova conta");
Console.WriteLine("[2] - Excluir uma conta");
Console.WriteLine("[3] - Depositar em uma conta");
Console.WriteLine("[4] - Sacar de uma conta");
Console.WriteLine("[5] - Imprimir o extrato de uma conta");
Console.WriteLine("[6] - Imprimir uma relação das contas existentes");
Console.WriteLine("[7] - Sair do programa");
indice = Convert.ToInt32(Console.ReadLine());
switch (indice)
{
case 1:
string nome;
Console.WriteLine("Digite o tipo de conta");
tipo_de_conta = Console.ReadLine();
Console.WriteLine("Digite seu nome");
nome = Console.ReadLine();
if (tipo_de_conta == "corrente")
{
vet[i] = new ContaCorrente();
vet[i].preenche(nome, i);
Console.WriteLine("O número da sua conta é: " + vet[i].num_conta);
}
else if (tipo_de_conta == "poupanca")
{
vet[i] = new ContaPoupanca();
vet[i].preenche(nome, i);
Console.WriteLine("O número da sua conta é: " + vet[i].num_conta);
}
i++;
break;
case 2:
Console.WriteLine("Digite o numero da conta a ser excluida");
int num = Convert.ToInt32(Console.ReadLine());
int g;
for (g = 0; g < vet.Length; g++)
{
try
{
if (num == vet[g].num_conta)
{
vet[g] = null;
g = vet.Length;
Console.WriteLine("Conta excluída");
}
}
catch (NullReferenceException)
{
}
}
if (g == 100)
{
Console.WriteLine("Conta nao encontrada");
}
break;
case 3:
Console.WriteLine("Digite o número da conta");
int nume = Convert.ToInt32(Console.ReadLine());
for (g = 0; g < vet.Length; g++)
{
try
{
if (nume == vet[g].num_conta)
{
Console.WriteLine("Conta encontrada");
Console.WriteLine("Digite o valor a ser depositado");
double deposito = Convert.ToDouble(Console.ReadLine());
vet[g].Deposita(deposito);
g = vet.Length;
}
}
catch (NullReferenceException) { }
}
if (g == 100)
{
Console.WriteLine("Conta nao encontrada");
}
break;
case 4:
Console.WriteLine("Digite o numero da conta a ser sacada");
nume = Convert.ToInt32(Console.ReadLine());
for (g = 0; g < vet.Length; g++)
{
try
{
if (nume == vet[g].num_conta)
{
Console.WriteLine("Conta encontrada");
Console.WriteLine("Digite o valor a ser sacado");
double saque = Convert.ToDouble(Console.ReadLine());
vet[g].Saca(saque);
g = vet.Length;
}
}
catch (NullReferenceException) { }
}
if (g == 100)
{
Console.WriteLine("Conta nao encontrada");
}
break;
case 5:
Console.WriteLine("Digite o numero da conta");
nume = Convert.ToInt32(Console.ReadLine());
for (g = 0; g < vet.Length; g++)
{
try
{
if (nume == vet[g].num_conta)
{
Console.WriteLine("Conta encontrada");
Console.WriteLine("Seu saldo é de : R$ " + vet[g].Saldo);
g = vet.Length;
}
}
catch (NullReferenceException) { }
}
if (g == 100)
{
Console.WriteLine("Conta nao encontrada");
}
break;
case 6:
int aux = 0;
Console.WriteLine("Relação das contas existentes :");
for (g = 0; g < vet.Length; g++)
{
if (vet[g] != null)
{
Console.WriteLine("\nNome : " + vet[g].nome_do_titular + "\nNúmero da conta : " + vet[g].num_conta);
}
else
{
aux++;
}
}
if (aux == 100)
{
Console.WriteLine("\nNão há contas para serem exibidas\n");
}
break;
case 7:
break;
}
}
}