// Métodos EDITAR
public ActionResult Editar(int id)
{
this.ViewBag.TituloPagina = "Editar Editorial";
Editoriales editorial = this.db.Editoriales.Find(id);
return(View(editorial));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Nombre,Ciudad,Estado,Pais")] Editoriales editoriales)
{
if (id != editoriales.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(editoriales);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EditorialesExists(editoriales.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View($"{viewPath}/Edit", editoriales));
}
public ActionResult Agregar()
{
this.ViewBag.TituloPagina = "Agregar Editorial";
Editoriales editorial = new Editoriales();
return(View("Editar", editorial));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Sede")] Editoriales editorial)
{
if (id != editorial.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _client.Update(editorial);
}
catch
{
if (!EditorialesExists(editorial.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(editorial));
}
public async Task <IHttpActionResult> PutEditoriales(int id, Editoriales editoriales)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != editoriales.Id)
{
return(BadRequest());
}
db.Entry(editoriales).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EditorialesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <Editoriales> Post([FromBody] Editoriales editorial)
{
try
{
//Se agrega la entidad a la colección de la base de datos
db.editoriales.Add(editorial);
//Se ejecuta el almacenamiento de los campos en la base de datos para su inserción
await db.SaveChangesAsync();
return(editorial);
}
catch (Exception ex)
{
Exception ex1 = ex;
//Se recorre la excepción para realizar la búsqueda de las excepciones internas y determinar el mensaje de salida
while (ex1.InnerException != null)
{
ex1 = ex1.InnerException;
}
throw new Exception(ex1.Message);
}
}
public ActionResult Agregar(Editoriales editorial)
{
db.Editoriales.Add(editorial);
db.SaveChanges();
return(RedirectToAction("Listar"));
}
public ActionResult EditarEditorial(int id)
{
gestionLibrosEntities db = new gestionLibrosEntities();
Editoriales editorial = db.Editoriales.Find(id);
return(View(editorial));
}
public ActionResult Agregar(Libros libro, IEnumerable <int> autores, IEnumerable <int> editoriales, IEnumerable <int> generos)
{
foreach (int autorActual in autores)
{
Autores autor = db.Autores.Find(autorActual);
libro.Autores.Add(autor);
}
foreach (int editorialActual in editoriales)
{
Editoriales editorial = db.Editoriales.Find(editorialActual);
libro.Editoriales.Add(editorial);
}
foreach (int generoActual in generos)
{
Generos genero = db.Generos.Find(generoActual);
libro.Generos.Add(genero);
}
db.Libros.Add(libro);
db.SaveChanges();
return(RedirectToAction("JsonListar"));
}
public ActionResult RemoverEditorial(int id)
{
gestionLibrosEntities db = new gestionLibrosEntities();
Editoriales editorial = db.Editoriales.Find(id);
List <Libros> listaDb = db.Libros.ToList();
List <Libros> ListaRemover = new List <Libros>();
foreach (var item in listaDb)
{
if (item.id_editorial == id)
{
ListaRemover.Add(item);
}
}
foreach (var item in ListaRemover)
{
(db.Libros.Find(item)).id_editorial = null; ///ARREGLATE
}
db.Editoriales.Remove(editorial);
db.SaveChanges();
return(RedirectToAction("Listar"));
}
public ActionResult Editar(Libros book, IEnumerable <int> autores, IEnumerable <int> editoriales, IEnumerable <int> generos)
{
Libros libro = db.Libros.Find(book.Id);
libro.NombreLibro = book.NombreLibro;
libro.Isbn = book.Isbn;
libro.Idioma = book.Idioma;
libro.AñoEdicion = book.AñoEdicion;
libro.Autores.Clear();
libro.Generos.Clear();
libro.Editoriales.Clear();
foreach (int autorActual in autores)
{
Autores escritoPor = db.Autores.Find(autorActual);
libro.Autores.Add(escritoPor);
}
foreach (int generoActual in generos)
{
Generos g = db.Generos.Find(generoActual);
libro.Generos.Add(g);
}
foreach (int editorialActual in editoriales)
{
Editoriales e = db.Editoriales.Find(editorialActual);
libro.Editoriales.Add(e);
}
this.db.SaveChanges();
return(RedirectToAction("Listar"));
}
public ActionResult DeleteConfirmed(int id)
{
Editoriales editoriales = db.Editoriales.Find(id);
db.Editoriales.Remove(editoriales);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// Método Eliminar
public ActionResult Eliminar(int id)
{
Editoriales editorial = this.db.Editoriales.Find(id);
this.db.Editoriales.Remove(editorial);
this.db.SaveChanges();
return(RedirectToAction("Listar"));
}
public static int insertar(Editoriales editoriales)
{
using (var db = new BibliotecaEntities())
{
db.Editoriales.Add(editoriales);
db.SaveChanges();
return(editoriales.id);
}
}
public static int actualizar(Editoriales editoriales)
{
using (var db = new BibliotecaEntities())
{
var actual = db.Editoriales.Find(editoriales.id);
actual.nombre = editoriales.nombre;
return(db.SaveChanges());
}
}
public ActionResult Editar(Editoriales editorial)
{
Editoriales publisher = db.Editoriales.Find(editorial.Id);
publisher.NombreEditorial = editorial.NombreEditorial;
publisher.Pais = editorial.Pais;
publisher.Website = editorial.Website;
this.db.SaveChanges();
return(RedirectToAction("Listar"));
}
public ActionResult Edit([Bind(Include = "id_edit,desc_edit")] Editoriales editoriales)
{
if (ModelState.IsValid)
{
db.Entry(editoriales).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(editoriales));
}
public ActionResult Editar(Editoriales editorial)
{
if (this.ModelState.IsValid)
{
this.db.Editoriales.Add(editorial);
this.db.Entry(editorial).State = EntityState.Modified;
this.db.SaveChanges();
return(Content("Actualización de Editorial correcta."));
}
return(new HttpStatusCodeResult(500, "Error de Servidor."));
}
public async Task <IActionResult> Create([Bind("Id,Nombre,Sede")] Editoriales editorial)
{
if (ModelState.IsValid)
{
await _client.Create(editorial);
return(RedirectToAction(nameof(Index)));
}
return(View(editorial));
}
public async Task <IActionResult> Create([Bind("ID,Nombre,Ciudad,Estado,Pais")] Editoriales editoriales)
{
if (ModelState.IsValid)
{
_context.Add(editoriales);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View($"{viewPath}/Create", editoriales));
}
public async Task <IHttpActionResult> GetEditoriales(int id)
{
Editoriales editoriales = await db.Editoriales.FindAsync(id);
if (editoriales == null)
{
return(NotFound());
}
return(Ok(editoriales));
}
public ActionResult Create([Bind(Include = "id_edit,desc_edit")] Editoriales editoriales)
{
if (ModelState.IsValid)
{
db.Editoriales.Add(editoriales);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(editoriales));
}
public async Task <IHttpActionResult> PostEditoriales(Editoriales editoriales)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Editoriales.Add(editoriales);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = editoriales.Id }, editoriales));
}
public async Task <Editoriales> Delete(int id)
{
try
{
//Se realiza la búsqueda de la información a eliminar
Editoriales patch = await db.editoriales.Include(x => x.Libros).Where(x => x.Id == id).FirstOrDefaultAsync();
if (patch == default(Editoriales))
{
//En caso de no encontrar el registro se genera una excepción para informar al usuario
throw new CustomException("El registro que intenta eliminar ya no se encuentra en la base de datos, por favor refresque la ventana e intentelo de nuevo");
}
//Se valida que no tenga relaciones
if (patch.Libros.Count > 0)
{
StringBuilder libros = new StringBuilder();
//Se mapean los libros relacionados
foreach (Libros libro in patch.Libros)
{
libros.AppendLine("<li>" + libro.Titulo + "</li>");
}
//Se genera excepción de tipo "Custom Exception" para su debida interpretación por el manejador
throw new CustomException("<p>No es posible eliminar la editorial ya que tiene libros relacionados, por favor elimine la relación entre los libros y la editorial seleccionada para continuar. Los libros relacionados son los siguientes:</p><ul>" + libros.ToString() + "</ul>");
}
//En caso de pasar la validación se elimina la entidad de la colección
db.editoriales.Remove(patch);
//Se ejecuta el almacenamiento de los campos en la base de datos para su eliminación
await db.SaveChangesAsync();
return(patch);
}
catch (CustomException ex)
{
//En caso de encontrar una excepción de tipo "CustomException" se retorna la excepción tal cual para la interpretación del manejador
throw ex;
}
catch (Exception ex)
{
Exception ex1 = ex;
//Se recorre la excepción para realizar la búsqueda de las excepciones internas y determinar el mensaje de salida
while (ex1.InnerException != null)
{
ex1 = ex1.InnerException;
}
throw new Exception(ex1.Message);
}
}
public async Task <Editoriales> Update(Editoriales editorial)
{
var response = await WebUtilities.ConectAsync(WebUtilities.Method.Post, _urls.BooksService, UrlsConfig.EditorialesOperations.Update(), editorial);
if (response.IsSuccessStatusCode)
{
return(WebUtilities.ValidateContent(response).ToEntitySimple <Editoriales>());
}
else
{
throw new Exception($"HttpException: {Environment.NewLine} StatusCode: {Convert.ToInt16(response.StatusCode)}, {Environment.NewLine} Messege: {WebUtilities.ValidateContent(response)}");
}
}
public async Task <IHttpActionResult> DeleteEditoriales(int id)
{
Editoriales editoriales = await db.Editoriales.FindAsync(id);
if (editoriales == null)
{
return(NotFound());
}
db.Editoriales.Remove(editoriales);
await db.SaveChangesAsync();
return(Ok(editoriales));
}
// GET: Editoriales/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Editoriales editoriales = db.Editoriales.Find(id);
if (editoriales == null)
{
return(HttpNotFound());
}
return(View(editoriales));
}
public bool AgregarEditorial(string Nombre)
{
var result = false;
Editoriales oEditorial = new Editoriales(Nombre);
/*if(ListaEditoriales.BuscarEditorial(Nombre)==null)
* {
*
* }*/
ListaEditoriales.AgregarEditorial(oEditorial);
result = true;
return(result);
}
public ActionResult Nuevo(string Nombre)
{
gestionLibrosEntities db = new gestionLibrosEntities();
Editoriales editorial = new Editoriales();
editorial.Nombre = Nombre;
db.Editoriales.Add(editorial);
db.SaveChanges();
return(RedirectToAction("Listar"));
}
public ActionResult Eliminar(int id)
{
this.ViewBag.Titulo = "Eliminar Libro";
Editoriales editorial = this.db.Editoriales.Find(id);
var librosEliminar = editorial.Libros.ToList();
foreach (var lib in librosEliminar)
{
db.Libros.Remove(lib);
}
this.db.Editoriales.Remove(editorial);
this.db.SaveChanges();
return(RedirectToAction("Listar"));
}
