public async Task <ActionResult <Manga_Capitulo_Pagina> > AgregarPaginas([FromBody] Manga_Capitulo_Pagina paginas, [FromForm] IFormFile pagina)
{
try
{
if (pagina == null)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = StatusCodes.Status400BadRequest, Mensaje = "Pagina invalida"
}));
}
MemoryStream ms = new MemoryStream();
pagina.CopyTo(ms);
paginas.Pagina = ms.ToArray();
_context.Manga_Capitulo_Paginas.Add(paginas);
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status201Created, Mensaje = "Pagina subida exitosamente", Dato = paginas
}));
}
catch (Exception ex)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = ex.HResult, Mensaje = ex.Message
}));
}
}
public async Task <ActionResult <Anime_Favorito> > CrearAnime_Favoritos([FromBody][Bind("animeId")] int animeId)
{
try
{
Claim correo = User.Claims.FirstOrDefault(c => c.Type == "Email");
if (correo != null)
{
Usuario usuario = await _userManager.FindByEmailAsync(correo.Value);
Anime_Favorito af = new Anime_Favorito()
{
Usuario = usuario,
Anime = _context.Animes.Find(animeId),
Favorito = true
};
_context.Add(af);
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat {
Estado = StatusCodes.Status201Created, Mensaje = "Anime favorito agregado", Dato = af.Favorito
}));
}
return(Unauthorized(new ApiResponseFormat {
Estado = StatusCodes.Status401Unauthorized, Mensaje = "Inicie sesion para usar esta opcion."
}));
}
catch (DbUpdateException ex)
{
return(StatusCode(ex.HResult, new { Result = ex.HResult, Data = ex.Message }));
}
}
public async Task <IActionResult> Edit(int mangaId, [FromBody] MangaEditarViewModel mangas)
{
if (mangaId != mangas.MangaId)
{
return(NotFound(new ApiResponseFormat()
{
}));
}
Manga editado = await _context.Mangas.Include(m => m.Generos).ThenInclude(g => g.Genero).Include(m => m.Capitulos).FirstOrDefaultAsync(a => a.MangaId == mangas.MangaId);
editado.Nombre = mangas.Nombre;
editado.Descripcion = mangas.Descripcion;
editado.Fecha_publicacion = mangas.Fecha_publicacion;
if (mangas.Portada != null)
{
MemoryStream ms = new MemoryStream();
mangas.Portada.CopyTo(ms);
editado.Portada = ms.ToArray();
}
await AniadirGeneros(editado, mangas.GenerosActivos.Where(ga => ga.Activo).Select(ga => ga.Genero).ToList());
try
{
_context.Update(editado);
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Mensaje = $"Manga {editado.Nombre} modificado con exito", Dato = editado
}));
}
catch (DbUpdateConcurrencyException ex)
{
if (!MangaExists(mangas.MangaId))
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status404NotFound, Mensaje = "Manga invalido"
}));
}
else
{
return(BadRequest(new ApiResponseFormat()
{
Estado = ex.HResult, Mensaje = ex.Message
}));
}
}
}
public async Task <ActionResult <Anime_Episodio> > ModificarAnime_Episodio(int id, [FromBody] Anime_EpisodioEditarViewModel anime_Episodio)
{
if (id != anime_Episodio.EpisodioId)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = StatusCodes.Status400BadRequest, Mensaje = "Identificador de episodio invalido"
}));
}
Anime_Episodio editado = _context.Anime_Episodios.Include(a => a.UrlServidores).Include(e => e.Anime).FirstOrDefault(e => e.EpisodioId == anime_Episodio.EpisodioId);
editado.Titulo_episodio = anime_Episodio.Titulo_episodio;
editado.Numero_episodio = anime_Episodio.Numero_episodio;
editado.UrlServidores = anime_Episodio.UrlServidores;
if (!string.IsNullOrEmpty(anime_Episodio.Nombre_Archivo))
{
editado.Nombre_archivo = anime_Episodio.Nombre_Archivo;
}
_context.Entry(editado).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Mensaje = "Episodio modificado", Dato = editado
}));
}
catch (DbUpdateConcurrencyException ex)
{
if (!Anime_EpisodioExists(id))
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status404NotFound, Mensaje = "Episodio no encontrado"
}));
}
else
{
return(StatusCode(StatusCodes.Status304NotModified, new ApiResponseFormat()
{
Estado = StatusCodes.Status304NotModified, Mensaje = ex.Message
}));
}
}
}
public async Task <bool> ValidateToken(string id)
{
try
{
var tokeninfo = await _context.UsuariosTokens.Where(ut => ut.UsuarioId == id).OrderByDescending(ut => ut.Fecha_Creacion).FirstOrDefaultAsync();
if (tokeninfo == null)
{
return(false);
}
if (DateTime.UtcNow >= tokeninfo.Fecha_Expiracion)
{
tokeninfo.Valido = false;
_context.UsuariosTokens.Update(tokeninfo);
await _context.SaveChangesAsync();
}
return(tokeninfo.Valido);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> EditarManga_Capitulo(int?id, [FromBody] Manga_CapituloEditarViewModel manga)
{
if (id == null)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = StatusCodes.Status400BadRequest, Mensaje = "Capitulo invalido"
}));
}
Manga_Capitulo editado = _context.Manga_Capitulos.Find(id);
editado.Nombre_capitulo = manga.Nombre_capitulo;
editado.Numero_capitulo = manga.Numero_capitulo;
editado.Fecha_publicacion = manga.Fecha_publicacion;
editado.Paginas = manga.Paginas;
_context.Entry(editado).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Mensaje = $"Capitulo {editado.Nombre_capitulo} editado con exito", Dato = editado
}));
}
catch (DbUpdateConcurrencyException ex)
{
if (!Manga_CapituloExists((int)id))
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status304NotModified, Mensaje = "Capitulo invalido"
}));
}
else
{
return(BadRequest(new ApiResponseFormat()
{
Estado = StatusCodes.Status400BadRequest, Mensaje = ex.Message
}));
}
}
}
public async Task <IActionResult> EditarGeneros(int id, [FromBody][Bind("GeneroId,Nombre")] Genero generos)
{
if (id != generos.GeneroId)
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status404NotFound, Mensaje = "Error al conseguir el genero deseado"
}));
}
if (_context.Generos.Any(g => g.Nombre.ToLower() == generos.Nombre.ToLower() && g.GeneroId != id))
{
return(Conflict(new ApiResponseFormat()
{
Estado = StatusCodes.Status409Conflict, Mensaje = $"El genero {generos.Nombre} ya existe."
}));
}
_context.Entry(generos).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Mensaje = $"Genero {generos.Nombre} modificado exitosamente.", Dato = generos
}));
}
catch (DbUpdateConcurrencyException ex)
{
if (!GenerosExists(id))
{
return(NotFound(new { result = "Error al modificar el genero deseado" }));
}
else
{
return(StatusCode(StatusCodes.Status304NotModified, new ApiResponseFormat {
Estado = StatusCodes.Status304NotModified, Mensaje = ex.Message
}));
}
}
}
public async Task <ActionResult <Manga_Favorito> > PostManga_Favoritos(int mangaId)
{
Claim correo = User.Claims.FirstOrDefault(c => c.Type == "Email");
if (correo != null)
{
Usuario usuario = await _userManager.FindByEmailAsync(correo.Value);
Manga manga = _context.Mangas.Find(mangaId);
Manga_Favorito af = new Manga_Favorito()
{
Usuario = usuario,
Manga = manga,
Favorito = true
};
try
{
_context.Add(af);
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status201Created, Mensaje = $"{manga.Nombre} agregado a favoritos", Dato = af.Favorito
}));
}
catch (Exception ex)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = ex.HResult, Mensaje = ex.Message
}));
}
}
return(Unauthorized(new { Result = StatusCodes.Status401Unauthorized, Data = "Inicie sesion para usar esta opcion." }));
}
private async Task GuardarToken(LoginUserToken userinfo)
{
var Fecha_Creacion = DateTime.UtcNow;
var Fecha_Expiracion = Fecha_Creacion.AddDays(7);
UsuarioToken guardartoken = new UsuarioToken()
{
Fecha_Creacion = Fecha_Creacion,
Fecha_Expiracion = Fecha_Expiracion,
Token = userinfo.Token,
UsuarioId = userinfo.Id,
Valido = true
};
await _context.UsuariosTokens.AddAsync(guardartoken);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> ModificarAnime(int id, [FromBody] AnimeEditarViewModel anime)
{
if (id != anime.AnimeId)
{
return(BadRequest(new ApiResponseFormat()
{
Estado = StatusCodes.Status400BadRequest, Mensaje = $"Los Ids no coinciden {id} y {anime.AnimeId}"
}));
}
Anime modificado = await _context.Animes.Include(a => a.Generos).ThenInclude(g => g.Genero).Include(a => a.Episodios).FirstOrDefaultAsync(a => a.AnimeId == anime.AnimeId);
modificado.Nombre = anime.Nombre;
modificado.Numero_episodios = anime.Numero_episodios;
modificado.Descripcion = anime.Descripcion;
modificado.Fecha_publicacion = anime.Fecha_publicacion;
string mensajePortadaInvalida = ".";
if (anime.Portada != null)
{
if (FormFileExtensions.IsImage(anime.Portada))
{
MemoryStream ms = new MemoryStream();
anime.Portada.CopyTo(ms);
modificado.Portada = ms.ToArray();
}
else
{
mensajePortadaInvalida = " pero el formato de imagen invalido, se pondra la imagen de portada default.";
}
}
await AniadirGeneros(modificado, anime.GenerosActivos.Where(ga => ga.Activo).Select(ga => ga.Genero).ToList());
_context.Entry(modificado).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Mensaje = $"Anime {modificado.Nombre} modificado exitosamente{mensajePortadaInvalida}", Dato = anime
}));
}
catch (DbUpdateConcurrencyException ex)
{
if (!AnimeExists(id))
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status404NotFound, Mensaje = $"No se encontro ningun anime con el Id {id}"
}));
}
else
{
return(StatusCode(StatusCodes.Status304NotModified, new ApiResponseFormat()
{
Estado = StatusCodes.Status304NotModified, Mensaje = ex.Message
}));
}
}
}
