Exemple #1
0
        public async Task <ResponseMODEL> DeleteAsync(int id)
        {
            try
            {
                var resultProcess = await bookDAL.GetAsync(id);

                if (resultProcess.IsApproved)
                {
                    if ((Book)resultProcess.ObjectResult != null)
                    {
                        return(await bookDAL.DeleteAsync((Book)resultProcess.ObjectResult));
                    }
                    else
                    {
                        return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "No es posible eliminar el libro", "No existe un libro que coincida con el codigo enviado"));
                    }
                }
                else
                {
                    return(resultProcess);
                }
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #2
0
        public async Task <ResponseMODEL> GetAsync(int id)
        {
            try
            {
                using (LibraryContext db = new LibraryContext())
                {
                    var result = await db.Editorials.FindAsync(id);

                    return(ResponseMODEL.Instance(true, "Transaccion Exitosa", "Consulta exitosa a la tabla \"Editorial\"", null, result));
                }
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion. Ver detalle", ex.Message, ex));
            }
        }
Exemple #3
0
        public async Task <ResponseMODEL> DeleteAsync(Editorial model)
        {
            try
            {
                using (LibraryContext db = new LibraryContext())
                {
                    db.Editorials.Remove(model);
                    await db.SaveChangesAsync();
                }

                return(ResponseMODEL.Instance(true, "Transaccion Exitosa", "Editorial eliminada"));
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion. Ver detalle", ex.Message, ex));
            }
        }
Exemple #4
0
        public async Task <ResponseMODEL> UpdateAsync(Book model)
        {
            try
            {
                using (LibraryContext db = new LibraryContext())
                {
                    db.Entry(model).State = EntityState.Modified;
                    await db.SaveChangesAsync();
                }

                return(ResponseMODEL.Instance(true, "Transaccion Exitosa", "Libro modificado"));
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion. Ver detalle", ex.Message, ex));
            }
        }
Exemple #5
0
        public async Task <ResponseMODEL> InsertAsync(Book model)
        {
            try
            {
                using (LibraryContext db = new LibraryContext())
                {
                    db.Books.Add(model);
                    await db.SaveChangesAsync();
                }

                return(ResponseMODEL.Instance(true, "Transaccion Exitosa", "Libro registrado"));
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion. Ver detalle", ex.Message, ex));
            }
        }
