public void DeleteBorrowRequest(BorrowRequest request)
{
MediaLibContainer context = ContextHelper <MediaLibContainer> .GetCurrentContext();
context.BorrowRequestSet.DeleteObject(request);
context.SaveChanges();
}
/// <summary>
/// Submits borrow request to borrowRequsts table in database
/// </summary>
/// <param name="id"> Movie id </param>
/// <returns> Task </returns>
public async Task <IActionResult> OnPostAsync(long?id)
{
// Retrieve the movie user wants to borrow
var borrowedMovie = await Context.Movie.FirstOrDefaultAsync(m => m.ID == id);
// Check in borrowRequests table if such request already exists and that is active
var checkDuplicates = await Context.BorrowRequest.FirstOrDefaultAsync(m => m.Title == borrowedMovie.Title &&
m.UserID == AuthenticatedUserInfo.ObjectIdentifier &&
m.RequestStatus != "Expired - Movie Returned");
// If active request exists tell the user that their previous request is pending approva
if (checkDuplicates != null && checkDuplicates.RequestStatus != "Declined")
{
return(RedirectToPage("./WarningPage"));
}
// Assamble borrow request
BorrowRequest = new BorrowRequest
{
Title = borrowedMovie.Title,
Category = borrowedMovie.Category,
RequestDate = DateTime.UtcNow,
SharedWithFirstName = AuthenticatedUserInfo.FirstName,
SharedWithLastName = AuthenticatedUserInfo.LastName,
UserID = AuthenticatedUserInfo.ObjectIdentifier,
SharedwithEmailAddress = AuthenticatedUserInfo.EmailAddress,
RequestStatus = "Review Pending"
};
// Add request to Borrow Request Table
Context.BorrowRequest.Add(BorrowRequest);
await Context.SaveChangesAsync();
return(RedirectToPage("./Index"));
}
public void RequestBorrowBook(string borrower, string lender, Guid bookId)
{
if (borrower == null || lender == null || bookId == null || borrower == lender)
{
throw new Exception("Cannot make request");
}
using (var context = new ApplicationDbContext())
{
UsersBooks userbook = context.UsersBooks.FirstOrDefault(x => x.BookId == bookId && x.UserId == lender);
if (userbook == null)
{
throw new Exception("User does not own this book");
}
if (userbook.Borrowed || userbook.Lent)
{
throw new Exception("Book is borrowed or lent, cannot make request");
}
BorrowRequest request = new BorrowRequest()
{
BookId = bookId,
BorrowerId = borrower,
LenderId = lender
};
context.BorrowRequests.Add(request);
context.SaveChanges();
}
}
public static BorrowRequestDTO ToDTO(this BorrowRequest model, BookDTO book, UserDTO user)
{
return(model == null ? null : new BorrowRequestDTO()
{
Book = book,
Borrower = user
});
}
public async Task <Borrows> Borrowed(BorrowRequest borrowRequest)
{
if (!_repository.CopyAvailable(borrowRequest.Copyid))
{
return(new Borrows());
}
var borrowInfo = await _repository.BorrowTransaction(borrowRequest);
return(borrowInfo);
}
public ItemShare RequestBorrow(BorrowRequest request)
{
if (null == request)
{
throw new ArgumentNullException("request");
}
var userId = User.Identifier();
return(this.borrow.Request(request, userId));
}
public bool ApproveRequest(BorrowRequest request)
{
if (request.GetNumberOfDays() <= Supervisor.GetMaxDayCanAprove())
{
return(true);
}
else
{
return(false);
}
}
public void BorrowRequestUserMedia(string usernameTo, T media)
{
BorrowRequest request = new BorrowRequest();
request.User = media.User;
request.UserMedia = media;
request.UserTo = usernameTo;
media.User.BorrowRequest.Add(request);
Save();
}
public async Task <ActionResult <BorrowRequest> > PostBorrowRequests(BorrowRequest borrowRequest)
{
if (_context.BorrowDetails.Count() > 5)
{
return(BadRequest("Khong the lay tren 5 quyen"));
}
_context.BorrowRequests.Add(borrowRequest);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBorrowRequests", new { id = borrowRequest.BorrowRequestId }, borrowRequest));
}
public BorrowRequest CreateBorrowRequest(BorrowRequestDTO borrowRequestDTO)
{
var entity = new BorrowRequest
{
UserId = borrowRequestDTO.UserId,
Status = "Waiting",
CreatedDate = DateTime.Now
};
_repository.Insert(entity);
return(entity);
}
public async Task <ActionResult <BorrowRequestResponse> > PostBorrowRequest(BorrowRequest borrowRequest)
{
try
{
await _repository.Create(borrowRequest);
}
catch (ArgumentException e)
{
return(BadRequest(e.Message));
}
return(CreatedAtAction("GetBorrowRequest", new { id = borrowRequest.Id }, borrowRequest));
}
/// <summary>
/// Shows details of borrowRequest
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> OnGetAsync(long?id)
{
if (id == null)
{
return(NotFound());
}
BorrowRequest = await _context.BorrowRequest.FirstOrDefaultAsync(m => m.ID == id);
if (BorrowRequest == null)
{
return(NotFound());
}
return(Page());
}
/// <summary>
/// Deletes borrow Request
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync(long?id)
{
if (id == null)
{
return(NotFound());
}
BorrowRequest = await _context.BorrowRequest.FindAsync(id);
if (BorrowRequest != null)
{
_context.BorrowRequest.Remove(BorrowRequest);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public IActionResult CreateBorrowRequest([FromBody] BorrowRequestDTO borrowRequestDTO)
{
try
{
if (borrowRequestDTO == null)
{
_logger.LogError("BorrowingRequest object sent from client is null.");
return(BadRequest("BorrowingRequest object is null"));
}
else if (!ModelState.IsValid)
{
_logger.LogError("Invalid BorrowingRequest object sent from client.");
return(ValidationProblem("Invalid model object"));
}
else
{
// int[] arrayBookIds = _services.arrayBookIds(borrowRequestDTO);
bool isBRValid = _services.IsBRInABRValid(borrowRequestDTO);
bool isBRInAMonthValid = _services.IsNumberOfTimesBRInMonthValid(borrowRequestDTO);
if (isBRValid == false)
{
return(ValidationProblem("One borrowing request more than 1 book(maximum is 5 books)"));
}
if (isBRInAMonthValid == false)
{
return(ValidationProblem("You can't create 3 borrow requests in a month"));
}
BorrowRequest entity = _services.CreateBorrowRequest(borrowRequestDTO);
_services.CreateBorrowRequestDetails(entity.Id, borrowRequestDTO);
return(CreatedAtRoute("BorrowingRequestById", new { id = entity.Id }, entity));
}
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside Create Borrow Request action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public IActionResult Insert(BorrowRequest borrowRequest, int userId)
{
var checkBorrowInMonth = _brRepository.GetAll().Count(br => br.UserId == userId && br.BorrowDate.Month == DateTime.Now.Month);
if (checkBorrowInMonth < 3)
{
if (borrowRequest.BorrowRequestDetails.Count <= 5)
{
borrowRequest.BorrowDate = DateTime.Now;
borrowRequest.Status = (Status)0;
borrowRequest.UserId = userId;
_brRepository.Insert(borrowRequest);
return(Ok(borrowRequest));
}
return(BadRequest("Ban ko the muon 5 cuon sach 1 luc"));
}
return(BadRequest("Ban ko the muon qua 3 lan trong 1 thang"));
}
public override bool BorrowBook(int days)
{
if (User.CurrentChoose.Count == 0)
{
Console.WriteLine("You need to choose some books first");
}
DateTime date = DateTime.Now.AddDays(days);
foreach (var book in User.CurrentChoose)
{
BorrowRequest borrowRequest = new BorrowRequest(DateTime.Now, date, book);
User.ApplyRequest(borrowRequest);
}
Menu.SetMenuState(Menu.BorrowBookState);
return(true);
}
public ActionResult UpdateBorrowRequest(int id, [FromBody] BorrowRequest newBorrowingRequest)
{
try
{
var oldBorrowingRequest = _repository.GetBorrowRequestById(id);
if (newBorrowingRequest == null)
{
_logger.LogError("BorrowingRequest object sent from client is null.");
return(BadRequest("BorrowingRequest object is null"));
}
else if (!ModelState.IsValid)
{
_logger.LogError("Invalid BorrowingRequest object sent from client.");
return(ValidationProblem("Invalid model object"));
}
else if (oldBorrowingRequest == null)
{
_logger.LogError($"BorrowingRequest with id: {id}, hasn't been found in db.");
return(NotFound());
}
else
{
var borrowingRequestEntity = new BorrowRequest
{
Id = id,
UserId = newBorrowingRequest.UserId,
Status = newBorrowingRequest.Status,
CreatedDate = oldBorrowingRequest.CreatedDate,
ModifiedDate = DateTime.Now
};
_repository.Update(borrowingRequestEntity);
return(NoContent());
}
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside Update BorrowingRequest action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public void ApplyRequest(BorrowRequest request)
{
if (ApproveRequest(request))
{
Console.WriteLine(request.RequestNumber + " approved by " + Supervisor.ToString() + " for " + request.GetNumberOfDays() + "days");
BorrowedBooks.Add(new KeyValuePair <DateTime, Book> (request.EndDay, request.BorrowedBook));
}
else
{
this.Supervisor = Supervisor.Supervisor;
if (Supervisor == null)
{
Console.WriteLine("You cannot borrow a book for more than 60 days");
}
else
{
ApplyRequest(request);
}
}
}
private async Task <bool> Validate(BorrowRequest request, Book book)
{
if (book == null)
{
Errors.Add($"The requested book with id '{request.BookId}' not found!");
}
else if (book.AvailableCopies == 0)
{
Errors.Add($"There are no copies available '{book.Title}', please try latter!");
}
else
{
var borrowedBooks = await _userBookRepository.GetByUserIdAsync(request.UserId);
if (borrowedBooks.Count >= 2)
{
Errors.Add($"Not allowed to have more than two books borrowed!");
}
}
return(Errors.Count == 0);
}
public async Task <ActionResult> BorrowBook([FromBody] BorrowRequest borrowRequest)
{
var currentPerson = personService.GetPersonJwtUsername();
var book = await bookService.FindBookById(borrowRequest.BookId);
var person = await personService.FindPersonByUsername(currentPerson);
if (book is null || !book.IsAvailable)
{
return(BadRequest(new ErrorResponse(ErrorTypes.NotFound.EnumDescription())));
}
var borrow = new BorrowInfo(person, book);
await personService.BorrowBook(borrow);
await bookService.UpdateBookOwner(book, person);
var borrowMapper = mapper.Map <BorrowResponse>(borrow);
return(Ok(borrowMapper));
}
public async Task <MessageResponse <BorrowResponse> > Handle(BorrowRequest request, CancellationToken cancellationToken)
{
try
{
var book = await _bookRepository.GetById(request.BookId);
if (!await Validate(request, book))
{
return(new MessageResponse <BorrowResponse>(MessageType.Validation, new MessageResponseError("Validate", Errors.First())));
}
book.AvailableCopies--;
await _bookRepository.Update(book);
await _userBookRepository.AddAsync(new UserBook(request.UserId, request.BookId));
return(new MessageResponse <BorrowResponse>(new BorrowResponse()));
}
catch (Exception e)
{
return(new MessageResponse <BorrowResponse>(MessageType.Error, e));
}
}
/// <summary>
/// Returns movie
/// </summary>
/// <param name="id">Movie ID</param>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync(long?id)
{
// Retrieve movie by its ID and remove ownership fields
Movie = await Context.Movie.FirstOrDefaultAsync(m => m.ID == id);
Movie.IsShareable = true;
Movie.SharedWithFirstName = "";
Movie.SharedWithLastName = "";
Movie.SharedwithEmailAddress = "";
Movie.UserID = "";
Movie.Request = "";
// If the user (other than the owner) is returning the movie, retrieve borrowRequest and change its status to "Expired - Returned"
if (AuthenticatedUserInfo.ObjectIdentifier != "c17f0d89-9862-45ca-beca-5b0c5ca2ae7e")
{
this.BorrowRequest = await Context.BorrowRequest.FirstOrDefaultAsync(m => m.Title == Movie.Title &&
m.UserID == AuthenticatedUserInfo.ObjectIdentifier &&
m.RequestStatus != "Expired - Movie Returned");
}
// Same function but for the owner
else
{
this.BorrowRequest = await Context.BorrowRequest.FirstOrDefaultAsync(m => m.Title == Movie.Title &&
m.RequestStatus != "Expired - Movie Returned");
}
BorrowRequest.RequestStatus = "Expired - Movie Returned";
// Update entities in the database
Context.Attach(BorrowRequest).State = EntityState.Modified;
Context.Attach(Movie).State = EntityState.Modified;
await Context.SaveChangesAsync();
return(RedirectToPage("./Index"));
}
public async Task <Borrows> BorrowTransaction(BorrowRequest borrowRequest)
{
var borrowTransaction = new Borrows()
{
Readerid = borrowRequest.Readerid,
Docid = borrowRequest.Docid,
Libid = borrowRequest.Libid,
Copyid = borrowRequest.Copyid,
Duedate = borrowRequest.Duedate,
Btime = borrowRequest.Btime,
Position = borrowRequest.Position
};
await _library.Borrows.AddAsync(borrowTransaction);
var copy = _library.Copy.FirstOrDefault(x => x.Copyid == borrowTransaction.Copyid);
if (copy != null)
{
copy.Available = false;
}
await _library.SaveChangesAsync();
return(borrowTransaction);
}
public ItemShare Request(BorrowRequest borrow, Guid userIdentifier)
{
if (null == borrow)
{
throw new ArgumentNullException("borrow");
}
if (Guid.Empty == userIdentifier)
{
throw new ArgumentException("user identifier");
}
if (Guid.Empty == borrow.ItemIdentifier)
{
throw new ArgumentException("item identifier");
}
var sproc = new GoodsBorrow()
{
ItemIdentifier = borrow.ItemIdentifier,
UserIdentifier = userIdentifier,
On = borrow.On,
Until = borrow.Until,
Comment = borrow.Comment,
};
var data = sproc.CallObject <ItemShare>();
if (null != data)
{
this.email.BorrowRequest(data);
this.activity.RequestBorrow(data);
}
return(data);
}
public async Task <IActionResult> PutBorrowRequest(int id, BorrowRequest borrowRequest)
{
try
{
await _repository.Update(id, borrowRequest);
}
catch (ArgumentException e)
{
if (e.InnerException == null)
{
return(BadRequest(e.Message));
}
else
{
return(NotFound(e.Message));
}
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public void AcceptBorrowBookRequest(string requester, string borrowFromId, Guid bookId)
{
if (requester == borrowFromId)
{
throw new Exception("Cannot borrow from self.");
}
using (var context = new ApplicationDbContext())
{
UsersBooks userBook = context.UsersBooks.FirstOrDefault(x => x.BookId == bookId && x.UserId == borrowFromId);
if (userBook == null)
{
//LOG
throw new Exception("Cannot find UserBook");
}
var book = context.Books.FirstOrDefault(x => x.Id == bookId);
ApplicationUser borrower = context.Users.FirstOrDefault(x => x.Id == requester);
if (borrower == null)
{
throw new Exception("Borrower does not exist");
}
userBook.Lent = true;
userBook.LentToId = borrower.Id;
userBook.LentTo = borrower;
ApplicationUser borrowFrom = context.Users.FirstOrDefault(x => x.Id == borrowFromId);
if (borrowFrom == null)
{
throw new Exception("BorrowFrom does not exist");
}
var newUserBook = new UsersBooks()
{
BookId = bookId,
UserId = borrower.Id,
Public = true,
Borrowed = true,
BorrowedFrom = borrowFrom,
BorrowedFromId = borrowFromId,
Lent = false,
Book = book
};
context.UsersBooks.Add(newUserBook);
BorrowRequest request = context.BorrowRequests.FirstOrDefault(x => x.BookId == bookId && x.BorrowerId == requester && x.LenderId == borrowFromId);
context.BorrowRequests.Remove(request);
Activity activity = new Activity()
{
Id = Guid.NewGuid(),
BookId = book.Id,
OwnerId = requester,
TimeStampUTC = DateTime.Now.ToUniversalTime(),
Type = ActivityType.BorrowedBook
};
context.Activities.Add(activity);
context.SaveChanges();
}
}
