public void Excluir(int Id)
{
Despesa despesa = ObterDespesa(Id);
_banco.Remove(despesa);
_banco.SaveChanges();
}
public static void deleteDespesa(int id)
{
Despesa d = getDespesa(id);
ctx.despesas.Remove(d);
ctx.SaveChanges();
}
public Despesa New(Despesa despesa)
{
context.Add(despesa);
context.SaveChanges();
return(despesa);
}
public Despesa Update(Despesa despesa)
{
context.Update(despesa);
context.SaveChanges();
return(despesa);
}
public void Popular()
{
if (_context.Conta.Any() ||
_context.Despesa.Any() ||
_context.Fundo.Any() ||
_context.Pessoa.Any() ||
_context.Transacao.Any())
{
return; //Banco de dados já populado
}
Conta c1 = new Conta(1, "CC BP", "Banpará", "21", "22926", TipoConta.Corrente);
Conta c2 = new Conta(2, "CC BB", "Banco do Brasil", "3074-0", "49850-5", TipoConta.Corrente);
Conta c3 = new Conta(3, "PP BB", "Banco do Brasil", "3074-0", "49850-5", TipoConta.Poupanca);
Conta c4 = new Conta(4, "PP BP", "Banpará", "21", "6071996", TipoConta.Poupanca);
Despesa d1 = new Despesa(1, "Energia", 255.63, DateTime.Now, null);
Despesa d2 = new Despesa(2, "Condomínio", 290.0, DateTime.Now, null);
Despesa d3 = new Despesa(3, "Internet", 133.35, DateTime.Now, null);
Pessoa p1 = new Pessoa(1, "Arianne Machado");
Pessoa p2 = new Pessoa(2, "Carlos Hugo Lopes");
Fundo f1 = new Fundo(1, "Lazer", 10.0, p1, c1);
Fundo f2 = new Fundo(2, "Lazer", 10.0, p2, c2);
_context.Conta.AddRange(c1, c2, c3, c4);
_context.Despesa.AddRange(d1, d2, d3);
_context.Pessoa.AddRange(p1, p2);
_context.Fundo.AddRange(f1, f2);
_context.SaveChanges();
}
public async Task Excluir(int Id)
{
Despesa despesa = ObterDespesa(Id);
_banco.Remove(despesa);
await _banco.SaveChangesAsync();
}
public IActionResult Despesa(double valor, int idSelecionado, DateTime data, string descricao, string saveBtn, string saveBtn2)
{
DespesaBLL bll = new DespesaBLL();
Despesa despesa = new Despesa();
if (saveBtn2 == "Deletar")
{
despesa.idDespesa = idSelecionado;
ViewData["result"] = bll.Delete(despesa);
return(View());
}
if (idSelecionado != 0)
{
despesa.idDespesa = idSelecionado;
despesa.Data = data;
despesa.Valor = valor;
despesa.Descricao = descricao;
ViewData["result"] = bll.Update(despesa);
return(View());
}
if (saveBtn == "Salvar")
{
despesa.Data = data;
despesa.Valor = valor;
despesa.Descricao = descricao;
ViewData["result"] = bll.Insert(despesa);
return(View());
}
return(View());
}
public async void Inserir(Despesa despesa)
{
await _connection.InsertAsync(despesa);
// _connection.Table<Despesa>()
var dinheiro = Mvx.GetSingleton<Dinheiro>();
dinheiro.Atualizar();
}
public async Task <IActionResult> Edit(Guid id, [Bind("DespesaId,MesId,TipoDespesaId,Valor")] Despesa despesa)
{
if (id != despesa.DespesaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(despesa);
await _context.SaveChangesAsync();
TempData["Confirmacao"] = "Despesa atualizada com sucesso!";
}
catch (DbUpdateConcurrencyException)
{
if (!DespesaExists(despesa.DespesaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MesId"] = new SelectList(_context.TMes, "MesId", "Nome", despesa.MesId);
ViewData["TipoDespesaId"] = new SelectList(_context.TTipoDespesa, "TipoDespesaId", "Nome", despesa.TipoDespesaId);
return(View(despesa));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,TipoCustoID,Valor,Data,Observacao")] Despesa despesa)
{
if (id != despesa.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(despesa);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DespesaExists(despesa.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TipoCustoID"] = new SelectList(_context.Set <TipoCusto>(), "ID", "ID", despesa.TipoCustoID);
return(View(despesa));
}
public bool ValidarDespesa(Despesa despesa)
{
if (despesa.Id == null)
{
return(false);
}
if (despesa.Descricao == null)
{
return(false);
}
if (despesa.Categoria == null)
{
return(false);
}
if (despesa.MesReferencia == null)
{
return(false);
}
if (despesa.TipoPagamento == null)
{
return(false);
}
return(true);
}
private Despesa GerarDespesasParceladas(Despesa despesa, int parcela)
{
var dataMesReferencia = DateTime.Parse(despesa.MesReferencia.ToString(), new CultureInfo("pt-BR"));
var dataMesSeguinte = dataMesReferencia.AddMonths(parcela);
var dataReferencia = dataMesSeguinte.Month.ToString() + "/" + dataMesSeguinte.Year.ToString();
var despesaGerada = new Despesa()
{
Id = Guid.NewGuid(),
Descricao = despesa.Descricao,
MesReferencia = dataReferencia,
Valor = despesa.Valor,
DataCompra = despesa.DataCompra,
Parcelas = despesa.Parcelas - parcela,
TipoPagamento = despesa.TipoPagamento,
Casal = despesa.Casal,
ResponsavelPagador = despesa.ResponsavelPagador,
ResponsavelPagadorId = despesa.ResponsavelPagadorId,
Categoria = despesa.Categoria,
CategoriaId = despesa.CategoriaId,
DividirDespesa = despesa.DividirDespesa,
Ids = despesa.Ids
};
return(despesaGerada);
}
public void Nao_pode_criar_despesa_com_categoria_invalida(int categoriaId)
{
Action act = () => Despesa.Create(_id, categoriaId, _data, _descricao, _isLancamentoPago, _valor,
_formaDePagto, _anotacao);
Assert.Throws <ArgumentOutOfRangeException>(act).ParamName.Should().Be("categoriaId");;
}
//select
public Despesa Select(int id)
{
Despesa obj = null;
System.Data.IDbConnection objConexao;
System.Data.IDbCommand objCommand;
System.Data.IDataReader objDataReader;
objConexao = Mapped.Connection();
objCommand = Mapped.Command("SELECT * FROM tbl_despesa WHERE des_codigo = ?codigo", objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?codigo", id));
objDataReader = objCommand.ExecuteReader();
while (objDataReader.Read())
{
obj = new Despesa();
obj.Codigo = Convert.ToInt32(objDataReader["des_codigo"]);
obj.Descricao = Convert.ToString(objDataReader["des_descricao"]);
obj.Valor = Convert.ToString(objDataReader["des_valor"]);
obj.DataVencimento = Convert.ToDateTime(objDataReader["des_datavencimento"]);
obj.Status = Convert.ToString(objDataReader["des_status"]);
}
objDataReader.Close();
objConexao.Close();
objCommand.Dispose();
objConexao.Dispose();
objDataReader.Dispose();
return(obj);
}
public void Nao_pode_criar_despesa_com_anotacao_invalida(string anotacao)
{
Action act = () => Despesa.Create(_id, _categoriaId, _data, _descricao, _isLancamentoPago, _valor,
_formaDePagto, anotacao);
Assert.Throws <ArgumentNullException>(act).ParamName.Should().Be("anotacao");;
}
public void Nao_pode_criar_despesa_com_valor_negativo(decimal valor)
{
Action act = () => Despesa.Create(_id, _categoriaId, _data, _descricao, _isLancamentoPago, valor,
_formaDePagto, _anotacao);
Assert.Throws <ArgumentOutOfRangeException>(act).ParamName.Should().Be("valor");;
}
public void Nao_pode_criar_despesa_com_data_invalida(int ano, int mes, int dia)
{
Action act = () => Despesa.Create(_id, _categoriaId, new DateTime(ano, mes, dia), _descricao, _isLancamentoPago, _valor,
_formaDePagto, _anotacao);
Assert.Throws <ArgumentOutOfRangeException>(act).ParamName.Should().Be("data");;
}
public void Alterar(Despesa despesa)
{
try
{
Despesa despesaAux = new Despesa();
despesaAux.ID = despesa.ID;
List <Despesa> resultado = this.Consultar(despesaAux, TipoPesquisa.E);
if (resultado == null || resultado.Count == 0)
{
throw new DespesaNaoAlteradaExcecao();
}
despesaAux = resultado[0];
despesaAux.data = despesa.data;
despesaAux.despesatipo_id = despesa.despesatipo_id;
despesaAux.ID = despesa.ID;
despesaAux.justificativa = despesa.justificativa;
despesaAux.timeCreated = despesa.timeCreated;
despesaAux.timeUpdated = despesa.timeUpdated;
Confirmar();
}
catch (Exception)
{
throw new DespesaNaoAlteradaExcecao();
}
}
public Despesa Adicionar(Despesa despesa)
{
despesa.Validar();
despesa = _contexto.Despesas.Add(despesa);
ConfirmarAlteracoes();
return(despesa);
}
public void iniciar_construtor_com_sucesso()
{
var despesa = new Despesa(MesEnum.Abril, new Conta("nome", new TipoConta { Id = (int)TipoContaEnum.Outros }));
// Assert.Greater((int) despesa.Mes, 0, "mes não informado.");
Assert.IsNotNull(despesa.Conta,"Conta não informada.");
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Descricao,Valor,Data,Custo")] Despesa despesa)
{
if (id != despesa.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(despesa);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DespesaExists(despesa.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(despesa));
}
public async Task <IActionResult> Atualizar([FromBody] Despesa despesa)
{
var usuarioEncontrado = await _usuarioService.GetUsuarioFromJwtAsync(User);
var despesaEncontrada = await _context.Despesas.FirstOrDefaultAsync(e => e.Id == despesa.Id && e.Conta.Usuario == usuarioEncontrado);
if (despesaEncontrada == null)
{
return(NotFound());
}
despesaEncontrada.DataDespesa = despesa.DataDespesa;
despesaEncontrada.Descricao = despesa.Descricao;
despesaEncontrada.Valor = despesa.Valor;
var contaEncontrado = await _context.Contas.FirstOrDefaultAsync(e => e.Id == despesa.Conta.Id && e.Usuario == usuarioEncontrado);
if (contaEncontrado == null)
{
return(NotFound());
}
despesaEncontrada.Conta = contaEncontrado;
_context.Despesas.Update(despesaEncontrada);
await _context.SaveChangesAsync();
return(Ok(despesaEncontrada));
}
public IActionResult Atualizar([FromBody] Despesa despesa, [FromServices] DespesaNegocio negocio)
{
try
{
var despesaDb = negocio.ObterPorId(despesa.Id);
if (despesaDb == null)
{
return(NotFound(new RetornoApi {
MensagemRetorno = "Receita não encontrada."
}));
}
negocio.Salvar(despesa);
return(Ok(new RetornoApi {
MensagemRetorno = "Despesa atualizada com sucesso."
}));
}
catch (Exception ex)
{
return(BadRequest(new RetornoApi {
MensagemRetorno = ex.Message
}));
}
}
public ActionResult AddDependent(Dependente dependente)
{
if (Sessao.isLogged())
{
Despesa d = desp;
Cliente c = ClienteDAO.getCliente(dependente.idDependente);
dependente.dependente = c;
double valorTotal = 0;
double valorDependentes = 0;
valorTotal = d.valor;
foreach (Dependente dep in d.dependentes)
{
valorDependentes += dep.valor;
}
double valorRestante = valorTotal - valorDependentes;
ViewBag.ValorRestante = valorRestante;
if (d.dependentes != null)
{
d.dependentes.Add(dependente);
}
else
{
List <Dependente> dependentes = new List <Dependente>();
dependentes.Add(dependente);
d.dependentes = dependentes;
}
DespesaDAO.updateDespesa(d);
return(Redirect(Url.Action("Edit", "Despesa") + "/" + d.id));
}
else
{
return(RedirectToAction("Login", "Usuario"));
}
}
public void PreAdicionar(Despesa despesa)
{
if (!ExecutarValidacao(new DespesaValidation(), despesa))
{
return;
}
}
public IActionResult Insert([FromBody] Despesa despesa, [FromServices] DespesaNegocio negocio, [FromServices] ContaNegocio contaNegocio)
{
try
{
var contaDb = contaNegocio.ObterPorId(despesa.Id_Conta);
if (contaDb == null)
{
return(NotFound(new RetornoApi {
MensagemRetorno = "Conta não encontrada."
}));
}
negocio.Salvar(despesa);
return(Ok(new RetornoApi {
MensagemRetorno = "Despesa criada com sucesso."
}));
}
catch (Exception ex)
{
return(BadRequest(new RetornoApi {
MensagemRetorno = ex.Message
}));
}
}
//create table menu programmerly and dynamically
private void TablesMenuGenerator(List <String> dataStrings)
{
foreach (var element in dataStrings)
{
MenuItem menuItem = new MenuItem
{
Header = element
};
menuItem.Click += (sender, e) =>
{
DataGrid dataGrid = new DataGrid();
if (element == PRODUTOS)
{
dataGrid = Produto.GetDataGrid();
}
if (element == DESPESAS)
{
dataGrid = Despesa.GetDataGrid();
}
if (element == IVA)
{
dataGrid = Iva.GetDataGrid();
}
if (element == RECEITAS)
{
dataGrid = Receita.GetDataGrid();
}
Grid.SetRow(dataGrid, 1);
CleanDataGrid();
mainGrid.Children.Add(dataGrid);
};
tablesMenu.Items.Add(menuItem);
}
}
public void ValidarDespesaParaSalvar()
{
//arrange
var despesa = new Despesa
{
Id = Guid.NewGuid(),
Descricao = "Roupa",
Categoria = null,
Casal = false,
MesReferencia = "09/10",
};
var despesaCerta = new Despesa
{
Id = Guid.NewGuid(),
Descricao = "Roupa",
Categoria = new Categoria(),
Casal = false,
MesReferencia = "09/10",
TipoPagamento = "ok"
};
var mock = new Mock <IDespesaService>();
mock.Setup(d => d.ValidarDespesa(despesa)).Returns(false);
var verify = new DespesaService();
//act
var resultadoEsperado = mock.Object.ValidarDespesa(despesa);
var resultado = verify.ValidarDespesa(despesa);
//assert
Assert.AreEqual(resultado, resultadoEsperado);
}
public void Editar()
{
if (_controleDespesa.ObterDespesaSelecionada() == null)
{
MessageBox.Show("Precisa selecionar um despesa.");
}
else
{
try
{
_dialogo.novaDespesa = _controleDespesa.ObterDespesaSelecionada();
DialogResult resultado = _dialogo.ShowDialog();
if (resultado == DialogResult.OK)
{
_despesa = _dialogo.novaDespesa;
_despesaServico.Atualizar(_despesa);
MessageBox.Show("Despesa atualizada com sucesso!");
}
_dialogo.LimparCampos();
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Erro");
Editar();
}
}
}
public ActionResult Alterar(int id, Despesa despesa)
{
try
{
if (ModelState.IsValid)
{
despesa.ID = id;
IDespesaProcesso processo = DespesaProcesso.Instance;
despesa.timeUpdated = DateTime.Now;
processo.Alterar(despesa);
processo.Confirmar();
// TODO: Add update logic here
return(RedirectToAction("Index"));
}
else
{
return(View(despesa));
}
}
catch
{
return(View());
}
}
public async Task <IHttpActionResult> PutDespesa(int id, Despesa despesa)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != despesa.DespesaId)
{
return(BadRequest());
}
db.Entry(despesa).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DespesaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void ApagarConfirmar(int id)
{
Despesa despesa = db.Despesa.Find(id);
db.Despesa.Remove(despesa);
db.SaveChanges();
}
public void IncluirDespesa(Despesa despesa)
{
if (despesa.DespesaId == 0)
{
despesa = context.Despesas.Add(despesa);
}
else
{
Despesa dbDespesa = context.Despesas.Find(despesa.DespesaId);
if (dbDespesa != null)
{
dbDespesa.Data = despesa.Data;
dbDespesa.Observacao = despesa.Observacao;
dbDespesa.Valor = despesa.Valor;
dbDespesa.CategoriaId = despesa.CategoriaId;
}
}
context.SaveChanges();
}
public void AtribuirVersaoFinalComSucesso()
{
ServicoOrcamentoOperacionalVersao servico = new ServicoOrcamentoOperacionalVersao();
IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
orcamentos.Expect(o => o.ObterOrcamentoFinalOrcamentoOperacional(null,null)).IgnoreArguments().Return(null);
servico.Orcamentos = orcamentos;
Departamento departamento = new Hospital("Barra dor");
var orcamento = new OrcamentoOperacionalVersao(departamento, new CentroDeCusto("centroDeCusto"), 2014);
Despesa despesa = new Despesa(MesEnum.Janeiro, null);
despesa.Valor = 10;
orcamento.DespesasOperacionais.Add(despesa);
servico.AtribuirVersaoFinal(orcamento);
Assert.IsTrue(orcamento.VersaoFinal);
}
public void ExcluirDespesa(Despesa despesa)
{
context.Despesas.Remove(despesa);
context.SaveChanges();
}
public void Salvar(Despesa despesa)
{
base.Salvar(despesa);
}
public async void Excluir(Despesa despesa)
{
await _connection.DeleteAsync(despesa);
var dinheiro = Mvx.GetSingleton<Dinheiro>();
dinheiro.Atualizar();
}
public AdicionarDespesaViewModel()
{
Despesa = new Despesa();
}