Exemple #6
0
        public async Task <ResponseMODEL> UpdateAsync(AuthorMODEL model)
        {
            try
            {
                Author modelDAL = new Author();
                modelDAL.Email      = model.Email;
                modelDAL.BirthDate  = model.BirthDate;
                modelDAL.CityOrigin = model.CityOrigin;
                modelDAL.FullName   = model.FullName;
                modelDAL.IdAuthor   = model.IdAuthor;

                return(await authorDAL.UpdateAsync(modelDAL));
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #7
0
        public async Task <ResponseMODEL> GetByIdAuthorAsync(int id)
        {
            try
            {
                using (LibraryContext db = new LibraryContext())
                {
                    var result = await db.Books
                                 .Where(i => i.IdAuthor == id)
                                 .ToListAsync();

                    return(ResponseMODEL.Instance(true, "Transaccion Exitosa", "Consulta exitosa a la tabla \"Libros\"", null, result));
                }
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion. Ver detalle", ex.Message, ex));
            }
        }
Exemple #8
0
        public async Task <ResponseMODEL> UpdateAsync(EditorialMODEL model)
        {
            try
            {
                Editorial modelDAL = new Editorial();
                modelDAL.Email = model.Email;
                modelDAL.CorrespondenceAddress = model.CorrespondenceAddress;
                modelDAL.Phone = model.Phone;
                modelDAL.Name  = model.Name;
                modelDAL.MaximumBooksRegistered = model.MaximumBooksRegistered;
                modelDAL.IdEditorial            = model.IdEditorial;

                return(await editorialDAL.UpdateAsync(modelDAL));
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #9
0
        public async Task <ResponseMODEL> GetAllAsync()
        {
            try
            {
                var resultProcess = await bookDAL.GetAllAsync();

                if (resultProcess.IsApproved)
                {
                    List <Book> result = (List <Book>)resultProcess.ObjectResult;
                    if (result.Count == 0)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Lista Vacia", "La tabla \"Libros\" esta vacia", result));
                    }
                    else
                    {
                        var resultList = result.Select(i => new BookMODEL
                        {
                            IdBook      = i.IdBook,
                            Gender      = i.Gender,
                            IdAuthor    = i.IdAuthor,
                            IdEditorial = i.IdEditorial,
                            NumberPages = i.NumberPages,
                            Tittle      = i.Tittle,
                            Year        = i.Year
                        }
                                                       ).ToList();

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultList;
                    }
                }

                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #10
0
        public async Task <ResponseMODEL> GetAllAsync()
        {
            try
            {
                var resultProcess = await editorialDAL.GetAllAsync();

                if (resultProcess.IsApproved)
                {
                    List <Editorial> result = (List <Editorial>)resultProcess.ObjectResult;
                    if (result.Count == 0)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Lista Vacia", "La tabla \"Editorial\" esta vacia", result));
                    }
                    else
                    {
                        var resultList = result.Select(i => new EditorialMODEL
                        {
                            Email = i.Email,
                            CorrespondenceAddress = i.CorrespondenceAddress,
                            Phone = i.Phone,
                            Name  = i.Name,
                            MaximumBooksRegistered = i.MaximumBooksRegistered,
                            IdEditorial            = i.IdEditorial
                        }
                                                       ).ToList();

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultList;
                    }
                }


                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #11
0
        public async Task <ResponseMODEL> DeleteAsync(int id)
        {
            try
            {
                var resultProcess = await editorialDAL.GetAsync(id);

                var validateBooks = await bookDAL.GetByIdEditorialAsync(id);

                if (!validateBooks.IsApproved)
                {
                    return(resultProcess);
                }

                if (((List <Book>)validateBooks.ObjectResult).Count > 0)
                {
                    return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "Editorial con libros activos", "No puede eliminar una editorial si tiene libros activos"));
                }

                if (resultProcess.IsApproved)
                {
                    if ((Editorial)resultProcess.ObjectResult != null)
                    {
                        return(await editorialDAL.DeleteAsync((Editorial)resultProcess.ObjectResult));
                    }
                    else
                    {
                        return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "No es posible eliminar la editorial", "No existe una editorial que coincida con el codigo enviado"));
                    }
                }
                else
                {
                    return(resultProcess);
                }
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #12
0
        public async Task <ResponseMODEL> GetAllAsync()
        {
            try
            {
                var resultProcess = await authorDAL.GetAllAsync();

                if (resultProcess.IsApproved)
                {
                    List <Author> result = (List <Author>)resultProcess.ObjectResult;
                    if (result.Count == 0)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Lista Vacia", "La tabla \"Autor\" esta vacia", result));
                    }
                    else
                    {
                        var resultList = result.Select(i => new AuthorMODEL
                        {
                            Email      = i.Email,
                            BirthDate  = i.BirthDate,
                            CityOrigin = i.CityOrigin,
                            FullName   = i.FullName,
                            IdAuthor   = i.IdAuthor
                        }
                                                       ).ToList();

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultList;
                    }
                }


                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #13
