public async Task <ActionResult <List <Partitura> > > GetByPopularity([FromQuery] long musicaId,
[FromServices] MaiaContext context)
{
if (musicaId == 0)
{
try
{
return(await context.Partituras
.Include(p => p.Musica)
.OrderByDescending(p => p.QuantAcessos)
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
else
{
try
{
return(await context.Partituras
.Where(p => p.MusicaId == musicaId)
.Include(p => p.Musica)
.OrderByDescending(p => p.QuantAcessos)
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public async Task <ActionResult> Favoritar([FromBody] FavoritoDTO model, [FromServices] MaiaContext context)
{
try
{
var favorito = model.ToFavorito();
var favoritoAntigo = await context.Favoritos
.Where(f => f.PostId == favorito.PostId && f.UsuarioId == favorito.UsuarioId)
.FirstOrDefaultAsync();
if (favoritoAntigo != null)
{
favoritoAntigo.Ativo = true;
}
else
{
context.Favoritos.Add(favorito);
}
var post = context.Posts.Where(p => p.Id == model.PostId).FirstOrDefault();
post.QuantFav = post.QuantFav + 1;
if (await context.SaveChangesAsync() > 0)
{
return(Ok());
}
return(BadRequest());
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult <Usuario> > GetById([FromRoute] int id, [FromServices] MaiaContext context)
{
return(await
context.Usuarios
.Where(u => u.Id == id)
.FirstOrDefaultAsync());
}
public async Task <ActionResult <Tab> > GetById([FromRoute] int id, [FromServices] MaiaContext context)
{
try
{
var tab = await context.Tabs
.Where(t => t.Id == id)
.Include(t => t.Usuario)
.Include(t => t.Musica)
.ThenInclude(m => m.Album)
.Include(t => t.Musica)
.ThenInclude(m => m.ArtistaMusicas)
.ThenInclude(am => am.Artista)
.FirstOrDefaultAsync();
tab.QuantAcessos += 1;
await context.SaveChangesAsync();
return(tab);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <string> > Login([FromServices] MaiaContext context, [FromBody] UsuarioDTO dto)
{
if (dto.Email != null && dto.Senha != null)
{
var usuario = await context.Usuarios
.Where(usuario => usuario.Email == dto.Email).FirstOrDefaultAsync();
if (usuario != null)
{
if (_hasherService.VerifyPassword(usuario.Senha, dto.Senha))
{
string token = _tokenService.GenerateToken(usuario);
return(Ok(new { usuario, token }));
}
else
{
return(Unauthorized("Senha incorreta."));
}
}
else
{
return(Unauthorized("Usuário não existe."));
}
}
else
{
return(BadRequest("E-mail ou senha não informado!"));
}
}
public async Task <ActionResult <Album> > Post([FromBody] AlbumDTO model, [FromServices] MaiaContext context)
{
var album = model.ToEntity();
try
{
context.Add(album);
var artista = await context.Artistas.Where(a => a.Id == album.ArtistaId).FirstOrDefaultAsync();
foreach (var musica in album.Musicas)
{
context.ArtistaMusicas.Add(new ArtistaMusica()
{
Artista = artista, Musica = musica
});
}
if (await context.SaveChangesAsync() > 0)
{
return(Created($"albuns/id/{album.Id}", album));
}
return(BadRequest());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <List <Usuario> > > GetAdms([FromServices] MaiaContext context)
{
return(await context
.Usuarios
.Where(u => u.Role == "adm")
.ToListAsync());
}
public async Task <ActionResult <object> > GetById(
[FromRoute] int id, [FromServices] MaiaContext context, [FromQuery] bool detailed = false, [FromQuery] bool includeAlbum = false
)
{
try
{
if (detailed)
{
return(await context.Musicas.Where(m => m.Id == id)
.Include(m => m.Album)
.Include(m => m.ArtistaMusicas)
.ThenInclude(am => am.Artista)
.FirstOrDefaultAsync());
}
if (includeAlbum)
{
return(await context.Musicas.Where(m => m.Id == id)
.Include(m => m.Album)
.FirstOrDefaultAsync());
}
return(await context.Musicas.Where(m => m.Id == id)
.FirstOrDefaultAsync());
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult> SetAsAdm([FromRoute] int id, [FromServices] MaiaContext context)
{
var usuario = await context.Usuarios
.Where(u => u.Id == id)
.FirstOrDefaultAsync();
usuario.Role = "adm";
context.Update(usuario);
await context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <Usuario> > Registrar([FromServices] MaiaContext context, [FromBody] UsuarioDTO model)
{
if (ModelState.IsValid)
{
var usuario = model.ToEntity(_hasherService);
context.Usuarios.Add(usuario);
var res = await context.SaveChangesAsync();
string token = _tokenService.GenerateToken(usuario);
return(Ok(new { usuario, token }));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <ActionResult> Desfavoritar([FromBody] FavoritoDTO model, [FromServices] MaiaContext context)
{
try
{
context.Favoritos.FirstOrDefault(
f => f.PostId == model.PostId && f.UsuarioId == model.UsuarioId
).Ativo = false;
context.Posts.FirstOrDefault(p => p.Id == model.PostId).QuantFav--;
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult <Post> > Get([FromRoute] int postId, [FromServices] MaiaContext context)
{
try
{
return(await context.Posts
.Include(p => p.Usuario)
.Include(p => p.Comentarios)
.ThenInclude(c => c.Usuario)
.Where(p => p.Id == postId).FirstOrDefaultAsync());
}
catch (Exception)
{
return(this.StatusCode(
StatusCodes.Status500InternalServerError, "Falha no banco de dados"
));
}
}
public async Task <ActionResult> Delete([FromRoute] long id, [FromServices] MaiaContext context)
{
try
{
var musica = new Musica()
{
Id = id
};
context.Musicas.Remove(musica);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <string> > Delete([FromRoute] int postId, [FromServices] MaiaContext context)
{
var usuarioId = int.Parse(
HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Sid).FirstOrDefault().Value
);
var post = await context.Posts.Where(p => p.Id == postId).FirstOrDefaultAsync();
if (post != null)
{
if (post.UsuarioId == usuarioId || HttpContext.User.IsInRole("adm"))
{
context.Posts.Remove(post);
await context.SaveChangesAsync();
return(Ok());
}
return(Forbid());
}
return(NoContent());
}
public async Task <ActionResult> Post([FromBody] ArtistaDTO model, [FromServices] MaiaContext context)
{
try
{
var artista = model.ToEntity();
context.Artistas.Add(artista);
if (await context.SaveChangesAsync() > 0)
{
return(Created($"/artistas/{artista.Id}", artista));
}
return(BadRequest(ModelState));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public async Task <ActionResult <Letra> > Post([FromBody] LetraDTO model, [FromServices] MaiaContext context)
{
try
{
var letra = model.ToEntity();
context.Letras.Add(letra);
if (await context.SaveChangesAsync() > 0)
{
return(Created($"letras/id/{letra.Id}", letra));
}
return(BadRequest());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <List <Musica> > > GetByPopularity([FromServices] MaiaContext context)
{
try
{
return(await context.Letras
.Include(l => l.Musica)
.ThenInclude(m => m.Album)
.Include(l => l.Musica)
.ThenInclude(m => m.ArtistaMusicas)
.ThenInclude(am => am.Artista)
.OrderByDescending(l => l.QuantAcessos)
.Select(l => l.Musica)
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <Tab> > Post([FromBody] TabDTO dto, [FromServices] MaiaContext context)
{
try
{
var tab = dto.ToEntity();
context.Tabs.Add(tab);
if (await context.SaveChangesAsync() > 0)
{
return(Created($"tabs/id/{tab.Id}", tab));
}
return(BadRequest());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <object> > GetByPopularity([FromServices] MaiaContext context)
{
try
{
return(await context.Tabs
.Select(t => new
{
t.Titulo,
t.Id,
t.Instrumento,
t.Musica,
t.QuantAcessos
})
.OrderByDescending(t => t.QuantAcessos)
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <object> > Get([FromQuery] int musicaId, [FromServices] MaiaContext context)
{
if (musicaId == 0)
{
try
{
return(await context.Tabs
.OrderByDescending(t => t.QuantAcessos)
.Take(10)
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
else
{
try
{
return(await context.Tabs
.Where(t => t.MusicaId == musicaId)
.Select(t => new
{
t.Titulo,
t.Id,
t.Instrumento,
t.Musica
})
.ToListAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public async Task <ActionResult> Post([FromBody] PostDTO model, [FromServices] MaiaContext context)
{
if (ModelState.IsValid)
{
try
{
var post = model.ToEntity();
context.Add(post);
if (await context.SaveChangesAsync() > 0)
{
return(Created($"/posts/{post.Id}", post));
}
}
catch (Exception)
{
return(this.StatusCode(
StatusCodes.Status500InternalServerError, "Falha no banco de dados"
));
}
}
return(BadRequest());
}
public async Task <ActionResult <Post> > Edit([FromBody] Post post, [FromServices] MaiaContext context)
{
try
{
var usuarioId = int.Parse(
HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Sid).FirstOrDefault().Value
);
if (post.UsuarioId == usuarioId)
{
context.Posts.Update(post);
await context.SaveChangesAsync();
return(Ok(post));
}
return(Forbid());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <List <Letra> > > GetByMusicaId([FromServices] MaiaContext context, [FromQuery] int musicaId)
{
try
{
var letras = await context.Letras
.Where(l => l.MusicaId == musicaId)
.Include(l => l.Musica)
.ThenInclude(l => l.ArtistaMusicas)
.ThenInclude(l => l.Artista)
.ToListAsync();
foreach (var letra in letras)
{
letra.QuantAcessos += 1;
}
await context.SaveChangesAsync();
return(letras);
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult <Partitura> > GetById([FromRoute] int id, [FromServices] MaiaContext context)
{
try
{
var partitura = await context.Partituras
.Where(m => m.Id == id)
.Include(p => p.Musica)
.ThenInclude(m => m.ArtistaMusicas)
.ThenInclude(am => am.Artista)
.Include(p => p.Usuario)
.FirstOrDefaultAsync();
partitura.QuantAcessos++;
await context.SaveChangesAsync();
return(partitura);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <List <Artista> > > Get(
[FromQuery] PageParameters parameters, [FromServices] MaiaContext context, [FromQuery] string nome
)
{
if (nome != null)
{
try
{
return(Ok(
await context.Artistas
.FromSqlRaw($"SELECT * FROM maia.artistas WHERE Nome LIKE '%{nome}%' LIMIT 5")
.ToListAsync()
));
}
catch (Exception e)
{
throw e;
}
}
else
{
try
{
return(Ok(
await context.Artistas
.Skip((parameters.Page - 1) * parameters.Size)
.Take(parameters.Size)
.ToListAsync()
));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
}
public async Task <ActionResult <List <Comentario> > > Get([FromQuery] int postId, [FromServices] MaiaContext context)
{
try
{
return(await context.Comentarios.Where(c => c.PostId == postId)
.Include(c => c.Usuario).ToListAsync());
}
catch (Exception)
{
}
return(BadRequest());
}
public async Task <ActionResult> Delete([FromRoute] long id, [FromQuery] int postId, [FromServices] MaiaContext context)
{
if (postId == 0)
{
return(BadRequest());
}
try
{
Comentario comentario = new Comentario()
{
Id = id
};
var post = await context.Posts.Where(p => p.Id == postId).FirstOrDefaultAsync();
post.QuantCmt--;
context.Remove(comentario);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult <List <Post> > > GetByUsuarioId([FromRoute] int usuarioId, [FromServices] MaiaContext context)
{
try
{
return(await context.Posts
.Where(p => p.UsuarioId == usuarioId)
.Take(2)
.ToListAsync());
}
catch (Exception)
{
return(this.StatusCode(
StatusCodes.Status500InternalServerError, "Falha no banco de dados"
));
}
}
public async Task <ActionResult <List <Post> > > GetByTag([FromQuery] PageParameters pageParameters, [FromRoute] string tag, [FromServices] MaiaContext context)
{
try
{
return(await context.Posts
.FromSqlRaw($"SELECT * FROM maia.posts WHERE FIND_IN_SET('{tag}', Tags)")
.Include(p => p.Usuario)
.OrderByDescending(p => p.DataPub)
.Skip((pageParameters.Page - 1) * pageParameters.Size)
.Take(pageParameters.Size)
.ToListAsync());
}
catch (Exception)
{
return(this.StatusCode(
StatusCodes.Status500InternalServerError, "Falha no banco de dados"
));
}
}
public async Task <ActionResult <List <Post> > > GetAll([FromQuery] PageParameters pageParameters, [FromServices] MaiaContext context)
{
try
{
int size = pageParameters.Size;
int page = pageParameters.Page;
var usuarioId = int.Parse(User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid)?.Value);
var posts = await context.Posts
.Include(p => p.Usuario)
.OrderByDescending(p => p.DataPub)
.Skip((page - 1) * size)
.Take(size)
.ToListAsync();
foreach (var post in posts)
{
var like = await context.Favoritos.FirstOrDefaultAsync(
f => f.UsuarioId == usuarioId && f.PostId == post.Id && f.Ativo
);
// Por algum motivo apenas trazer esse comentário faz com que ele seja adicionado ao JSON.
await context.Comentarios
.Where(c => c.PostId == post.Id)
.FirstOrDefaultAsync();
if (like != null)
{
post.Favoritado = true;
}
// if (comentario != null)
// post.Comentarios.Add(comentario);
}
return(posts);
}
catch (Exception e)
{
Console.WriteLine(e);
return(this.StatusCode(
StatusCodes.Status500InternalServerError, "Falha no banco de dados"
));
}
}
