public async Task <IActionResult> AddNewAsync(LibroDTO libroDTO)
        {
            try
            {
                var exist = this.bibliotecaContext.Libros.FirstOrDefault(a => a.Nombre == libroDTO.Nombre && a.IdAutor == libroDTO.IdAutor);
                if (exist != null)
                {
                    return(this.BadRequest(new { error = $"Ya existe un libro con el nombre {libroDTO.Nombre}" }));
                }
                var autor = this.bibliotecaContext.Autors.FirstOrDefault(p => p.Id == libroDTO.IdAutor);
                if (autor == null)
                {
                    return(this.BadRequest(new { Error = $"No se encontro un autor con el id [{libroDTO.IdAutor}]" }));
                }

                await this.bibliotecaContext.Libros.AddAsync(new Libro
                {
                    IdAutor          = libroDTO.IdAutor,
                    Cantidad         = libroDTO.Cantidad,
                    FechaPublicacion = libroDTO.FechaPublicacion,
                    Nombre           = libroDTO.Nombre,
                });

                await this.bibliotecaContext.SaveChangesAsync();

                return(this.Ok());
            }
            catch (Exception)
            {
                return(this.BadRequest());
            }
        }
Example #2
0
        public async Task <LibroDTO> ActualizarLibro(int LibroId, LibroDTO libroDTO)
        {
            try
            {
                if (LibroId == libroDTO.Id)
                {
                    Libro libroDetalles = await _db.Libro.FindAsync(LibroId);

                    Libro libro = _mapper.Map <LibroDTO, Libro>(libroDTO, libroDetalles);
                    libro.Autor = "";
                    libro.FechaActualizacion = DateTime.Now;
                    var updateLibro = _db.Libro.Update(libro);
                    await _db.SaveChangesAsync();

                    return(_mapper.Map <Libro, LibroDTO>(updateLibro.Entity));
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception)
            {
                return(null);
            }
        }
        public async Task <ActionResult> PutLibro(int id, [FromBody] LibroDTO libroDTO)
        {
            var libro = await context.Libros.FirstOrDefaultAsync(x => x.Id == id);

            if (libro == null)
            {
                libro = new Libro()
                {
                    Titulo = libroDTO.Titulo, AutorId = libroDTO.AutorId, EditorialId = libroDTO.EditorialId,
                    TemaId = libroDTO.TemaId, Calificacion = libroDTO.Calificacion, Paginas = libroDTO.Paginas, Comentario = libroDTO.Comentario,
                    Fecha  = libroDTO.Fecha
                };
                context.Libros.Add(libro);
            }
            else
            {
                // libro = mapper.Map<Libro>(libroDTO);
                libro.Titulo       = libroDTO.Titulo;
                libro.AutorId      = libroDTO.AutorId;
                libro.Calificacion = libroDTO.Calificacion;
                libro.Comentario   = libroDTO.Comentario;
                libro.EditorialId  = libroDTO.EditorialId;
                libro.Fecha        = libroDTO.Fecha;
                libro.Paginas      = libroDTO.Paginas;
                libro.TemaId       = libroDTO.TemaId;
            }
            await context.SaveChangesAsync();

            return(Ok(libro));
        }
Example #4
0
 private Libro ConstructModel(LibroDTO data) => new Libro()
 {
     Titulo       = data.Titulo,
     Anno         = data.Anno,
     Generon      = data.Generon,
     IdAutor      = data.IdAutor,
     IdEditorial  = data.IdEditorial,
     NumeroPagina = data.NumeroPagina
 };
Example #5
0
        public async Task <ActionResult> Post(LibroDTO libroDTO)
        {
            var libro = mapped.Map <Libro>(libroDTO);

            context.Add(libro);
            await context.SaveChangesAsync();

            libroDTO = mapped.Map <LibroDTO>(libro);
            return(new CreatedAtRouteResult("SearchLibro", new { id = libro.Id }, libroDTO));
        }
        public async Task <ActionResult> Post([FromBody] LibroPostDTO entity)
        {
            Libro libro = mapper.Map <Libro>(entity);

            context.Add(libro);
            await context.SaveChangesAsync();

            LibroDTO libroDTO = mapper.Map <LibroDTO>(libro);

            return(new CreatedAtRouteResult("ObtenerLibro", new { id = libroDTO.Id }, libroDTO));
        }
Example #7
0
        public async Task <LibroDTO> AgregarLibro(LibroDTO libroDTO)
        {
            Libro libro = _mapper.Map <LibroDTO, Libro>(libroDTO);

            libro.FechaCreacion = DateTime.Now;
            libro.Autor         = "";
            var addLibro = await _db.Libro.AddAsync(libro);

            await _db.SaveChangesAsync();

            return(_mapper.Map <Libro, LibroDTO>(addLibro.Entity));
        }
Example #8
0
 public async Task <LibroDTO> ExisteNombreLibro(string Nombre)
 {
     try
     {
         LibroDTO libro = _mapper.Map <Libro, LibroDTO>(await _db.Libro.FirstOrDefaultAsync(x => x.Nombre.ToLower() == Nombre.ToLower()));
         return(libro);
     }
     catch (Exception)
     {
         return(null);
     }
 }
Example #9
0
 public async Task <LibroDTO> ObtenerLibro(int LibroId)
 {
     try
     {
         LibroDTO libro = _mapper.Map <Libro, LibroDTO>(await _db.Libro.FirstOrDefaultAsync(x => x.Id == LibroId));
         return(libro);
     }
     catch (Exception)
     {
         return(null);
     }
 }
        public async Task <ActionResult> Put(int id, [FromBody] LibroDTO LibroDTO)
        {
            var libro = mapper.Map <Autor>(LibroDTO);

            LibroDTO.Id = id;

            context.Entry(LibroDTO).State = EntityState.Modified;

            await context.SaveChangesAsync();

            return(NoContent());
        }
 public ActionResult Edit(LibroDTO libroDTO)
 {
     if (ModelState.IsValid)
     {
         bib = new Biblioteca();
         bool modificarOk = bib.modificarLibro(libroDTO);
         if (modificarOk == true)
         {
             return(RedirectToAction("Index"));
         }
     }
     return(View(libroDTO));
 }
 public ActionResult Create(LibroDTO libroDTO)
 {
     if (ModelState.IsValid)
     {
         bib = new Biblioteca();
         bool annadirOk = bib.annadirLibros(libroDTO);
         if (annadirOk == true)
         {
             return(RedirectToAction("Index"));
         }
     }
     return(View());
 }
Example #13
0
        public async Task <ActionResult <LibroDTO> > Get(int id)
        {
            Libro libro = await context.Libros.FirstOrDefaultAsync(x => x.Id == id && x.Activo);

            if (libro == null)
            {
                return(NotFound());
            }

            LibroDTO libroDTO = mapper.Map <LibroDTO>(libro);

            return(libroDTO);
        }
Example #14
0
        public async Task <ResponseBase <Libro> > Update(LibroDTO data)
        {
            var editorial = await LibroRepo.GetAsync(predicate : p => p.Id == data.Id);

            if (editorial == null)
            {
                return(new ResponseBase <Libro>(message: "Nose pudo actualizar el registro solicitado"));
            }

            editorial = ConstructModel(data);
            await LibroRepo.UpdateAsync(editorial);

            return(new ResponseBase <Libro>(message: "Solicitud Ok", data: editorial, count: 1));
        }
        public ActionResult Delete(long?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            bib = new Biblioteca();
            LibroDTO librosdto = bib.mostrarLibros(id ?? 0);

            if (librosdto == null)
            {
                return(HttpNotFound());
            }
            return(View(librosdto));
        }
 public IActionResult Create([FromBody] LibroDTO libroDTO)
 {
     try
     {
         var respEditorialViewModel = _libroService.Insert(libroDTO);
         return(Ok(respEditorialViewModel));
     }
     catch (ApplicationException ex)
     {
         return(BadRequest(ex));
     }
     catch (Exception ex)
     {
         return(BadRequest("Ha ocurrido un error inesperado"));
     }
 }
        public async Task <ActionResult> UpdateAutorAsync(int id, [FromBody] LibroDTO libroDTO)
        {
            if (libroDTO.IdLibro != id)
            {
                return(BadRequest(ModelState));
            }

            var libro = mapper.Map <Libro>(libroDTO);

            if (!await libroRepository.UpdateAsync(libro))
            {
                ModelState.AddModelError("Response", $"Ha ocurrido un error al intentar actualizar el libro {libroDTO.Titulo}");
                return(StatusCode(500, ModelState));
            }
            return(NoContent());
        }
        public async Task <ActionResult> CreateAutorAsync([FromBody] LibroDTO libroDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var libro = mapper.Map <Libro>(libroDTO);

            if (!await libroRepository.CreateAsync(libro))
            {
                ModelState.AddModelError(string.Empty, $"Ha ocurrido un error al intentar guardar el libro {libroDTO.Titulo}");
                return(StatusCode(500, ModelState));
            }

            return(CreatedAtRoute("GetBookAsync", new { id = libro.IdLibro }, libro));
        }
        private List <AutorDTO> MapLibroDTOAutores(Libro libro, LibroDTO libroDTO)
        {
            var resultado = new List <AutorDTO>();

            if (libro.AutoresLibros == null)
            {
                return(resultado);
            }

            foreach (var autorlibro in libro.AutoresLibros)
            {
                resultado.Add(new AutorDTO()
                {
                    Id     = autorlibro.AutorId,
                    Nombre = autorlibro.Autor.Nombre
                });
            }

            return(resultado);
        }
Example #20
0
        public async Task <ActionResult> Post([FromForm] LibroCreacionDTO libroCreacionDTO)
        {
            Libro libro = mapper.Map <Libro>(libroCreacionDTO);

            if (libroCreacionDTO.RutaLibro != null)
            {
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    await libroCreacionDTO.RutaLibro.CopyToAsync(memoryStream);

                    byte[] contenido = memoryStream.ToArray();
                    string extencion = Path.GetExtension(libroCreacionDTO.RutaLibro.FileName);
                    libro.Ruta = await almacenador.GuardarArchivo(contenido, extencion, contenedor, libroCreacionDTO.RutaLibro.ContentType);
                }
            }

            context.Add(libro);
            await context.SaveChangesAsync();

            LibroDTO libroDTO = mapper.Map <LibroDTO>(libro);

            return(new CreatedAtRouteResult("obtenerLibro", new { id = libroDTO.Id }, libroDTO));
        }