0
        public async Task <ResponseMODEL> GetAsync(int id)
        {
            try
            {
                var resultProcess = await bookDAL.GetAsync(id);

                if (resultProcess.IsApproved)
                {
                    Book result = (Book)resultProcess.ObjectResult;
                    if (result == null)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Sin resultados", "No existen coincidencias con para esta consulta", result));
                    }
                    else
                    {
                        BookMODEL resultObject = new BookMODEL {
                            IdBook      = result.IdBook,
                            Gender      = result.Gender,
                            IdAuthor    = result.IdAuthor,
                            IdEditorial = result.IdEditorial,
                            NumberPages = result.NumberPages,
                            Tittle      = result.Tittle,
                            Year        = result.Year
                        };

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultObject;
                    }
                }

                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #14
0
        public async Task <ResponseMODEL> GetAsync(int id)
        {
            try
            {
                var resultProcess = await editorialDAL.GetAsync(id);

                if (resultProcess.IsApproved)
                {
                    Editorial result = (Editorial)resultProcess.ObjectResult;
                    if (result == null)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Sin resultados", "No existen coincidencias con para esta consulta", result));
                    }
                    else
                    {
                        EditorialMODEL resultObject = new EditorialMODEL
                        {
                            Email = result.Email,
                            CorrespondenceAddress = result.CorrespondenceAddress,
                            Phone = result.Phone,
                            Name  = result.Name,
                            MaximumBooksRegistered = result.MaximumBooksRegistered,
                            IdEditorial            = result.IdEditorial
                        };

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultObject;
                    }
                }

                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #15
0
        public async Task <ResponseMODEL> GetAsync(int id)
        {
            try
            {
                var resultProcess = await authorDAL.GetAsync(id);

                if (resultProcess.IsApproved)
                {
                    Author result = (Author)resultProcess.ObjectResult;
                    if (result == null)
                    {
                        return(ResponseMODEL.Instance(true, "Consulta Exitosa", "Sin resultados", "No existen coincidencias con para esta consulta", result));
                    }
                    else
                    {
                        AuthorMODEL resultObject = new AuthorMODEL
                        {
                            Email      = result.Email,
                            BirthDate  = result.BirthDate,
                            CityOrigin = result.CityOrigin,
                            FullName   = result.FullName,
                            IdAuthor   = result.IdAuthor
                        };

                        resultProcess.ObjectResult = null;
                        resultProcess.ObjectResult = resultObject;
                    }
                }

                return(resultProcess);
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }
Exemple #16
0
        public async Task <ResponseMODEL> UpdateAsync(BookMODEL model)
        {
            try
            {
                var validateEditorial = await editorialDAL.GetAsync(model.IdEditorial);

                if (!validateEditorial.IsApproved)
                {
                    return(validateEditorial);
                }

                Editorial editorial = (Editorial)validateEditorial.ObjectResult;

                if (editorial == null)
                {
                    return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "La editorial no está registrada", "Transaccion rechazada por regla de negocio"));
                }

                var validateAuthor = await authorDAL.GetAsync(model.IdAuthor);

                if (!validateAuthor.IsApproved)
                {
                    return(validateAuthor);
                }

                Author author = (Author)validateAuthor.ObjectResult;
                if (author == null)
                {
                    return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "El autor no está registrado", "Transaccion rechazada por regla de negocio"));
                }

                var limit = editorial.MaximumBooksRegistered;
                var validateBooksEditorial = await bookDAL.GetByIdEditorialAsync(model.IdEditorial);

                if (validateBooksEditorial.IsApproved)
                {
                    List <Book> booksEditorial = (List <Book>)validateBooksEditorial.ObjectResult;
                    if (booksEditorial.Count < limit || limit == -1)
                    {
                        Book modelDAL = new Book();
                        modelDAL.IdBook      = model.IdBook;
                        modelDAL.Tittle      = model.Tittle;
                        modelDAL.Year        = model.Year;
                        modelDAL.NumberPages = model.NumberPages;
                        modelDAL.Gender      = model.Gender;
                        modelDAL.IdAuthor    = model.IdAuthor;
                        modelDAL.IdEditorial = model.IdEditorial;

                        return(await bookDAL.UpdateAsync(modelDAL));
                    }
                    else
                    {
                        return(ResponseMODEL.Instance(false, "Transaccion Rechazada", "No es posible modificar el libro, se alcanzó el máximo permitido", "Transaccion rechazada por regla de negocio"));
                    }
                }
                else
                {
                    return(validateBooksEditorial);
                }
            }
            catch (Exception ex)
            {
                return(ResponseMODEL.Instance(false, "Error Controlado", "Se controlo un error en la aplicacion.", ex.Message, ex));
            }
        }