public async Task <RequestBook> ResponseRequest(RequestBook objRequestBook)
{
_LibraryDBContext.RequestBooks.Update(objRequestBook);
await _LibraryDBContext.SaveChangesAsync();
return(objRequestBook);
}
public RequestBook AddBook(RequestBook book)
{
if (!ValidationEditorialOrAuthor(value: book.AuthorId))
{
throw new Exception("El autor no está registrado");
}
if (!ValidationEditorialOrAuthor(value: book.EditorialId))
{
throw new Exception("La editorial no está registrada");
}
if (!ValidationNewBook(model: book))
{
throw new Exception("No es posible registrar el libro, se alcanzó el máximo permitido.");
}
context.Books.Add(new Entities.Books
{
Id = 0,
AuthorId = book.AuthorId,
EditorialId = book.EditorialId,
Genre = book.Genre,
Title = book.Title,
NumberPage = book.NumberPage,
Year = book.Year
});
context.SaveChanges();
return(book);
}
public void DeleteBook(RequestBook book)
{
var existingBook = context.Books.Find(book.Id);
context.Books.Remove(existingBook);
context.SaveChanges();
}
public ActionResult DeleteConfirmed(int id)
{
RequestBook requestBook = db.RequestBooks.Find(id);
db.RequestBooks.Remove(requestBook);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task InsertRequestBook(RequestBook requestBook)
{
using var conn = _connectionFactory.GetConnection;
var query = $"InsertRequestBook";
var para = new DynamicParameters();
para.Add("@Details", requestBook.DetailsDT.AsTableValuedParameter("UT_RequestBook"));
await conn.QueryFirstOrDefaultAsync <RequestBook>(query, para, commandType : CommandType.StoredProcedure);
}
public ActionResult Edit([Bind(Include = "Id,MemberId,BookTitleRQ,AuthorBookRQ,PublisherBookRQ,RequestDate,Note")] RequestBook requestBook)
{
if (ModelState.IsValid)
{
db.Entry(requestBook).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.MemberId = new SelectList(db.Members, "Id", "Name", requestBook.MemberId);
return(View(requestBook));
}
public ActionResult Create(RequestBook requestBook)
{
if (ModelState.IsValid)
{
db.RequestBooks.Add(requestBook);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//ViewBag.MemberId = new SelectList(db.Members, "Id", "UserName", requestBook.MemberId);
return(View(requestBook));
}
// POST: odata/RequestBooks
public IHttpActionResult Post(RequestBook requestBook)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.RequestBooks.Add(requestBook);
db.SaveChanges();
return(Created(requestBook));
}
public async Task <IActionResult> CancelRequest(RequestBook objRequestBook)
{
if (objRequestBook.Action == null)
{
objRequestBook.Action = false;
await _libraryRepository.CancelRequest(objRequestBook);
}
else
{
return(BadRequest("You Already Cancelled Book Request !!!"));
}
return(Ok("Successfully Cancelled."));
}
public async Task <IActionResult> ResponseRequest(RequestBook objRequestBook)
{
if (objRequestBook.Action == null)
{
objRequestBook.Action = true;
await _libraryRepository.ResponseRequest(objRequestBook);
}
else
{
return(BadRequest("You Already Approved Book Request !!!"));
}
return(Ok("Successfully Approved"));
}
public ActionResult Post([FromBody] RequestBook book)
{
try
{
bookData.AddBook(book);
return(Created($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{HttpContext.Request.Path}/{book.Id}",
book));
}
catch (Exception ex)
{
return(BadRequest(ex.Message.Contains("inner") ? ex.InnerException.Message : ex.Message));
}
}
// GET: RequestBooks/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RequestBook requestBook = db.RequestBooks.Find(id);
if (requestBook == null)
{
return(HttpNotFound());
}
return(View(requestBook));
}
// DELETE: odata/RequestBooks(5)
public IHttpActionResult Delete([FromODataUri] int key)
{
RequestBook requestBook = db.RequestBooks.Find(key);
if (requestBook == null)
{
return(NotFound());
}
db.RequestBooks.Remove(requestBook);
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent));
}
public RequestBook EditBook(RequestBook book)
{
var existingBook = GetBook(book.Id);
existingBook.Year = book.Year;
existingBook.Title = book.Title;
existingBook.NumberPage = book.NumberPage;
existingBook.EditorialId = book.EditorialId;
existingBook.AuthorId = book.AuthorId;
existingBook.Genre = book.Genre;
context.Entry(existingBook).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
context.SaveChanges();
return(existingBook);
}
// GET: RequestBooks/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RequestBook requestBook = db.RequestBooks.Find(id);
if (requestBook == null)
{
return(HttpNotFound());
}
ViewBag.MemberId = new SelectList(db.Members, "Id", "Name", requestBook.MemberId);
return(View(requestBook));
}
public ActionResult Put([FromBody] RequestBook book)
{
try
{
var existingBook = bookData.GetBook(book.Id);
if (existingBook != null)
{
bookData.EditBook(book);
}
return(Ok(book));
}
catch (Exception ex)
{
return(BadRequest(ex.Message.Contains("inner") ? ex.InnerException.Message : ex.Message));
}
}
private bool ValidationNewBook(RequestBook model)
{
var maxBooksByEditorial = context.Editorials.Where(editorial => editorial.Id == model.EditorialId).FirstOrDefault().MaxBook;
if (maxBooksByEditorial < 0)
{
return(true);
}
var numberBooksByAuthor = (context.Books.Where(book => book.EditorialId == model.EditorialId)).Count();
if (maxBooksByEditorial > numberBooksByAuthor)
{
return(true);
}
return(false);
}
public RespnseBook AddBook(RequestBook book)
{
try
{
string ImageUrl = "";
if (book.BookImage != null)
{
ImageUrl = cloudinary.UploadImage(book.BookName, book.BookImage);
}
responseBook = new RespnseBook
{
BookName = book.BookName,
BookDiscription = book.BookDiscription == null ? "" : book.BookDiscription,
BookPrice = book.BookPrice,
BookImage = ImageUrl,
AuthorName = book.AuthorName,
Quantity = book.Quantity
};
var result = bookManagementRL.AddBook(responseBook);
responseBook = new RespnseBook
{
BookID = result.BookID,
BookDiscription = result.BookDiscription,
BookImage = result.BookImage,
BookName = result.BookName,
BookPrice = result.BookPrice,
AuthorName = result.AuthorName,
InCart = result.InCart,
InStock = result.InStock,
Quantity = result.Quantity
};
return(result);
}
catch (Exception)
{
throw;
}
}
public int InsertRequestBook(RequestBookViewModel model, int id)
{
RequestBook book = new RequestBook();
book.Author = model.Author;
book.point = model.point;
book.Title = model.Tittle;
book.userId = id;
try
{
db.RequestBook.Add(book);
db.SaveChanges();
return(1);
}
catch
{
return(0);
}
}
public IActionResult AddBook([FromForm] RequestBook Book)
{
if (Book == null)
{
return(BadRequest("Book is null."));
}
try
{
var identity = User.Identity as ClaimsIdentity;
if (identity != null)
{
RespnseBook book = bookManagementBL.AddBook(Book);
if (book != null)
{
return(Ok(new { success = true, Message = "book added", book }));
}
}
return(BadRequest(new { success = false, Message = "book adding Unsuccessful" }));
}
catch (Exception exception)
{
return(BadRequest(new { success = false, exception.Message }));
}
}
// PUT: odata/RequestBooks(5)
public IHttpActionResult Put([FromODataUri] int key, Delta <RequestBook> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RequestBook requestBook = db.RequestBooks.Find(key);
if (requestBook == null)
{
return(NotFound());
}
patch.Put(requestBook);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RequestBookExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(requestBook));
}
public async Task <IActionResult> InsertRequest()
{
try
{
RequestBook objRequestBook = new RequestBook();
objRequestBook.CollegeRollNo = HttpContext.Request.Form["collegeRollNo"];
objRequestBook.FirstName = HttpContext.Request.Form["FirstName"];
objRequestBook.LastName = HttpContext.Request.Form["LastName"];
objRequestBook.DepartmentName = HttpContext.Request.Form["Department"];
objRequestBook.Email = HttpContext.Request.Form["Email"];
objRequestBook.BookName = HttpContext.Request.Form["BookName"];
objRequestBook.BookId = HttpContext.Request.Form["BookId"];
objRequestBook.BookAuthor = HttpContext.Request.Form["AuthorName"];
objRequestBook.IssueDate = Convert.ToDateTime(HttpContext.Request.Form["IssueDate"]);
objRequestBook.DueDate = Convert.ToDateTime(objRequestBook.IssueDate.Value.AddDays(7).ToString("yyyy/MM/dd"));
await _libraryRepository.InsertRequest(objRequestBook);
return(Ok("Successfully Requested"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> UploadRequestExcel()
{
try
{
var file = HttpContext.Request.Form.Files[0];
var uploadPath = Path.Combine(_webHostEnvironment.ContentRootPath, "Files", "Request Book");
var ext = Path.GetExtension(file.FileName)?.ToLower();
var extensions = new string[] { ".xls", ".xlsx" };
var flag = false;
foreach (var item in extensions)
{
if (item != ext)
{
continue;
}
flag = true;
break;
}
if (!flag)
{
throw new Exception("Not a valid extension !");
}
var fileName = DateTime.UtcNow.AddMinutes(345).ToString("yyyyMMddhhmmssfff") + ext;
await using var ms = new MemoryStream();
await file.CopyToAsync(ms);
var package = new ExcelPackage(ms);
var workbook = package.Workbook;
var worksheet = workbook.Worksheets.FirstOrDefault(x => x.Name == "Request_Book");
if (worksheet is null)
{
throw new Exception("A worksheet with name Request Book cannot be found!");
}
var rows = worksheet.Dimension.Rows;
var columns = worksheet.Dimension.Columns;
if (rows <= 1 || columns <= 1)
{
throw new Exception("Unable to find data!");
}
var dt = new DataTable();
for (var row = 1; row <= 1; row++)
{
for (var col = 1; col <= columns; col++)
{
dt.Columns.Add(worksheet.Cells[row, col].Value.ToString()?.Trim());
}
}
for (var row = 2; row <= rows; row++)
{
var dr = dt.NewRow();
for (var col = 1; col <= columns; col++)
{
dr[col - 1] = worksheet.Cells[row, col].Value.ToString()?.Trim();
}
dt.Rows.Add(dr);
}
var requestBooks = new RequestBook();
requestBooks.DetailsDT = dt;
await _libraryRepository.InsertRequestBook(requestBooks);
var filePath = Path.Combine(uploadPath, fileName);
await using var fileStream = new FileStream(filePath, FileMode.Create);
await file.CopyToAsync(fileStream);
return(Ok("Save Changes Successfully"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task InsertRequest(RequestBook requestBook)
{
await _LibraryDBContext.RequestBooks.AddAsync(requestBook);
await _LibraryDBContext.SaveChangesAsync();
}
public async Task CancelRequest(RequestBook objRequestBook)
{
_LibraryDBContext.RequestBooks.Update(objRequestBook);
await _LibraryDBContext.SaveChangesAsync();
}
