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());
}
}
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));
}
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
};
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));
}
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));
}
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);
}
}
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());
}
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);
}
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);
}
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));
}
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));
}
public async Task <ActionResult> Put(int id, [FromBody] LibroDTO data)
{
var result = await business.Update(data);
return(StatusCode(result.Code, result));
}
