public ActionResult Atualizar(int id, [FromBody] TipoDespesa tipodespesa)
{
if (tipodespesa == null)
{
return(BadRequest());
}
//Validando dados
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var obj = _tipoDespesaRepository.Find(id);
if (obj == null)
{
return(NotFound());
}
_tipoDespesaRepository.Update(tipodespesa);
return(Ok());
}
private void GravarDespesa()
{
if (!string.IsNullOrEmpty(txtTipoDespesa.Text))
{
TipoDespesa tipoDespesa = new TipoDespesa();
TipoDespesaBO tipoDespesaBO = new TipoDespesaBO();
tipoDespesa.ClasseDespesaID = Convert.ToInt32(txtClasseDespesa.SelectedValue);
tipoDespesa.NomeTipoDespesa = txtTipoDespesa.Text;
tipoDespesaBO.GravarTipoDespesa(tipoDespesa);
MessageBox.Show("Tipo despesa gravado com sucesso", "Ok", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (MessageBox.Show("Desejar cadastrar outro tipo de despesa ?", "Pergunta", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
txtClasseDespesa.Focus();
txtTipoDespesa.Clear();
}
else
{
this.Close();
}
}
else
{
MessageBox.Show("Informe o nome tipo despesa", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void SalvaDespesa()
{
TipoDespesa tipo = (TipoDespesa)comboTipo.SelectedItem;
var despesaBuilder = new DespesasBuilder()
.GetData(dataDespesa.Value)
.GetTipoDespesaId(tipo.Id)
.GetValor(Convert.ToDecimal(txtValor.Text))
.GetDescricao(txtDescricao.Text)
.GetIsAtiva(true);
Despesas despesa = despesaBuilder.Build();
if (new DespesasDao().DbAdd(despesa))
{
if (MessageBox.Show("Despesa cadastrada com sucessso!\nCadastrar Nova?", "Pergunta", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CarregarTabela();
LimpaTextBoxes();
}
else
{
this.Close();
}
}
else
{
MessageBox.Show("Erro na adição de despesa, favor tentar novamente.");
}
}
public TipoDespesa SelectTipoDespesaEscritorio(int codigo)
{
TipoDespesa tipoDespesa = null;
IDbCommand objCommand;
IDbConnection objConexao;
IDataReader objDataReader;
string sql = "SELECT * FROM TID_TIPODESPESA WHERE TID_CODIGO = ?codigo";
objConexao = Mapped.Connection();
objCommand = Mapped.Command(sql, objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?codigo", codigo));
objDataReader = objCommand.ExecuteReader();
while (objDataReader.Read())
{
tipoDespesa = new TipoDespesa();
tipoDespesa.Codigo = Convert.ToInt32(objDataReader["TID_CODIGO"]);
tipoDespesa.Categoria = Convert.ToInt32(objDataReader["TID_CATEGORIA"]);
tipoDespesa.Descricao = Convert.ToString(objDataReader["TID_TIPODESPESA"]);
}
objConexao.Close();
objDataReader.Close();
objConexao.Dispose();
objCommand.Dispose();
objDataReader.Dispose();
return(tipoDespesa);
}
private void btnExcluir_Click(object sender, EventArgs e)
{
if (tabControl1.SelectedIndex == 0)
{
tabControl1.SelectTab(1);
}
if (MessageBox.Show("Confirma exclusão?", "Yes or No",
MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2)
== DialogResult.Yes)
{
var tipoDespesa = new TipoDespesa
{
IdTipoDespesa = int.Parse(txtId.Text),
NomeTipoDespesa = txtNomeTipoDespesa.Text,
};
if (tipoDespesa.Excluir(conexao) > 0)
{
MessageBox.Show("Tipo de despesa excluído com sucesso!");
AtualizarTabela();
return;
}
MessageBox.Show("Erro ao excluir tipo de despesa!");
}
}
public async Task <IActionResult> Edit(int id, [Bind("TipoDespesaId,Nome")] TipoDespesa tipoDespesa)
{
if (id != tipoDespesa.TipoDespesaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
TempData["Confirmacao"] = tipoDespesa.Nome + " foi atualizado com sucesso.";
_context.Update(tipoDespesa);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoDespesaExists(tipoDespesa.TipoDespesaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoDespesa));
}
public ActionResult ExcluirTipoDespesa(int id)
{
var c = new TipoDespesa().SelecionarPorId(id);
c.Excluir();
return(RedirectToAction("TiposDespesas"));
}
public async Task <IHttpActionResult> PutTipoDespesa(int id, TipoDespesa tipoDespesa)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tipoDespesa.TipoDespesaId)
{
return(BadRequest());
}
db.Entry(tipoDespesa).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoDespesaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
internal List <TipoDespesa> PegarTodosTiposDeDespesaAtivosDropDownList()
{
List <TipoDespesa> tipoDespesas = new List <TipoDespesa>();
using (SqlConnection connection = new SqlConnection(StringConnection))
{
try
{
// private string InsertConta = "INSERT INTO Contas (Nome,Saldo,CreateTime,CreateBy,Obsoleto) VALUES(@Nome,@Saldo,@CreateTime,@CreateBy,@Obsoleto)";
connection.Open();
var command = new SqlCommand(SelectTipoDespesaAtivasDropDownList, connection);
var dataReader = command.ExecuteReader();
while (dataReader.Read())
{
TipoDespesa tipoDespesa = new TipoDespesa();
//string ID = dataReader["ID"].ToString();
tipoDespesa.Id = Convert.ToInt32(dataReader["Id"]);
tipoDespesa.Nome = dataReader["Nome"].ToString();
tipoDespesas.Add(tipoDespesa);
}
dataReader.Close();
command.Dispose();
connection.Close();
}
catch (Exception ex)
{
}
}
return(tipoDespesas);
}
private List <TipoDespesa> PegarTipoDespesaPorId(SqlConnection cn, int id)
{
List <TipoDespesa> tipoDespesas = new List <TipoDespesa>();
try
{
using (SqlCommand cmd = new SqlCommand(SelectTipoDespesaId, cn))
{
cmd.Parameters.Add(new SqlParameter("@Id", id));
// cn.Open();
var dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
TipoDespesa tipoDespesa = new TipoDespesa();
tipoDespesa.Id = Convert.ToInt32(dataReader["Id"]);
tipoDespesa.Nome = dataReader["Nome"].ToString();
tipoDespesas.Add(tipoDespesa);
}
// cn.Close();
}
}
catch (Exception ex)
{
}
return(tipoDespesas);
}
private void AtualizarDespesa()
{
TipoDespesaDAO despesaDAO = new TipoDespesaDAO();
TipoDespesa atual = despesaDAO.Find(d => d.COD_TIPO_DESPESA == ((TipoDespesa)cmbDespesas.SelectedItem).COD_TIPO_DESPESA).First <TipoDespesa>();
atual.DESCRICAO_DESPESA = txtDecricao.Text;
despesaDAO.SaveChanges();
}
public ActionResult DeleteConfirmed(int id)
{
TipoDespesa tipoDespesa = db.TipoDespesas.Find(id);
tipoDespesa.Situacao = false;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void EditarCusto(int id)
{
Despesas despesas = new Despesas();
DespesasDB despesasDB = new DespesasDB();
TipoDespesa tipoDespesa = new TipoDespesa();
TipoDespesasDB tipoDespesaDB = new TipoDespesasDB();
try
{
if (Convert.ToDateTime(txtEditarData.Text) > DateTime.Today)
{
lblMsgEditarCusto.Text = "A data deve ser menos que a data de hoje!";
divMsgEditarCusto.Attributes["class"] = "alert alert-danger";
}
else if (ddlEditarTipo.SelectedItem.Text == "Selecione")
{
lblMsgEditarCusto.Text = "Escolha um tipo de custo!";
divMsgEditarCusto.Attributes["class"] = "alert alert-danger";
ddlEditarTipo.Focus();
}
else if (string.IsNullOrWhiteSpace(txtEditarData.Text))
{
lblMsgEditarCusto.Text = "Preencha a data!";
divMsgEditarCusto.Attributes["class"] = "alert alert-danger";
txtEditarData.Focus();
}
else if (ddlEditarTipo.SelectedItem.Text == "Outros" && string.IsNullOrWhiteSpace(txtEditarDescricao.Text))
{
lblMsgEditarCusto.Text = "Escreva uma descrição!";
divMsgEditarCusto.Attributes["class"] = "alert alert-danger";
txtEditarDescricao.Focus();
}
else
{
despesas = despesasDB.Select(id);
despesas.Valor = Convert.ToDecimal(txtEditarValor.Text);
despesas.Data = Convert.ToDateTime(txtEditarData.Text);
despesas.Obs = txtEditarObs.Text;
tipoDespesa.Codigo = Convert.ToInt32(ddlEditarTipo.SelectedItem.Value);
despesas.TipoDespesa = tipoDespesa;
if (ddlEditarTipo.SelectedItem.Text == "Outros")
{
tipoDespesaDB.InsertCustoProcesso(txtEditarDescricao.Text);
tipoDespesa.Codigo = tipoDespesaDB.GetLastId(txtEditarDescricao.Text);
}
despesasDB.Update(despesas);
CarregaGridElblTotal(Convert.ToInt32(Session["ProcessoCusto"]));
Function.CarregaItemDDLByCodigo(ddlEditarTipo, tipoDespesa.Codigo);
lblMsgEditarCusto.Text = "Custo editado com sucesso";
divMsgEditarCusto.Attributes["class"] = "alert alert-success";
}
}
catch (FormatException)
{
lblMsgEditarCusto.Text = "Data invalida";
divMsgEditarCusto.Attributes["class"] = "alert alert-danger";
}
}
private void ExcluirDespesa()
{
TipoDespesa despesa = new TipoDespesa();
TipoDespesaDAO despesaDAO = new TipoDespesaDAO();
despesa = despesaDAO.Find(d => d.COD_TIPO_DESPESA == ((TipoDespesa)cmbDespesas.SelectedItem).COD_TIPO_DESPESA).First <TipoDespesa>();
despesaDAO.Delete(despesa);
despesaDAO.SaveChanges();
}
public ActionResult DeleteConfirmed(int id)
{
TipoDespesa tipoDespesa = db.TipoDespesas.Find(id);
tipoDespesa.Status = EnumStatus.INATIVO;
// db.TipoDespesas.Remove(tipoDespesa);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void SalvarDespesa()
{
TipoDespesa novaDespesa = new TipoDespesa();
TipoDespesaDAO despesaDAO = new TipoDespesaDAO();
novaDespesa.DESCRICAO_DESPESA = txtDecricao.Text;
despesaDAO.Add(novaDespesa);
despesaDAO.SaveChanges();
novaDespesa = null;
}
public async Task <IHttpActionResult> PostTipoDespesa(TipoDespesa tipoDespesa)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = tipoDespesa.TipoDespesaId }, tipoDespesa));
}
private void frmMembro_Load(object sender, EventArgs e)
{
dsTipoDespesa.Tables.Add(TipoDespesa.Listar(conexao));
bnTipoDespesa.DataSource = dsTipoDespesa.Tables["TIPODESPESA"];
dgvTipoDespesa.DataSource = bnTipoDespesa;
bnvTipoDespesa.BindingSource = bnTipoDespesa;
txtId.DataBindings.Add(nameof(txtId.Text), bnTipoDespesa, "ID_TIPODESPESA");
txtNomeTipoDespesa.DataBindings.Add(nameof(txtNomeTipoDespesa.Text), bnTipoDespesa, "NOME_TIPODESPESA");
}
public ActionResult Edit([Bind(Include = "Id,Nome,Status")] TipoDespesa tipoDespesa)
{
if (ModelState.IsValid)
{
db.Entry(tipoDespesa).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoDespesa));
}
public void Update(TipoDespesa TipoDespesa)
{
try
{
dbTipoDespesa.Update(TipoDespesa);
}
catch (Exception ex)
{
throw new Exception($"Erro ao atualizar os dados do TipoDespesa: {ex.Message}.");
}
}
public async Task <IHttpActionResult> GetTipoDespesa(int id)
{
TipoDespesa tipoDespesa = await db.TipoDespesas.FindAsync(id);
if (tipoDespesa == null)
{
return(NotFound());
}
return(Ok(tipoDespesa));
}
public void Save(TipoDespesa TipoDespesa)
{
try
{
dbTipoDespesa.Add(TipoDespesa);
}
catch (Exception ex)
{
throw new Exception($"Erro ao salvar TipoDespesa: {ex.Message}.");
}
}
public ActionResult Create([Bind(Include = "Id,Nome,Situacao")] TipoDespesa tipoDespesa)
{
if (ModelState.IsValid)
{
db.TipoDespesas.Add(tipoDespesa);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoDespesa));
}
public IActionResult Put(int id, [FromBody] TipoDespesa tipoDespesa)
{
if (tipoDespesa == null)
{
return(BadRequest());
}
repository.Update(tipoDespesa);
return(Ok(tipoDespesa));
}
public IActionResult Post([FromBody] TipoDespesa tipoDespesa)
{
if (tipoDespesa == null)
{
return(BadRequest());
}
repository.Create(tipoDespesa);
return(CreatedAtAction("Get", new { id = tipoDespesa.id }, tipoDespesa));
}
public void AlterarTipoDespesa(TipoDespesa tipoDespesa)
{
conexaoBanco = new ConexaoBanco();
sb = new StringBuilder();
sb.Append("UPDATE tblTipoDespesa SET ");
sb.Append("NomeTipoDespesa = '" + tipoDespesa.NomeTipoDespesa + "',");
sb.Append("ClasseDespesaID = '" + tipoDespesa.ClasseDespesaID + "' ");
sb.Append("WHERE TipoDespesaID = " + tipoDespesa.TipoDespesaID);
conexaoBanco.manterCRUD(sb.ToString());
}
public void SalvarTipoDespesa(TipoDespesa tipoDespesa)
{
try
{
_context.TipoDespesas.Add(tipoDespesa);
_context.SaveChanges();
}
catch (Exception)
{
throw new Exception("OPS... Erro ao criar uma nova tipo de despesa.");
}
}
public async Task <IActionResult> Create([Bind("TipoDespesaId,Nome")] TipoDespesa tipoDespesa)
{
if (ModelState.IsValid)
{
TempData["Confirmacao"] = tipoDespesa.Nome + " foi cadastrado com sucesso.";
_context.Add(tipoDespesa);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tipoDespesa));
}
public void InserirTipoDespesa(TipoDespesa tipoDespesa)
{
conexaoBanco = new ConexaoBanco();
sb = new StringBuilder();
sb.Append("INSERT INTO tblTipoDespesa(NomeTipoDespesa,ClasseDespesaID)VALUES('");
sb.Append(tipoDespesa.NomeTipoDespesa);
sb.Append("','");
sb.Append(tipoDespesa.ClasseDespesaID);
sb.Append("')");
conexaoBanco.manterCRUD(sb.ToString());
}
public void AddUser()
{
var tipoDespesas = _tipoDespesaRepository.GetAll();
TipoDespesa tipoDespesa = new TipoDespesa
{
NOME_TIPO_DESPESA = "nd",
};
_tipoDespesaRepository.Add(tipoDespesa);
var tipoDespesasdepois = _tipoDespesaRepository.GetAll();
Assert.IsTrue(tipoDespesas.Count() < tipoDespesasdepois.Count());
}