public async Task <Presenca> Delete(Presenca presencaRetornada)
{
context.Presenca.Remove(presencaRetornada);
await context.SaveChangesAsync();
return(presencaRetornada);
}
public async Task <Evento> Delete(Evento eventoRetornado)
{
context.Evento.Remove(eventoRetornado);
await context.SaveChangesAsync();
return(eventoRetornado);
}
public async Task <Usuario> Alterar(Usuario usuario)
{
_contexto.Entry(usuario).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(usuario);
}
public async Task <Localizacao> Put(Localizacao localizacao)
{
context.Entry(localizacao).State = EntityState.Modified;
await context.SaveChangesAsync();
return(localizacao);
}
public async Task <TipoUsuario> Delete(TipoUsuario tipoUsuarioRetornado)
{
context.TipoUsuario.Remove(tipoUsuarioRetornado);
await context.SaveChangesAsync();
return(tipoUsuarioRetornado);
}
public async Task <Evento> Alterar(Evento evento)
{
_contexto.Entry(evento).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(evento);
}
public async Task <Localizacao> Alterar(Localizacao localizacao)
{
_contexto.Entry(localizacao).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(localizacao);
}
public async Task <Presenca> Alterar(Presenca presenca)
{
_contexto.Entry(presenca).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(presenca);
}
public async Task <Localizacao> Delete(Localizacao localizacaoRetornada)
{
context.Localizacao.Remove(localizacaoRetornada);
await context.SaveChangesAsync();
return(localizacaoRetornada);
}
public async Task <Usuario> Delete(Usuario usuarioRetornado)
{
context.Usuario.Remove(usuarioRetornado);
await context.SaveChangesAsync();
return(usuarioRetornado);
}
public async Task <Categoria> Delete(Categoria categoriaRetornada)
{
context.Categoria.Remove(categoriaRetornada);
await context.SaveChangesAsync();
return(categoriaRetornada);
}
public async Task <Categoria> Alterar(Categoria categoria)
{
// Comparamos os atributos que foram modificados através do EF
_contexto.Entry(categoria).State = EntityState.Modified;
await _contexto.SaveChangesAsync();
return(categoria);
}
public async Task <ActionResult <Evento> > Post(Evento Evento)
{
try{
await context.Evento.AddAsync(Evento);
await context.SaveChangesAsync();
}catch (System.Exception) {
throw;
}
return(Evento);
}
public async Task <ActionResult <Presenca> > Post(Presenca Presenca)
{
try{
await context.Presenca.AddAsync(Presenca);
await context.SaveChangesAsync();
}catch (System.Exception) {
throw;
}
return(Presenca);
}
public async Task <ActionResult <TipoUsuario> > Post(TipoUsuario TipoUsuario)
{
try{
await context.TipoUsuario.AddAsync(TipoUsuario);
await context.SaveChangesAsync();
}catch (System.Exception) {
throw;
}
return(TipoUsuario);
}
public async Task <ActionResult <Localizacao> > Post(Localizacao localizacao)
{
try{
await context.Localizacao.AddAsync(localizacao);
await context.SaveChangesAsync();
}catch (System.Exception) {
throw;
}
return(localizacao);
}
public async Task <ActionResult <Eventos> > Post(Eventos evento)
{
try{
// Tratamos contra ataque de SQL Injection
await _contexto.AddAsync(evento);
// Salvamos efetivamente o nosso objeto no banco de dados
await _contexto.SaveChangesAsync();
}catch (DbUpdateConcurrencyException) {
throw;
}
return(evento);
}
public async Task <ActionResult <TipoUsuario> > Post(TipoUsuario tipousuario)
{
try {
// Tratamos contra ataques de SQL INJECTION
await _contexto.AddAsync(tipousuario);
// Salvamos efetivamento o nosso objeto
await _contexto.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) {
throw;
}
return(tipousuario);
}
public async Task <ActionResult <Localizacao> > Post(Localizacao localizacao)
{
try{
//Tratamos contra ataques de SQL Injection
await _contexto.AddAsync(localizacao);
//Salvamos efetivamente o nosso objeto no Banco de dados.
await _contexto.SaveChangesAsync();
}catch (DbUpdateConcurrencyException) {
throw;
}
return(localizacao);
}
public async Task <ActionResult <Categoria> > Post(Categoria categoria)
{
try
{
await context.Categoria.AddAsync(categoria);
await context.SaveChangesAsync();
}catch (System.Exception)
{
throw;
}
return(categoria);
}
//Objeto:Evento var:categoria
public async Task <ActionResult <Evento> > Post(Evento evento)
{
try{
//Tratamos contra ataques de SQL injection
await _contexto.AddAsync(evento);
//parametros, para não sofre nenhum tipo de ataques
//Salvamos efetiamente o nosso objeto no banco de dados
await _contexto.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
throw;
}
return(evento);
}
public async Task <ActionResult <Usuario> > Post(Usuario usuario)
{
try {
// Tratamos contra ataques de SQL Injection
await _contexto.AddAsync(usuario);
// Salvamos efetivamente o nosso objeto no banco
await _contexto.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
throw;
}
return(usuario);
}
public async Task <ActionResult <Evento> > Post(Evento evento)
{
try
{
await _context.AddAsync(evento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(evento);
}
public async Task <ActionResult <Usuario> > Post(Usuario usuario)
{
try
{
await _context.AddAsync(usuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(usuario);
}
public async Task <ActionResult> Put(int id_catg, Categoria categoria)
{
Categoria categoriaRetornada = await context.Categoria.FindAsync(id_catg);
if (categoriaRetornada == null)
{
return(NotFound());
}
// categoriaRetornada.Titulo = categoria.Titulo;
// context.Categoria.Update(categoriaRetornada);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <Categoria> > Post(Categoria categoria)
{
try
{
await _context.AddAsync(categoria);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(categoria);
}
public async Task <ActionResult <Localizacao> > Post(Localizacao localizacao)
{
try
{
await _context.AddAsync(localizacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(localizacao);
}
public async Task <ActionResult <Presenca> > Post(Presenca presenca)
{
try
{
await _context.AddAsync(presenca);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(presenca);
}
public async Task <ActionResult <Presenca> > Post(Presenca presenca)
{
try
{
// Tratamento contra SQL Injection
await _contexto.AddAsync(presenca);
await _contexto.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(presenca);
}
public async Task <ActionResult <Categoria> > Post(Categoria categoria)
{
try
{
// Tratamos contra ataques de SQL Injection
await _contexto.AddAsync(categoria);
//Salvamos efetivamente o nosso objeto no banco de dadOS
await _contexto.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(categoria);
}