public void IncluirReceitasModel(ReceitasModelView entity)
{
List <ReceitaIngredientes> lista = new List <ReceitaIngredientes>();
int receitaId = entity.ReceitasId;
foreach (var item in entity.IngredientesModelView)
{
lista.Add(new ReceitaIngredientes()
{
ReceitasId = receitaId,
IngredientesId = item.IngredientesId,
Unidade = item.Unidade,
Quantidade = item.Quantidade
});
}
var receita = new Receitas()
{
CategoriasId = entity.Categoria.CategoriasId,
DataCadastro = entity.DataCadastro,
ModoPreparo = entity.ModoPreparo,
Titulo = entity.Titulo,
UsuariosId = entity.Usuario.UsuariosId,
ReceitaIngredientes = lista
};
_context.Receita.Add(receita);
_context.SaveChanges();
}
public TagReceita(Tags tags, int tagsId, Receitas receitas, int receitasId)
{
Tags = tags;
TagsId = tagsId;
Receitas = receitas;
ReceitasId = receitasId;
}
public async Task <bool> updateAssync(Receitas entity)
{
using (var conn = _dbConnenction)
{
return(await conn.UpdateAsync(entity));
}
}
public async Task <ActionResult <Receitas> > PostReceitas(Receitas receitas)
{
_context.Receitas.Add(receitas);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetReceitas", new { id = receitas.Id }, receitas));
}
public async Task <IActionResult> PutReceitas(int id, Receitas receitas)
{
if (id != receitas.Id)
{
return(BadRequest());
}
_context.Entry(receitas).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReceitasExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Receitas> > Post(Receitas obj)
{
try
{
obj.Date = DateTime.Now;
var tagList = new List <Tags>();
foreach (var item in obj.Tags)
{
var tag = new Tags()
{
Tag = item.Title
};
var tagRec = new TagReceita()
{
Receitas = obj,
Tags = tag
};
var tagExist = _unit.Tags.Get(x => x.Tag == item.Title);
if (tagExist.Count == 0)
{
_unit.Tags.Insert(tag);
_unit.TagProj.Insert(tagRec);
}
}
_unit.Receitas.Insert(obj);
await _unit.CommitAssync();
return(Ok(obj));
}
catch (Exception)
{
throw;
}
}
public List <Receitas> NovaReceitas(int index)
{
List <Receitas> Lista = new List <Receitas>();
Receitas NovaListaReceita = new Receitas();
if (index == 1)
{
Ingredientes PaoDeQueijo = receitas.Find(x => x.NomeDaReceita.Equals("Pão de Queijo"));
NovaListaReceita.receita = PaoDeQueijo;
Lista.Add(NovaListaReceita);
}
if (index == 2)
{
Ingredientes PaoDeQueijo = receitas.Find(x => x.NomeDaReceita.Equals("Bolo de Fubá"));
NovaListaReceita.receita = PaoDeQueijo;
Lista.Add(NovaListaReceita);
}
if (index == 3)
{
Ingredientes PaoDeQueijo = receitas.Find(x => x.NomeDaReceita.Equals("Canjica"));
NovaListaReceita.receita = PaoDeQueijo;
Lista.Add(NovaListaReceita);
}
else
{
index = 0;
}
return(Lista);
}
public void CadastrarNovaReceita(Receitas novaReceita)
{
var strsql = @"INSERT INTO recebimentos (
data_recebimento
,valor
,id_categoria
,descricao
,id_usuario
)
VALUES (
@data
,@valor
,@categoria
,@descricao
,@idUsuario
)" ;
using (var command = new SqlCommand(strsql, Conexao.Conectar()))
{
command.Parameters.AddWithValue("@idUsuario", Sessao.Usuario.Id);
command.Parameters.AddWithValue("@data", novaReceita.Data);
command.Parameters.AddWithValue("@valor", novaReceita.Valor);
command.Parameters.AddWithValue("@categoria", novaReceita.Categoria.Id);
command.Parameters.AddWithValue("@descricao", novaReceita.Descricao);
command.ExecuteNonQuery();
}
}
public async Task Descurtir(int id)
{
var receitas = await Receitas.GetByIdAssync(id);
receitas.Unlikes++;
await _context.SaveChangesAsync();
}
public async Task <ActionResult> Edit(int id, [Bind("Id,Titulo,Descricao,CategoriaId")] Receitas receitas)
{
ViewBag.Categoria = ListaCategoria();
if (id != receitas.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(receitas);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReceitasExists(receitas.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(receitas));
}
private void Salvar()
{
var obj = new Receitas();
obj.Nome = txtNome.Text;
obj.Tipo = new Tipo_Receita()
{
Id = Convert.ToInt32(ddlTipo.SelectedValue)
};
obj.Usuario = new Usuario()
{
Id = ((Usuario)User).Id
};
obj.Ingredientes = txtIngredientes.Text;
obj.ModoDePreparo = txtModo.Text;
obj.UrlVideo = txtUrl.Text;
obj.Foto = fupArquivo.FileName;
if (fupArquivo.HasFile)
{
if (!Directory.Exists(Server.MapPath("~/Uploads")))
{
Directory.CreateDirectory(Server.MapPath("~/Uploads"));
}
var fileName = Path.Combine(Server.MapPath("~/Uploads"), fupArquivo.FileName);
fupArquivo.SaveAs(fileName);
}
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Db"].ConnectionString))
{
string strSQL = @"INSERT INTO receitas (nome, id_tipo, ingredientes, modo_preparo, url_video, foto, id_usuario)
VALUES (@nome, @id_tipo, @ingredientes, @modo_preparo, @url_video, @foto, @id_usuario)";
using (SqlCommand cmd = new SqlCommand(strSQL))
{
cmd.Connection = conn;
cmd.Parameters.Add("@nome", SqlDbType.VarChar).Value = obj.Nome;
cmd.Parameters.Add("@id_tipo", SqlDbType.Int).Value = obj.Tipo.Id;
cmd.Parameters.Add("@ingredientes", SqlDbType.VarChar).Value = obj.Ingredientes;
cmd.Parameters.Add("@modo_preparo", SqlDbType.VarChar).Value = obj.ModoDePreparo;
cmd.Parameters.Add("@url_video", SqlDbType.VarChar).Value = obj.UrlVideo;
cmd.Parameters.Add("@foto", SqlDbType.VarChar).Value = obj.Foto;
cmd.Parameters.Add("@id_usuario", SqlDbType.Int).Value = obj.Usuario.Id;
foreach (SqlParameter parameter in cmd.Parameters)
{
if (parameter.Value == null)
{
parameter.Value = DBNull.Value;
}
}
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
}
}
//public void Update(Receitas obj) => Receitas.Update(obj);
//public void Create(Receitas obj) => Receitas.Insert(obj);
//public async void Delete(int id) => await Receitas.DeleteAsync(id);
public async Task Curtir(int id)
{
var receitas = await Receitas.GetByIdAssync(id);
receitas.Likes++;
_context.Update(receitas);
await _context.SaveChangesAsync();
}
public async Task <int> createAssync(Receitas entity)
{
using (var conn = _dbConnenction)
{
// Poderia ser utilizado o Insert() do fastcrud, porém retorna void(), e quero que retorne o id inserido
// também podeira usar dapper.contrib que retorna o id da linha inserida, mas não optei por instalar mais uma biblioteca.
return(await conn.ExecuteScalarAsync <int>(ReceitasScripts.INSERT_SINGLE_RECEITAS, entity));
}
}
public async Task LoadAsync()
{
var receitas = await _receitasDaHoraApiService.GetReceitasByCategoriaIdAsync(_categoria.Id);
Receitas.Clear();
foreach (var receita in receitas)
{
Receitas.Add(receita);
}
}
public IActionResult Update([FromBody] Receitas receitas, [FromServices] ReceitasService service)
{
if (ModelState.IsValid)
{
return(Ok(service.UpdateReceita(receitas)));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> CriarAssync(Receitas entity)
{
try
{
var result = await receitasServices.createAssync(entity);
return(Success(result));
}
catch (Exception ex)
{
return(Error(ex, ex.Message.Contains('|') ? ex.Message : null));
}
}
public async Task <ActionResult> Create([Bind("Id,Titulo,Descricao,CategoriaId")] Receitas receitas)
{
ViewBag.Categoria = ListaCategoria();
if (ModelState.IsValid)
{
_context.Add(receitas);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(receitas));
}
//public async Task<List<Receitas>> GetAll() => (List<Receitas>) await Receitas.GetAsync();
public async Task <Receitas> GetById(int id)
{
var receitas = await Receitas.GetByIdAssync(id);
var imgs = await Img.GetAsync(x => x.ReceitasId == receitas.Id);
var respostas = await Resp.GetAsync(x => x.ReceitasId == receitas.Id);
var tagProj = await TagProj.GetAsync(x => x.ReceitasId == receitas.Id);
receitas.Imagens = imgs;
receitas.Respostas = respostas;
receitas.Tag = tagProj;
return(receitas);
}
protected void Page_Load(object sender, EventArgs e)
{
if (IsPostBack)
{
return;
}
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Db"].ConnectionString))
{
var lst = new List <Receitas>();
string strSQL = @"SELECT * FROM receitas";
using (SqlCommand cmd = new SqlCommand(strSQL))
{
conn.Open();
cmd.Connection = conn;
cmd.CommandText = strSQL;
var dataReader = cmd.ExecuteReader();
var dt = new DataTable();
dt.Load(dataReader);
conn.Close();
foreach (DataRow row in dt.Rows)
{
var receita = new Receitas()
{
Id = Convert.ToInt32(row["id"]),
Nome = row["nome"].ToString(),
Tipo = new Tipo_Receita()
{
Id = Convert.ToInt32(row["id_tipo"])
},
Ingredientes = row["ingredientes"].ToString(),
ModoDePreparo = row["modo_preparo"].ToString(),
UrlVideo = row["url_video"].ToString(),
Foto = row["foto"].ToString()
};
lst.Add(receita);
}
}
gridView.DataSource = lst;
gridView.DataBind();
}
}
private void InserirLancamento(bool fecharTela)
{
try
{
switch (_tipoLancamentoSelecionado)
{
case TipoLancamento.Despesa:
var novaDespesa = new Despesas()
{
DataVencimento = _data,
Valor = _valor,
Categoria = _categoriaLancamento,
Descricao = _descricao,
Pago = _valorPago,
ParcelaAtual = _parcelaAtual,
TotalParcelas = _totalParcelas
};
_despesaDAL.CadastrarNovaDespesa(novaDespesa);
break;
case TipoLancamento.Receita:
var novaReceita = new Receitas()
{
Data = _data,
Valor = _valor,
Categoria = _categoriaLancamento,
Descricao = _descricao
};
_receitaDAL.CadastrarNovaReceita(novaReceita);
break;
}
if (fecharTela)
{
FecharTela(true);
}
}
catch (Exception ex)
{
var teste = ex;
_textAvisoCadastro = string.Format("Houve um erro ao cadastrar a {0} informada.", _tipoLancamentoSelecionado);
RaisePropertyChanged("textAvisoCadastro");
}
}
public async Task <ActionResult> Update(Receitas obj)
{
try
{
var entityExist = _unit.Receitas.EntityExists(obj);
if (!entityExist)
{
return(NotFound());
}
_unit.Receitas.Update(obj);
await _unit.CommitAssync();
return(Ok(obj));
}
catch (Exception)
{
throw;
}
}
public ResponseCadastroDTO UpdateReceita(Receitas receitas)
{
ResponseCadastroDTO response = new ResponseCadastroDTO();
try
{
MongoDbContext context_ = new MongoDbContext();
context_.Receitas.ReplaceOne(s => s.Id == receitas.Id, receitas);
response.cadastrado = true;
}
catch (Exception e)
{
response.cadastrado = false;
response.erros = new List <string>();
response.erros.Add("Ocorreu um erro ao se conectar com a base de dados.");
throw;
}
return(response);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
ddReceita.DataSource = Receitas.ListaTodos();
ddReceita.DataTextField = Receita.Campos.Nome;
ddReceita.DataValueField = Receita.Campos.ID;
ddReceita.DataBind();
ddCategoria.DataSource = Categorias.ListaTodos();
ddCategoria.DataTextField = Categoria.Campos.Nome;
ddCategoria.DataValueField = Categoria.Campos.ID;
ddCategoria.DataBind();
ddDificuldade.DataSource = Dificuldades.ListaTodos();
ddDificuldade.DataTextField = Dificuldade.Campos.Nome;
ddDificuldade.DataValueField = Dificuldade.Campos.ID;
ddDificuldade.DataBind();
}
}
public bool ExisteMensalidade(Receitas mensalidade)
{
using (var cn = Connection)
{
var query = @" SELECT CASE WHEN EXISTS (
SELECT *
FROM Receitas r
WHERE r.ClienteId = '" + mensalidade.ClienteId + "' and " +
"r.AnoReferencia = '" + mensalidade.AnoReferencia + "' and " +
"r.MesReferencia = '" + mensalidade.MesReferencia + "' and " +
"r.ReceitasId != '" + mensalidade.ReceitasId + "' " +
") THEN CAST(1 AS INT) ELSE CAST(0 AS INT) END ";
cn.Open();
var valido = cn.Query <int>(query).First();
cn.Close();
if (valido == 1)
{
return(true);
}
return(false);
}
}
public void AtualizarReceitaModel(ReceitasModelView entity)
{
List <ReceitaIngredientes> lista = new List <ReceitaIngredientes>();
int receitaId = entity.ReceitasId;
foreach (var item in entity.IngredientesModelView)
{
lista.Add(new ReceitaIngredientes()
{
ReceitasId = receitaId,
IngredientesId = item.IngredientesId,
Unidade = item.Unidade,
Quantidade = item.Quantidade
});
}
var receita = new Receitas()
{
ReceitasId = entity.ReceitasId,
CategoriasId = entity.Categoria.CategoriasId,
DataCadastro = entity.DataCadastro,
ModoPreparo = entity.ModoPreparo,
Titulo = entity.Titulo,
UsuariosId = entity.Usuario.UsuariosId
};
_context.Entry(receita).State = EntityState.Modified;
var allRegisters = _context.ReceitaIngredientes.Where(x => x.ReceitasId == entity.ReceitasId).ToList();
_context.ReceitaIngredientes.RemoveRange(allRegisters);
_context.SaveChanges();
_context.ReceitaIngredientes.AddRangeAsync(lista);
_context.SaveChanges();
}
protected void Page_Load(object sender, EventArgs e)
{
MembershipUser mUser = Membership.GetUser(User.Identity.Name);
if (!Page.IsPostBack)
{
novoComentario = new Receita();
ddReceita.DataSource = Receitas.ListaTodos();
ddReceita.DataTextField = Receita.Campos.Nome;
ddReceita.DataValueField = Receita.Campos.ID;
ddReceita.DataBind();
ddClassificação.DataSource = Classificacoes.ListaTodos();
ddClassificação.DataTextField = Classificacao.Campos.Nome;
ddClassificação.DataValueField = Classificacao.Campos.ID;
ddClassificação.DataBind();
Session["Receita"] = novoComentario;
flag = true;
}
}
private static LogReceitasDespesas GetLog(Receitas r)
{
var logRecDesp = new LogReceitasDespesas
{
Documento = r.Documento,
DataVencimento = r.DataVencimento,
DataPagamento = r.DataPagamento,
DataEmissao = r.DataEmissao,
Valor = r.Valor,
Juros = r.Juros,
Multa = r.Multa,
ValorTotal = r.ValorTotal,
Observacao = r.Observacao,
Situacao = r.Situacao,
Tipo = "Receita",
CategoriaFinanceiraId = r.CategoriaFinanceiraId.ToString(),
FornecedorId = r.ClienteId.ToString(),
FuncionarioId = r.FuncionarioId.ToString(),
TipoPagamentoId = r.TipoPagamentoId,
RegistroId = r.ReceitasId.ToString()
};
return(logRecDesp);
}
public void createAssync(Receitas Receitas)
{
var result = receitasRepository.createAssync(Receitas).Result;
Assert.True(result > 0);
}
public async Task <bool> updateAssync(Receitas entity)
{
return(await receitasRepository.updateAssync(entity));
}
public IEnumerable <Receitas> ObterReceitasPorPeriodo(PeriodoRelatorio periodoRelatorio)
{
var dataInicio = new DateTime();
var dataFim = new DateTime();
List <Receitas> receitas = new List <Receitas>();
switch (periodoRelatorio)
{
case PeriodoRelatorio.MesAtual:
dataInicio = Convert.ToDateTime(string.Format("01/{0}/{1}", DateTime.Now.Month, DateTime.Now.Year));
dataFim = Convert.ToDateTime(string.Format("{0}/{1}/{2}", DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month), DateTime.Now.Month, DateTime.Now.Year));
break;
case PeriodoRelatorio.UltimosSeisMeses:
dataInicio = DateTime.Now.AddMonths(-6);
dataFim = DateTime.Now;
break;
}
var strsql = @"SELECT id_recebimento
,data_recebimento
,valor
,id_categoria
,descricao
FROM recebimentos
WHERE id_usuario = @idUsuario
AND data_recebimento BETWEEN @dataInicio
AND @dataFim" ;
using (var busca = new SqlCommand(strsql, Conexao.Conectar()))
{
busca.Parameters.AddWithValue("@idUsuario", Sessao.Usuario.Id);
busca.Parameters.AddWithValue("@dataInicio", dataInicio);
busca.Parameters.AddWithValue("@dataFim", dataFim);
using (var reader = busca.ExecuteReader())
{
while (reader.Read())
{
var receita = new Receitas()
{
Id = Convert.ToInt32(reader["id_recebimento"]),
Valor = Convert.ToDecimal(reader["valor"]),
Data = Convert.ToDateTime(reader["data_recebimento"]),
Categoria = new Categoria()
{
Id = Convert.ToInt32(reader["id_categoria"])
},
Descricao = reader["descricao"].ToString()
};
receitas.Add(receita);
}
}
foreach (var rec in receitas)
{
rec.Categoria = _categoriaDAL.ObterDadosCategoriaPorId(rec.Categoria.Id);
}
return(receitas);
}
}
