public Divida getDivida(int iddevedor)
{
SqlCommand cmd = new SqlCommand();
Conexao conexao = new Conexao();
SqlDataReader dr;
cmd.CommandText = "SELECT * FROM DIVIDA WHERE DIVIDA.IDDEVEDOR = @ID";
cmd.Parameters.AddWithValue("@ID", iddevedor);
Divida retorno = new Divida();
try
{
cmd.Connection = conexao.conectar();
dr = cmd.ExecuteReader();
if (dr.HasRows)
{
while (dr.Read())
{
retorno.idDivida = Convert.ToInt32(dr["IDDIVIDA"]);
retorno.valor = Convert.ToDouble(dr["VALOR"]);
retorno.dataVencimento = Convert.ToDateTime(dr["DATAVENCIMENTO"]);
retorno.idEmpresa = Convert.ToInt32(dr["IDEMPRESA"]);
retorno.idDevedor = Convert.ToInt32(dr["IDDEVEDOR"]);
retorno.status = Convert.ToString(dr["STATUS"]);
}
}
}
catch (SqlException ex)
{
MessageBox.Show(ex.Message);
}
return(retorno);
}
public void enviarEmail(string para, Divida divida)
{
this.client = new SmtpClient();
this.client.Host = "smtp.gmail.com";
this.client.Port = PORTA;
this.client.EnableSsl = true;
this.client.UseDefaultCredentials = false;
this.client.Credentials = new NetworkCredential("*****@*****.**", "Toledo123");
string anexo = verificaArquivo(divida);
MailMessage mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**");
mail.To.Add(new MailAddress(para));
mail.Body = "Mensagem automatica, não é necessario responder. Segue em anexo seu(s) boleto(s).";
mail.Subject = "Negociacao de credito - EasyCall";
mail.Attachments.Add(new Attachment(anexo));
try
{
client.Send(mail);
client.SendCompleted += new SendCompletedEventHandler(SendCompletedCallback);
//MessageBox.Show("email enviado com sucesso!");
mail.Dispose();
client.Dispose();
}
catch (Exception ex)
{
MessageBox.Show("erro: " + ex.Message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
// GET: api/Divida/5
public Divida Get(int id)
{
Divida divida = new Divida();
var connection = DBConnection.Instance();
try
{
if (connection.IsConnect())
{
var command = new MySqlCommand("SELECT ID, CLIENTE_ID, MOTIVO, VALOR, DATA_DIVIDA FROM DIVIDAS WHERE EXCLUIDO_EM IS NULL AND ID = @val1", connection.Connection);
command.Parameters.AddWithValue("@val1", id);
var reader = command.ExecuteReader();
while (reader.Read())
{
divida = new Divida
{
Id = int.Parse(reader.GetString(0)),
ClienteId = int.Parse(reader.GetString(1)),
Motivo = reader.GetString(2),
Valor = decimal.Parse(reader.GetString(3)),
DataDivida = DateTime.Parse(reader.GetString(4))
};
break;
}
}
}
finally
{
connection.Close();
}
return(divida);
}
// GET: api/Divida
public List <Divida> Get()
{
List <Divida> dividas = new List <Divida>();
Divida divida;
var connection = DBConnection.Instance();
try
{
if (connection.IsConnect())
{
var command = new MySqlCommand("SELECT ID, CLIENTE_ID, MOTIVO, VALOR, DATA_DIVIDA FROM DIVIDAS WHERE EXCLUIDO_EM IS NULL", connection.Connection);
var reader = command.ExecuteReader();
while (reader.Read())
{
divida = new Divida
{
Id = int.Parse(reader.GetString(0)),
ClienteId = int.Parse(reader.GetString(1)),
Motivo = reader.GetString(2),
Valor = decimal.Parse(reader.GetString(3)),
DataDivida = DateTime.Parse(reader.GetString(4))
};
dividas.Add(divida);
}
}
}
finally
{
connection.Close();
}
return(dividas);
}
public List <Divida> listDivida()
{
SqlCommand cmd = new SqlCommand();
Conexao conexao = new Conexao();
SqlDataReader dr;
cmd.CommandText = "SELECT * FROM DIVIDA";
var retorno = new List <Divida>();
try
{
cmd.Connection = conexao.conectar();
dr = cmd.ExecuteReader();
if (dr.HasRows)
{
while (dr.Read())
{
var item = new Divida();
item.idDivida = Convert.ToInt32(dr["IDDIVIDA"]);
item.valor = Convert.ToDouble(dr["VALOR"]);
item.dataVencimento = Convert.ToDateTime(dr["DATAVENCIMENTO"]);
item.idEmpresa = Convert.ToInt32(dr["IDEMPRESA"]);
item.idDevedor = Convert.ToInt32(dr["IDDEVEDOR"]);
item.status = Convert.ToString(dr["STATUS"]);
//item.ul = Convert.ToDateTime(dr["UL"]);
retorno.Add(item);
}
}
}
catch (SqlException ex)
{
MessageBox.Show(ex.Message);
}
return(retorno);
}
public Divida Calcular(Divida d)
{
double amortizacaoConstante = d.Montante / (d.Parcelas.Count - 1);
double saldoDevedor = d.Montante;
d.TotalAmortizacao = 0;
d.TotalJuros = 0;
d.TotalPrestacao = 0;
foreach (Parcela p in d.Parcelas)
{
p.SaldoDevedor = saldoDevedor;
saldoDevedor -= amortizacaoConstante;
if (p.Periodo == 0)
{
continue;
}
p.Amortizacao = amortizacaoConstante;
p.Juros = Math.Round((((d.Parcelas.Count - 1) - p.Periodo + 1) * d.TaxaDeJuros * amortizacaoConstante), 2);
p.Prestacao = amortizacaoConstante + p.Juros;
d.TotalAmortizacao += p.Amortizacao;
d.TotalJuros += p.Juros;
d.TotalPrestacao += p.Prestacao;
}
return(d);
}
public async Task <IRetorno> IncluirDivida(DividaDTO dto)
{
try
{
dto.Validate();
if (dto.Invalid)
{
return(new RetornoDTO(false, "Erro na requisição, verificar parametros de entrar", dto.Notifications));
}
var divida = new Divida(dto.ValorOriginal, dto.DataVencimento, dto.DocumentoDevedor, dto.UsuarioId);
var dividaCriada = await _repository.CriarAsync(divida);
if (dividaCriada)
{
return(new RetornoDTO(true, "Divida incluida com sucesso", divida));
}
return(new RetornoDTO(false, "Erro ao tentar salvar os dados na base", null));
}catch (Exception ex)
{
throw ex;
}
}
public Divida BuscarDivida(int Cod_divida)
{
try
{
AbrirConexao();
cmd = new SqlCommand("Select * from Divida where Cod_divida = @v1", con);
cmd.Parameters.AddWithValue("@v1", Cod_divida);
Dr = cmd.ExecuteReader();
Divida d = new Divida();
if (Dr.Read())
{
d.Quantidade = Convert.ToInt32(Dr["quantidade"]);
d.Produto = Convert.ToString(Dr["Produto"]);
d.Data = Convert.ToString(Dr["Data"]);
d.Comprador = Convert.ToString(Dr["Comprador"]);
d.preco = Convert.ToDecimal(Dr["Preco"]);
}
return(d);
}
catch (Exception ex)
{
throw new Exception("erro ao pesquisar" + ex.Message);
}
finally
{
FecharConexao();
}
}
public List <Divida> ListarTodasDividas()
{
try
{
AbrirConexao();
List <Divida> lista = new List <Divida>();
cmd = new SqlCommand("select * from Divida ", con);
Dr = cmd.ExecuteReader();
while (Dr.Read())
{
Divida d = new Divida();
d.Cod_divida = Convert.ToInt32(Dr["Cod_divida"]);
d.Quantidade = Convert.ToInt32(Dr["Quantidade"]);
d.Produto = Convert.ToString(Dr["Produto"]);
d.Data = Convert.ToString(Dr["Data"]);
d.Comprador = Convert.ToString(Dr["Comprador"]);
d.preco = Convert.ToDecimal(Dr["Preco"]);
d.Cod_deleta = Convert.ToInt32(Dr["Cod_deleta"]);
lista.Add(d);
}
return(lista);
}
catch (Exception ex)
{
throw new Exception("Erro ao gravar cliente: " + ex.Message);
}
finally
{
FecharConexao();
}
}
public async Task <bool> ExcluirAsync(Divida entity)
{
var count = listaDividas.Count;
listaDividas.Remove(entity);
return(await Task.FromResult(listaDividas.Count < count));
}
public int Insert(Divida divida)
{
var connectionString = this.GetConnectionString();
int id = 0;
using (var db = new MySqlConnection(connectionString))
{
try
{
db.Open();
var trans = db.BeginTransaction();
var query = @"INSERT INTO Divida(NumeroTitulo, NomeDevedor, CPFDevedor, PorcentagemMulta, PorcentagemJuros)
VALUES(@NumeroTitulo, @NomeDevedor, @CPFDevedor, @PorcentagemMulta, @PorcentagemJuros);
SELECT LAST_INSERT_ID()";
id = db.QuerySingle <int>(query, divida, transaction: trans);
divida.Parcelas.ForEach(x => x.DividaId = id);
query = "INSERT INTO Parcela(Numero, DataVencimento, Valor, DividaId) VALUES (@Numero, @DataVencimento, @Valor, @DividaId)";
db.Execute(query, divida.Parcelas, transaction: trans);
trans.Commit();
}
catch (Exception ex)
{
ExceptionDispatchInfo.Capture(ex).Throw();
}
finally
{
db.Close();
}
return(id);
}
}
public Divida Calcular(Divida d)
{
double saldoDevedor = d.Montante;
foreach (Parcela p in d.Parcelas)
{
if (p.Periodo != (d.Parcelas.Count - 1))
{
p.SaldoDevedor = saldoDevedor;
}
if (p.Periodo == 0)
{
continue;
}
p.Juros = Math.Round((saldoDevedor * d.TaxaDeJuros), 2);
if (p.Periodo == d.Parcelas.Count - 1)
{
p.Amortizacao = saldoDevedor;
p.Prestacao = p.Amortizacao + p.Juros;
}
else
{
p.Prestacao = p.Juros;
}
d.TotalAmortizacao += p.Amortizacao;
d.TotalJuros += p.Juros;
d.TotalPrestacao += p.Prestacao;
}
return(d);
}
public async Task <bool> AlterarAsync(Divida entity)
{
var index = listaDividas.FindIndex(x => x.Id == entity.Id);
listaDividas[index] = entity;
return(true);
}
private List <Parcela> CalcularParcelas(Parametrizacao parametrizacao, Divida divida)
{
try
{
var listaParcela = new List <Parcela>();
var totalAPagar = CalCularValorTotalAPagar(divida, parametrizacao);
var valorParcela = totalAPagar / parametrizacao.MaximoParcelas;
var diaVencimento = DateTime.Now.AddDays(1).Day;
var anoVencimento = DateTime.Now.Year;
var mesVencimeto = DateTime.Now.Month;
for (int i = 0; i < parametrizacao.MaximoParcelas; i++)
{
var numeroParcela = i + 1;
var parcela = new Parcela(numeroParcela, valorParcela, new DateTime(anoVencimento, mesVencimeto + (i + 1), diaVencimento));
listaParcela.Add(parcela);
}
return(listaParcela);
} catch (Exception ex)
{
throw ex;
}
}
public async Task <IHttpActionResult> PutDivida(int id, Divida Divida)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != Divida.Id)
{
return(BadRequest());
}
db.Entry(Divida).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DividaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public FormCadastroDeDivida(Divida divida)
{
InitializeComponent();
Codigo = divida.Codigo;
txtNome.Text = divida.Nome;
txtValor.Text = divida.ValorDaDivida.ToString();
txtData.SelectedDate = divida.DataDeVencimento;
}
public async Task <bool> CriarAsync(Divida entity)
{
var count = listaDividas.Count;
entity.Usuario = _usuario;
listaDividas.Add(entity);
return(await Task.FromResult(listaDividas.Count > count));
}
public ActionResult DeleteConfirmedDivida(int id)
{
Divida divida = db.Dividas.Find(id);
db.Dividas.Remove(divida);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void AmortizacaoDeveSerSubtracaoPrestacaoPeloJuros()
{
Divida resultado = amortizacao.Calcular(d);
foreach (Parcela p in resultado.Parcelas)
{
Assert.AreEqual(p.Amortizacao, Math.Round(p.Prestacao - p.Juros), 2);
}
}
public void DeveAtribuirNumeroCorretoDeParcelas()
{
Divida d = new Divida(0, 0, 10);
for (int i = 0; i < d.Parcelas.Count; i++)
{
Assert.AreEqual(d.Parcelas[i].Periodo, i);
}
Assert.AreEqual(d.Parcelas.Count, 11);
}
public void JurosDeveSerSaldoDevedorDoMesAnteriorMultiplicadoPelaTaxaDeJuros()
{
Divida resultado = amortizacao.Calcular(d);
double esperado;
for (int i = 1; i < resultado.Parcelas.Count; i++)
{
esperado = Math.Round((resultado.Parcelas[i - 1].SaldoDevedor * d.TaxaDeJuros), 2);
Assert.AreEqual(resultado.Parcelas[i].Juros, esperado);
}
}
public void SaldoDevedorDeveSerIgualMesAnteriorMenosAmortizacaoAtual()
{
Divida resultado = amortizacao.Calcular(d);
double esperado;
for (int i = 1; i < resultado.Parcelas.Count; i++)
{
esperado = Math.Round((resultado.Parcelas[i - 1].SaldoDevedor - resultado.Parcelas[i].Amortizacao), 2);
Assert.AreEqual(resultado.Parcelas[i].SaldoDevedor, esperado);
}
}
public async Task <Divida> Put([FromBody] Divida divida)
{
try
{
return(await _repositorioFinanceiro.AtualizarDivida(divida));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult Edit([Bind(Include = "DividaId,ClienteId,ValorDaDivida")] Divida divida)
{
if (ModelState.IsValid)
{
db.Entry(divida).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClienteId = new SelectList(db.Clientes, "ClienteId", "Nome", divida.ClienteId);
return(View(divida));
}
public void PrestacaoDeveSerASomaDaAmortizacaoComJuros()
{
Divida resultado = amortizacao.Calcular(d);
foreach (Parcela p in resultado.Parcelas)
{
if (p.Periodo != 0)
{
Assert.AreEqual(p.Prestacao, p.Amortizacao + p.Juros);
}
}
}
public void AmortizacaoDeveSerConstante()
{
Divida resultado = amortizacao.Calcular(d);
foreach (Parcela p in resultado.Parcelas)
{
if (p.Periodo != 0)
{
Assert.AreEqual(p.Amortizacao, 10000);
}
}
}
public void JurosDevemSerConstantes()
{
Divida resultado = amortizacao.Calcular(d);
foreach (Parcela p in resultado.Parcelas)
{
if (p.Periodo != 0)
{
Assert.AreEqual(p.Juros, 1500);
}
}
}
public ActionResult CreateDivida([Bind(Include = "DividaId,ClienteId,ValorDaDivida")] Divida divida)
{
if (ModelState.IsValid)
{
db.Dividas.Add(divida);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClienteId = new SelectList(db.Clientes, "ClienteId", "Nome", divida.ClienteId);
return(View(divida));
}
public async Task <bool> DeletarDivida(int idDivida)
{
try
{
Divida divida = _context.Dividas.Find(idDivida);
_context.Dividas.Remove(divida);
await _context.SaveChangesAsync();
}
catch
{
return(false);
}
return(true);
}
// GET: Administrador/Divida/DeleteDivida/5
public ActionResult DeleteDivida(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Divida divida = db.Dividas.Find(id);
if (divida == null)
{
return(HttpNotFound());
}
return(View(divida));
}