Example #21
0
        public async Task <ResponseBase <Libro> > Create(LibroDTO data)
        {
            var exist = await LibroRepo.GetAsync(predicate : p => p.Titulo == data.Titulo && p.IdAutor == data.IdAutor);

            var _libros = await LibroRepo.GetAllAsync(predicate : p => p.IdEditorial == data.IdEditorial);

            var editorial = await EditorialRepo.GetAsync(predicate : p => p.Id == data.IdEditorial);

            var autor = await AutorRepo.GetAsync(predicate : p => p.Id == data.IdAutor);


            if (exist != null)
            {
                return(new ResponseBase <Libro>(message: "Ya existe un Libros Registrado con Este Nombre y Este Autor", code: System.Net.HttpStatusCode.OK));
            }

            if (editorial == null)
            {
                return(new ResponseBase <Libro>(message: "La Editorial no está registrada", code: System.Net.HttpStatusCode.OK));
            }

            if (autor == null)
            {
                return(new ResponseBase <Libro>(message: "El Autor no está registrado", code: System.Net.HttpStatusCode.OK));
            }

            if (_libros.Count() >= editorial.LibrosRegistrado)
            {
                return(new ResponseBase <Libro>(message: "No es posible registrar el libro, se alcanzó el máximo permitido.", code: System.Net.HttpStatusCode.OK));
            }

            Libro libro = ConstructModel(data);

            await LibroRepo.AddAsync(libro);

            return(new ResponseBase <Libro>(message: "Solicitud Ok", data: libro, count: 1));
        }
Example #22
0
        public async Task <ActionResult> Put(int id, [FromBody] LibroDTO data)
        {
            var result = await business.Update(data);

            return(StatusCode(result.Code, result));
        }