// Usuario escolhe o investimento com valor pré-estabelecido na lista
public void AplicarInvestimento(Investimento investimento)
{
// Inserir na lista da contaContabil, e na lista de transações, e fazer as relações bilaterais
// Se saldo for suficiente, instanciar uma Transação de aplicação(p/ extrato) e incluir na lista de transações o investimento em si
if (SaldoSuficiente(investimento.ValorInicial))
{
investimento.Status = "Aplicado";
investimento.Conta = this;
Transacoes.Add(investimento);
investimento.ContaContabil = BancoProp.ContaInvestimento;
investimento.ContaContabil.Investimentos.Add(investimento);
investimento.Valor = investimento.ValorInicial;
Transacao t = new Transacao()
{
Tipo = "Aplicação",
Conta = this,
Valor = -investimento.ValorInicial,
Data = DateTime.Today,
Descricao = "Aplicação feita no investimento '" + investimento.Descricao + "'"
};
Transacoes.Add(t);
Saldo -= investimento.ValorInicial;
}
}
public void Salvar()
{
if (_transacoes == null)
{
return;
}
var gerenciarTransacao = !EmTransacao;
if (gerenciarTransacao)
{
IniciarTransacao();
}
try
{
Transacoes.Salvar();
if (gerenciarTransacao)
{
ConfirmarTransacao();
}
}
catch
{
if (gerenciarTransacao)
{
CancelarTransacao();
}
throw;
}
}
// Transferência para outra conta, também sujeito a checagem de saldo
public void Transferir(double valor, ContaCorrente favorecido)
{
if (SaldoSuficiente(valor))
{
DateTime data = DateTime.Now;
Transferencia transferencia = new Transferencia()
{
Valor = -valor,
Conta = this,
Data = data,
Tipo = "Transferência",
Descricao = "Transferência realizada para a conta: " + favorecido.Numero + " Proprietário: " + favorecido.ClienteProp.Nome,
Favorecido = favorecido
};
Transacoes.Add(transferencia);
Transferencia transferido = new Transferencia()
{
Valor = valor,
Conta = favorecido,
Data = data,
Tipo = "Transferência",
Descricao = "Transferência recebida da conta:" + this.Numero + " Proprietário: " + this.ClienteProp.Nome
};
favorecido.Transacoes.Add(transferido);
// Atualizar saldos
Saldo -= valor;
favorecido.Saldo += valor;
}
}
public void Incluir(Transacoes t)
{
try
{
objCon.conn.Open();
StringBuilder query = new StringBuilder();
query.AppendLine("INSERT INTO tbTransacoes (ContaIdOrigem, ContaIdDestino, TipoTransacao, Valor, Data, AporteId) ")
.AppendLine("VALUES(@ContaIdOrigem, @ContaIdDestino, @TipoTransacao, @Valor, DATE('now'), @AporteId) ");
using (SQLiteCommand cmd = new SQLiteCommand(query.ToString(), objCon.conn))
{
cmd.Parameters.AddWithValue("@ContaIdOrigem", (t.TipoTransacao == (int)Transacoes.enuTipoTransacao.Aporte ? null : t.ContaIdOrigem));
cmd.Parameters.AddWithValue("@ContaIdDestino", t.ContaIdDestino);
cmd.Parameters.AddWithValue("@TipoTransacao", t.TipoTransacao);
cmd.Parameters.AddWithValue("@Valor", t.Valor);
cmd.Parameters.AddWithValue("@AporteId", t.AporteId);
cmd.ExecuteNonQuery();
}
}
catch (Exception)
{
throw;
}
finally
{
if (objCon.conn.State == System.Data.ConnectionState.Open)
{
objCon.conn.Close();
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,AdquirenteId,CodigoCliente,DataTransacao,HoraTransacao,NumeroCartao,CodigoAutorizacao,NSU,BandeiraId,ValorBruto,TaxaAdmin,ValorLiquido")] Transacoes transacoes)
{
if (id != transacoes.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(transacoes);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransacoesExists(transacoes.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AdquirenteId"] = new SelectList(_context.Set <Adquirente>(), "Id", "Id", transacoes.AdquirenteId);
ViewData["BandeiraId"] = new SelectList(_context.Set <Bandeira>(), "Id", "Id", transacoes.BandeiraId);
return(View(transacoes));
}
public async Task <IActionResult> PutTransacoes(int id, Transacoes transacoes)
{
if (id != transacoes.ID)
{
return(BadRequest());
}
_context.Entry(transacoes).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransacoesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public HttpResponseMessage Post(Transacoes t)
{
try
{
if (ModelState.IsValid && t != null)
{
HttpStatusCode httpStatus = HttpStatusCode.OK;
string msg = tBusiness.MovimentacaoContas(t);
if (msg.Length <= 0)
{
msg = "Registro cadastrado com sucesso!";
}
else
{
httpStatus = HttpStatusCode.BadRequest;
}
var response = new HttpResponseMessage(httpStatus)
{
Content = new StringContent(msg)
};
return(response);
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Ocorreu um erro. Por favor verifique os dados enviados."));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public SaqueViewModel Sacar(SaqueViewModel saqueViewModel)
{
var conta = _contaRepository.ObterPorId(saqueViewModel.Id);
Transacoes transacoes = new Transacoes(saqueViewModel.ValorSaque, TipoTransacao.Saque, conta.Id);
transacoes.Conta = conta;
var contaRet = _contaService.Sacar(conta, transacoes);
saqueViewModel = Mapper.Map <SaqueViewModel>(contaRet);
if (contaRet.ValidationResult.IsValid)
{
_transacaoService.Adicionar(transacoes);
}
else
{
contaRet.ValidationResult.Message = "Ocorreu um erro ao sacar!";
return(Mapper.Map <SaqueViewModel>(contaRet));
}
if (transacoes.ValidationResult.IsValid)
{
Commit();
contaRet.ValidationResult.Message = "Saque realizado com sucesso!";
}
return(Mapper.Map <SaqueViewModel>(contaRet));
}
public DepositoViewModel Depositar(DepositoViewModel depositoViewModel)
{
var conta = _contaRepository.ObterPorId(depositoViewModel.Id);
Transacoes transacoes = new Transacoes(depositoViewModel.ValorDeposito, TipoTransacao.Deposito, conta.Id);
var contaRet = _contaService.Depositar(conta, transacoes);
if (contaRet.ValidationResult.IsValid)
{
_transacaoService.Adicionar(transacoes);
}
else
{
contaRet.ValidationResult.Message = "Ocorreu um erro ao depositar!";
return(Mapper.Map <DepositoViewModel>(contaRet));
}
if (transacoes.ValidationResult.IsValid)
{
Commit();
contaRet.ValidationResult.Message = "Deposito realizado com sucesso!";
}
depositoViewModel = Mapper.Map <DepositoViewModel>(contaRet);
return(depositoViewModel);
}
public List <Transacoes> buscaVendas(MySqlCommand cmd)
{
List <Transacoes> lstVendas = new List <Transacoes>();
Abrir();
MySqlDataReader reader = Pesquisar(cmd);
while (reader.Read())
{
Transacoes ts = new Transacoes();
ts.id = reader.GetInt32(0);
ts.transacao = reader.GetInt32(1);
ts.id_Cliente = Convert.ToInt32(reader.GetString(2));
ts.cliente = reader.GetString(3);
ts.formaPagamento = reader.GetString(4);
ts.totalCompra = reader.GetString(5);
ts.operador = reader.GetString(6);
ts.dataInicio = reader.GetString(7);
ts.dataFim = reader.GetString(8);
lstVendas.Add(ts);
}
Fechar();
return(lstVendas);
}
public async Task <ActionResult <Transacoes> > PostTransacoes(Transacoes transacoes)
{
_context.Transacoes.Add(transacoes);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTransacoes", new { id = transacoes.ID }, transacoes));
}
public void Saque(int idContaOrgem, decimal valor)
{
var conta = contaServicoAplicacao.Recuperar(idContaOrgem);
var transacao = new Transacoes(conta, TipoTransacao.Saque, valor);
transacao.FazerSaque();
Salvar(transacao);
}
public void Limpar()
{
Transacoes.Limpar();
foreach (var nome in Repositorios.Keys)
{
(Repositorios[nome] as IRepositorioObject).Limpar();
}
}
public void Excluir(Transacoes entidade)
{
using (var uow = UoWFactory.Create())
{
transacoesRepositorio.Excluir(entidade);
uow.Commit();
}
}
public Transacoes ConsultarTransacao(int?transacaoId, string aporteId = "")
{
try
{
objCon.conn.Open();
StringBuilder query = new StringBuilder();
query.AppendLine("SELECT TransacaoId, ContaIdOrigem, ContaIdDestino, TipoTransacao, Valor, Data, AporteId")
.AppendLine("FROM tbTransacoes ");
if (transacaoId != null)
{
query.AppendLine("WHERE TransacaoId = @TransacaoId ");
}
else if (aporteId.Length > 0)
{
query.AppendLine("WHERE AporteId = @AporteId ");
}
Transacoes retorno = new Transacoes();
using (SQLiteCommand cmd = new SQLiteCommand(query.ToString(), objCon.conn))
{
if (transacaoId != null)
{
cmd.Parameters.AddWithValue("@TransacaoId", transacaoId);
}
else if (aporteId.Length > 0)
{
cmd.Parameters.AddWithValue("@AporteId", aporteId);
}
using (SQLiteDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
retorno.TransacaoId = Convert.ToInt32(dr["TransacaoId"]);
retorno.ContaIdOrigem = (dr["ContaIdOrigem"] != DBNull.Value ? Convert.ToInt32(dr["ContaIdOrigem"].ToString()) : default(int?));
retorno.ContaIdDestino = Convert.ToInt32(dr["ContaIdDestino"].ToString());
retorno.TipoTransacao = Convert.ToInt32(dr["TipoTransacao"]);
retorno.Valor = Convert.ToDecimal(dr["Valor"]);
retorno.Data = dr["Data"].ToString();
retorno.AporteId = dr["AporteId"].ToString();
}
}
}
return(retorno);
}
catch (Exception)
{
throw;
}
finally
{
objCon.conn.Close();
}
}
public Conta Depositar(Conta conta, Transacoes transacao)
{
conta.Depositar(transacao);
if (!conta.IsValid() || !transacao.IsValid())
{
return(conta);
}
return(!conta.ValidationResult.IsValid ? conta : _contaRepository.Atualizar(conta));
}
// Realiza a solicitação de um empréstimo
public void SolicitarEmprestimo(Emprestimo emprestimo)
{
// Adicionar na lista da conta contábil e de transacoes da conta
// Atualizar saldo
// Na tela de execução, instanciar o Emprestimo com valor, forma de pagamento lido das boxes, etc
emprestimo.Conta = this;
emprestimo.GerarParcelas();
Saldo += emprestimo.Valor;
Transacoes.Add(emprestimo);
BancoProp.ContaEmprestimo.Emprestimos.Add(emprestimo);
}
public void Transferencia(int idContaOrgem, int idContaDestino, decimal valor)
{
var origem = contaServicoAplicacao.Recuperar(idContaOrgem);
var destino = contaServicoAplicacao.Recuperar(idContaDestino);
var transacao = new Transacoes(origem, TipoTransacao.Saque, valor);
transacao.AdicionarContaDestino(destino);
transacao.FazerTransferencia();
Salvar(transacao);
}
public async Task <IActionResult> Create([Bind("ID,AdquirenteId,CodigoCliente,DataTransacao,HoraTransacao,NumeroCartao,CodigoAutorizacao,NSU,BandeiraId,ValorBruto,TaxaAdmin,ValorLiquido")] Transacoes transacoes)
{
if (ModelState.IsValid)
{
_context.Add(transacoes);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AdquirenteId"] = new SelectList(_context.Set <Adquirente>(), "Id", "Id", transacoes.AdquirenteId);
ViewData["BandeiraId"] = new SelectList(_context.Set <Bandeira>(), "Id", "Id", transacoes.BandeiraId);
return(View(transacoes));
}
public Conta Sacar(Conta conta, Transacoes transacao)
{
conta.Sacar(transacao);
if (!conta.IsValid() || !transacao.IsValid())
{
return(conta);
}
conta.ValidationResult = new SaqueEstaConsistenteValidation(_contaRepository, _transacoesRepository).Validate(transacao);
return(!conta.ValidationResult.IsValid ? conta : _contaRepository.Atualizar(conta));
}
// Depósito na conta
public void Depositar(double valor)
{
Deposito deposito = new Deposito()
{
Valor = valor,
Conta = this,
Data = DateTime.Now,
Tipo = "Depósito",
Descricao = "Depósito realizado"
};
Transacoes.Add(deposito);
// Guardar a transação para extrato
Saldo += valor;
}
public Transacoes concluirCompra(String tipo)
{
Transacoes ts = new Transacoes();
ts.transacao = Convert.ToInt32(lbTransacao.Text);
ts.id_Cliente = Convert.ToInt32(lblIdentificacaoCliente.Text);
ts.cliente = richTextCliente.Text;
ts.formaPagamento = tipo;
ts.totalCompra = richTextTotal.Text;
ts.operador = "teste"; //deve ser imprementado seguranca user
ts.dataInicio = dateTimePicker1.Text;
ts.dataFim = DateTime.Now.ToString("yyyy-MM-dd");
return(ts);
}
public void saveVendaDinheiroCartao(Transacoes t, DataTable compra, String tr)
{
MySqlCommand cmd = new MySqlCommand("BEGIN; insert into transacoes values (default," +
" @transacao, @id_Cliente, @cliente, @formaPagamento, @totalCompra, @operador, @dataInicio, @dataFim); " +
" COMMIT;");
cmd.Parameters.AddWithValue("@transacao", t.transacao);
cmd.Parameters.AddWithValue("@id_Cliente", t.id_Cliente);
cmd.Parameters.AddWithValue("@cliente", t.cliente);
cmd.Parameters.AddWithValue("@formaPagamento", t.formaPagamento);
cmd.Parameters.AddWithValue("@totalCompra", t.totalCompra);
cmd.Parameters.AddWithValue("@operador", t.operador);
cmd.Parameters.AddWithValue("@dataInicio", t.dataInicio);
cmd.Parameters.AddWithValue("@dataFim", t.dataFim);
ConexaoVendas c = new ConexaoVendas();
c.Abrir();
c.Executar(cmd);
c.Fechar();
for (int i = 0; i < compra.Rows.Count; i++)
{
c.Abrir();
MySqlCommand cmd1 = new MySqlCommand("begin; insert into produtosCompra values (default," +
" @transacao, @ean, @produto, @quantidade, @desconto, @acrescimo, @preco, @custo, (select id from transacoes where transacao = " + t.transacao + ")); commit;");
cmd1.Parameters.AddWithValue("@transacao", t.transacao);
cmd1.Parameters.AddWithValue("@ean", compra.Rows[i]["ID"].ToString());
cmd1.Parameters.AddWithValue("@produto", compra.Rows[i]["PRODUTO"].ToString());
cmd1.Parameters.AddWithValue("@quantidade", compra.Rows[i]["QTD"].ToString());
cmd1.Parameters.AddWithValue("@desconto", compra.Rows[i]["DESCONTO"].ToString());
cmd1.Parameters.AddWithValue("@acrescimo", compra.Rows[i]["ACRESCIMO"].ToString());
cmd1.Parameters.AddWithValue("@preco", compra.Rows[i]["PRECO UN"].ToString());
cmd1.Parameters.AddWithValue("@custo", buscaCusto(Convert.ToInt32(compra.Rows[i]["ID"])));
c.Executar(cmd1);
c.Fechar();
}
if (t.formaPagamento == "Carteira")
{
saveCarteira(t, compra, tr);
}
MessageBox.Show("Operação concluida com ÊXITO!");
}
public void QuandoSacarUmValorDe(int p0)
{
var repoConta = new Mock <IContaRepository>();
var repoTransacao = new Mock <ITransacoesRepository>();
transacao = new Transacoes(p0, Enuns.TipoTransacao.Saque, conta.Id);
transacao.Conta = conta;
repoTransacao.Setup(r => r.Buscar(It.IsAny <Expression <Func <Transacoes, bool> > >()))
.Returns <Expression <Func <Transacoes, bool> > >(pred => transacoes.Where(pred.Compile()));
var contaService = new ContaService(repoConta.Object, repoTransacao.Object);
contaService.Sacar(conta, transacao);
transacao.Valor = transacao.Valor * -1;
transacoes.Add(transacao);
}
} // Banco para vincular as contas contábeis nas aplicações, resgates, solicitações de empréstimo e etc
// Saque de valor se houver saldo suficiente
public void Sacar(double valor)
{
if (SaldoSuficiente(valor))
{
Saque saque = new Saque()
{
Valor = -valor,
Conta = this,
Data = DateTime.Now,
Tipo = "Saque",
Descricao = "Saque realizado"
};
Transacoes.Add(saque);
// Guardar o saque na tabela de transacoes/saques no banco
Saldo -= valor;
}
}
public Transacoes Adicionar(Transacoes transacoes)
{
if (!transacoes.IsValid())
{
return(transacoes);
}
if (transacoes.ValidationResult.IsValid)
{
if (transacoes.TipoTransacao == Enuns.TipoTransacao.Saque)
{
transacoes.Valor = transacoes.Valor * -1;
}
return(_transacoesRepository.Adicionar(transacoes));
}
return(transacoes);
}
public async Task AddTransacoes(Transacoes transacao)
{
using (IDbConnection conn = Connection)
{
try
{
conn.Execute(@"insert Transacoes (Descricao)
values (@Descricao)", transacao);
}
catch (Exception ex)
{
throw ex;
}
finally
{
//con.Close();
}
}
}
public async Task <ActionResult <Transacoes> > Post([FromBody] string value)
{
try
{
var transacao = new Transacoes()
{
Descricao = value
};
await _transacoesRepository.AddTransacoes(transacao);
return(Ok());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(BadRequest(ex.Message));
}
}
// Resgata o valor integral do investimento
public void ResgatarInvestimento(Investimento investimento)
{
// Não precisa remover da lista da ContaContabil, status resgatado na lista Transacoes
// Ações de rendimento ficam na classe de Investimento em si
if (investimento.Status.Equals("Aplicado"))
{
investimento.Status = "Resgatado";
investimento.Valor = Math.Round(investimento.ValorInicial + investimento.CalcularRendimentoFinal(), 2);
Transacao t = new Transacao()
{
Tipo = "Resgate",
Conta = this,
Valor = investimento.Valor,
Data = DateTime.Today,
Descricao = "Resgate do investimento '" + investimento.Descricao + "'"
};
Transacoes.Add(t);
Saldo += investimento.Valor;
}
}
public string Estorno(int?transacaoId, string aporteId)
{
try
{
Transacoes t = new Transacoes();
if (aporteId.Length > 0)
{
t = tData.ConsultarTransacao(null, aporteId);
}
else if (transacaoId != null)
{
t = tData.ConsultarTransacao(transacaoId, "");
}
if (t.TransacaoId <= 0)
{
return("Transação não localizada;");
}
t.TipoTransacao = (int)Transacoes.enuTipoTransacao.Estorno;
if (aporteId.Length > 0)
{
t.Valor = (t.Valor * -1);
}
else if (transacaoId != null)
{
int contaIdDestino = t.ContaIdOrigem.Value;
t.ContaIdOrigem = t.ContaIdDestino;
t.ContaIdDestino = contaIdDestino;
}
tData.Incluir(t);
return("Estorno realizado com sucesso!");
}
catch (Exception)
{
throw;
}
}
