コード例 #1
0
        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
                }));
            }
        }
コード例 #2
0
        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 }));
            }
        }
コード例 #3
0
        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
                    }));
                }
            }
        }
コード例 #4
0
        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
                    }));
                }
            }
        }
コード例 #5
0
        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);
            }
        }
コード例 #6
0
        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
                    }));
                }
            }
        }
コード例 #7
0
        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
                    }));
                }
            }
        }
コード例 #8
0
        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." }));
        }
コード例 #9
0
        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();
        }
コード例 #10
0
        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
                    }));
                }
            }
        }