private void AddCopiesButton_Click(object sender, EventArgs e)
{
if (BooksListBox.CheckedItems.Count == 0)
{
var selectError = new ErrorForm("You must select a book to add copies!");
selectError.ShowDialog();
return;
}
if (int.Parse(NumberOfCopiesToAddTextBox.Text) > 50)
{
NumberOfCopiesToAddTextBox.Text = @"50";
var copiesError = new ErrorForm("You can add a maximum of 50 copies at once");
copiesError.ShowDialog();
}
if (string.IsNullOrWhiteSpace(NumberOfCopiesToAddTextBox.Text))
{
return;
}
var selected = BooksListBox.SelectedItem.ToString();
var checkedBook = _bookRepository.GetAllBooks().First(book => book.ToString() == selected);
for (var i = 0; i < int.Parse(NumberOfCopiesToAddTextBox.Text); i++)
{
var copyToAdd = new BookCopy(BookStatus.Available,
_bookRepository.GetAllBooks().FirstOrDefault(book => book.ToString() == checkedBook.ToString()));
_bookCopyRepository.AddBookCopy(copyToAdd);
}
NumberOfCopiesToAddTextBox.Text = "";
RefreshBookInfoListBox();
}
public async Task <IActionResult> PostBookCopy([FromBody] BookCopy bookCopy)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.BookCopy.Add(bookCopy);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (BookCopyExists(bookCopy.Isbn, bookCopy.CopyCount))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetBookCopy", new { copyCount = bookCopy.CopyCount, isbn = bookCopy.Isbn }, bookCopy));
}
/// <summary>
/// Adds input book copy to database and notifies subscribers of the update.
/// </summary>
/// <param name="bc">BookCopy reference to be added to DB</param>
public void Add(BookCopy bc)
{
bookCopyRepository.Add(bc);
var e = EventArgs.Empty;
OnUpdated(e);
}
public async Task HandleSaveNewClicked_Test_Book()
{
// arrange
var fakeView = A.Fake <IManageCopiesForm>();
BookCopy copy = new BookCopy {
Id = 1
};
A.CallTo(() => fakeView.NewCopy).Returns(copy);
var fakeCopyServiceFactory = A.Fake <ICopyServiceFactory>();
var fakeCopyService = A.Fake <IBookCopyService>();
A.CallTo(() => fakeCopyServiceFactory.GetBookCopyService()).Returns(fakeCopyService);
Book item = new Book {
Id = 1
};
ManageCopiesPresenter presenter = new ManageCopiesPresenter(fakeView, item, fakeCopyServiceFactory);
List <BookCopy> copies = new List <BookCopy>
{
copy
};
A.CallTo(() => fakeCopyService.GetByItemId(1)).Returns(copies);
// act
await presenter.HandleSaveNewClicked(null, null);
// assert
A.CallTo(() => fakeView.DisplayCopies(copies)).MustHaveHappened();
A.CallTo(() => fakeCopyService.Create(copy)).MustHaveHappened();
Assert.AreEqual("Ready.", fakeView.StatusText);
}
public static void LoanBookToUser(User user, Book book)
{
using (var context = new BookDBDataContext())
{
bool alreadyLoaned = (from bu in context.BookUsers
where bu.UserID == user.ID &&
bu.BookCopy.Book.ID == book.ID &&
bu.ReturnDate >= DateTime.Now.Date
select 1).Count() > 0;
if (alreadyLoaned == true)
{
throw new ArgumentException("You have already loaned this book!");
}
BookCopy availableCopy = (from bu in context.BookUsers
where bu.BookCopy.BookID == book.ID &&
bu.ReturnDate == null
select bu.BookCopy).FirstOrDefault();
var avail = (from bc in context.BookCopies
where bc.BookID == book.ID &&
bc.BookUsers.Count() == 0
select bc).FirstOrDefault();
if (availableCopy == null)
{
throw new ArgumentException("There is no available copy of this book!");
}
}
}
public ReturnBookTransaction(BookCopy bookCopy, TransactionInfo transInfo)
: base(bookCopy)
{
_PaymentService = new PaymentService();
_LastTransaction = transInfo;
_LastTransaction.AmountToPay = RequiredFee;
}
public void DiscardChangesClicked_Test()
{
// arrange
var fakeView = A.Fake <IManageCopiesForm>();
fakeView.SelectedDescription = "some description";
fakeView.SelectedNotes = "some notes";
Copy copy = new BookCopy {
Id = 1, Description = "test copy", Notes = "test copy"
};
A.CallTo(() => fakeView.SelectedCopy).Returns(copy);
var fakeCopyServiceFactory = A.Fake <ICopyServiceFactory>();
Item item = new Book {
Id = 1, Title = "item"
};
ManageCopiesPresenter presenter = new ManageCopiesPresenter(fakeView, item, fakeCopyServiceFactory);
// act
presenter.DiscardChangesClicked(null, null);
// assert
Assert.AreEqual("test copy", fakeView.SelectedDescription);
Assert.AreEqual("test copy", fakeView.SelectedNotes);
}
public async Task <ActionResult <BookCopyDTO> > CreateBookCopiesFromDto(int amount, [FromBody] BookCopyDTO bookCopyDto)
{
var bookCopy = _mapper.Map <BookCopy>(bookCopyDto);
for (int i = 0; i < amount; i++)
{
var newBookCopy = new BookCopy()
{
BookId = bookCopy.Book.BookId,
IsAvailable = true,
ShelfNumber = bookCopy.ShelfNumber,
OriginLibraryId = bookCopy.OriginLibrary.LibraryId,
CurrentLibraryId = bookCopy.CurrentLibrary.LibraryId
};
_wrapper.BookCopyRepository.CreateBookCopy(newBookCopy);
}
try
{
await _wrapper.SaveAsync();
}
catch (DbUpdateException e)
{
return(BadRequest(e.Message));
}
return(CreatedAtAction(nameof(CreateBookCopy), new { id = bookCopy.BookCopyId }, bookCopy));
}
public void DeleteBookCopy(BookCopy bookCopy, bool removeDependencies = false)
{
var dependencies = _dataContext.events.Where(e => e is BookEvent)
.Cast <BookEvent>()
.Where(e => e.Copy == bookCopy);
if (!removeDependencies && dependencies.Count() > 0)
{
throw new UnsafeDataRemoveException(dependencies.ToString());
}
if (bookCopy.IsLent)
{
throw new BookCopyLentException();
}
var result = _dataContext.bookCopies.Remove(bookCopy);
if (!result)
{
throw new DataNotRemovedException();
}
_dataContext.events.RemoveAll(dependencies);
}
public BookInfo GetBookInfo(BookCopy bookCopy)
{
using (var bookInfoRepo = new BookInfoRepository())
{
return(bookInfoRepo.Where(b => b.Id.Equals(bookCopy.BookInfoId)).Single());
}
}
/// <summary>
/// Method to make a loan of a book for a member.
/// </summary>
/// <param name="member">Member that makes the loan.</param>
/// <param name="book">Book the member wants to loan.</param>
public void MakeLoan(Member member, Book book)
{
if (null == bookRepository.Find(book.ISBN))
{
throw new ArgumentException("No book wit ISBN: " + book.ISBN + " found in database.");
}
else
{
List <int> noOfCopiesOnLoan = loanRepository.All().
Where(loan => loan.TimeOfReturn == null).
Where(loan => loan.Copy.Book.ISBN == book.ISBN).
Select(loan => loan.Copy.ID).
ToList();
BookCopy copyToLoan = bookCopyRepository.All().
Where(c => false == noOfCopiesOnLoan.Contains(c.ID)).
Where(c => c.Book.ISBN == book.ISBN).
FirstOrDefault();
if (null == copyToLoan)
{
throw new ArgumentException("No bookcopy available for Title: " + book.Title + ".");
}
else
{
MakeLoan(member, copyToLoan);
}
}
}
private void button1_Click(object sender, EventArgs e)
{
foreach (ListViewItem item in lvItems.Items)
{
if (item.Checked)
{
item.Remove();
int tmpID = int.Parse(item.Text.ToString());
try
{
BookRental dbObject = dbDataContext.BookRentals.SingleOrDefault(x => x.ID == tmpID);
BookCopy bc = dbDataContext.BookCopies.Where(x => x.ID == dbObject.CopyID).First();
bc.Free = 1;
dbObject.ReturnDate = (DateTime?)DateTime.Now;
dbObject.status = 0;
dbDataContext.SubmitChanges();
int elementIndex = BookListForm.items.FindIndex(x => x.SubItems[0].Text == item.SubItems[4].Text);
BookListForm.items[elementIndex].SubItems[6].Text = (int.Parse(BookListForm.items[elementIndex].SubItems[6].Text) + 1).ToString();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
}
}
private void loadOrders(bool selectMode)
{
DateTime today = DateTime.Today;
foreach (BookRental bookRental in dbDataContext.BookRentals.OrderByDescending(x => x.ID).
Where(y => y.status == (selectMode ? 1 : 0)))
{
Users user = dbDataContext.Users.Where(x => x.ID == bookRental.ReaderID).First();
BookCopy bookCopy = dbDataContext.BookCopies.Where(x => x.ID == bookRental.CopyID).First();
Books book = dbDataContext.Books.Where(x => x.ID == bookCopy.BookID).First(); //name
if (Program.loggedUser.AdminStatus == 0 && user.ID != Program.loggedUser.ID)
{
continue;
}
DateTime returnDate = (DateTime)bookRental.ReturnDate;
bool status = (returnDate.CompareTo(today) > 0);
string strStatus = (bookRental.status == 1) ? (status ? "Wypożyczona" : "Nieoddana") : "Oddana";
var item = new ListViewItem(new[]
{
bookRental.ID.ToString(),
(user.Name + " " + user.Surname).ToString(),
bookRental.RentDate.ToString(),
returnDate.ToString(),
book.Title.ToString(),
strStatus
}
);
this.lvItems.Items.Add(item);
}
this.lvItems.ListViewItemSorter = new LvComparer(0);
//this.lvItems.Sorting = SortOrder.Descending;
}
private void SaveButton_Click(object sender, EventArgs e)
{
NameTextBox.Text = NameTextBox.Text.TrimAndRemoveWhiteSpaces();
if (!CheckForErrors())
{
return;
}
var toAdd = new Book
{
Name = NameTextBox.Text,
PageCount = PageCountTextBox.Text,
Genre = (Genre)Enum.Parse(typeof(Genre), GenreComboBox.Text),
Author = _authorRepository.GetAllAuthors().First(author => author.ToString() == AuthorComboBox.Text),
Publisher = _publisherRepository.GetAllPublishers().First(publisher => publisher.ToString() == PublisherComboBox.Text)
};
_bookRepository.AddBook(toAdd);
var statusToAdd = IsReadOnlyCheckBox.Checked ? BookStatus.ReadOnly : BookStatus.Available;
for (var i = 0; i < int.Parse(NumberOfCopiesTextBox.Text); i++)
{
var copyToAdd = new BookCopy(statusToAdd, _bookRepository.GetAllBooks().FirstOrDefault(book => book.ToString() == toAdd.ToString()));
_bookCopyRepository.AddBookCopy(copyToAdd);
}
Close();
}
public async Task HandleSaveNewClicked(object sender, EventArgs args)
{
this._view.StatusText = "Please Wait...";
if (this._item.GetType() == typeof(Book))
{
var copyService = this._serviceFactory.GetBookCopyService();
BookCopy copy = (BookCopy)this._view.NewCopy;
await copyService.Create(copy);
this._view.DisplayCopies(await copyService.GetByItemId(this._item.Id));
}
else if (this._item.GetType() == typeof(MediaItem))
{
var copyService = this._serviceFactory.GetMediaItemCopyService();
MediaItemCopy copy = (MediaItemCopy)this._view.NewCopy;
await copyService.Create(copy);
this._view.DisplayCopies(await copyService.GetByItemId(this._item.Id));
}
this._view.NewDescription = "";
this._view.NewNotes = "";
this._view.StatusText = "Ready.";
}
private void CheckBookCopyExistance(BookCopy bookCopy)
{
if (!_dataContext.bookCopies.Contains(bookCopy))
{
throw new InvalidEventException("Book copy does not exist.");
}
}
public ActionResult Create(BookCreateVm vm)
{
if (ModelState.IsValid)
{
//Create new book
var newBook = new BookDetails();
newBook.AuthorID = vm.AuthorId;
newBook.Description = vm.Description;
newBook.ISBN = vm.ISBN;
newBook.Title = vm.Title;
_bookService.AddBook(newBook);
if (vm.NumberOfCopies != 0)
{
var allBooksIncludingNewBookDetails = _bookService.GetAllBooks();
var allBooksOrdered = allBooksIncludingNewBookDetails.OrderBy(x => x.ID);
var lastItem = allBooksOrdered.Last();
for (var i = 0; i < vm.NumberOfCopies; i++)
{
var newBookCopy = new BookCopy();
var BookDetailsID = lastItem.ID;
newBookCopy.DetailsId = BookDetailsID;
_bookCopyService.AddBookCopy(newBookCopy);
newBookCopy = null;
}
}
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction("Error", "Home", ""));
}
private void CheckBookCopyReference(BookCopy bookCopy)
{
if (!_dataContext.books.ContainsKey(bookCopy.Book.Isbn))
{
throw new InvalidDataException("Book copy refers to book that is not in repository!");
}
}
/// <summary>
/// Dodaj novu knjigu sa random kategorijom
/// </summary>
public async Task <bool> AddBokk(Book book)
{
int count = await _categoryrepo.CountAsync();
Random rand = new Random();
book.CategoryID = rand.Next(0, count);
Book result = await _bookrepo.AddAsync(book);
if (result != null)
{
List <BookCopy> copies = new List <BookCopy>();
for (int i = 0; i < 20; i++)
{
BookCopy copy = new BookCopy()
{
Borrowed = false, BookId = result.Id
};
copies.Add(copy);
}
return(await _copyrepo.AddRangeAsync(copies));
}
return(false);
}
public void LoanBook(BookCopy bookCopy, Member member)
{
// Uppgiftsspecifik logik för att ett lån ska vara försenat
var dateOfLoan = DateTime.Now;
if (member.Loans is null)
{
dateOfLoan = DateTime.Now;
}
else if (member.Loans.Count >= 1)
{
dateOfLoan = DateTime.Now.AddMonths(-1);
}
var loan = new Loan()
{
TimeOfLoan = dateOfLoan,
DueDate = dateOfLoan.AddDays(14),
BookCopy = bookCopy,
Member = member,
};
AddLoan(loan);
ConnectMemberAndLoan(loan, member);
}
public async Task HandleSaveSelectedClicked_Test_Book()
{
// arrange
var fakeView = A.Fake <IManageCopiesForm>();
A.CallTo(() => fakeView.SelectedDescription).Returns("description");
A.CallTo(() => fakeView.SelectedNotes).Returns("notes");
BookCopy copy = new BookCopy {
Id = 1, BookId = 1, Description = fakeView.SelectedDescription, Notes = fakeView.SelectedNotes
};
A.CallTo(() => fakeView.ModifiedSelectedCopy).Returns(copy);
Book item = new Book {
Id = 1, Title = "item"
};
var fakeCopyServiceFactory = A.Fake <ICopyServiceFactory>();
var fakeCopyService = A.Fake <IBookCopyService>();
A.CallTo(() => fakeCopyServiceFactory.GetBookCopyService()).Returns(fakeCopyService);
ManageCopiesPresenter presenter = new ManageCopiesPresenter(fakeView, item, fakeCopyServiceFactory);
List <BookCopy> copies = new List <BookCopy>
{
copy
};
A.CallTo(() => fakeCopyService.GetByItemId(1)).Returns(copies);
// act
await presenter.HandleSaveSelectedClicked(null, null);
// assert
A.CallTo(() => fakeView.DisplayCopies(copies)).MustHaveHappened();
A.CallTo(() => fakeCopyService.Update(copy)).MustHaveHappened();
Assert.AreEqual("Ready.", fakeView.StatusText);
}
public ReturnBookEvent(
BookCopy copy,
Customer customer,
DateTime date
) : base(copy, customer, date)
{
}
public void CopySelected_Test_Selected()
{
// arrange
var fakeView = A.Fake <IManageCopiesForm>();
Copy copy = new BookCopy {
Id = 1, Description = "test copy", Notes = "test copy"
};
A.CallTo(() => fakeView.NumberCopiesSelected).Returns(1);
A.CallTo(() => fakeView.SelectedCopy).Returns(copy);
var fakeCopyServiceFactory = A.Fake <ICopyServiceFactory>();
Item item = new Book {
Id = 1, Title = "item"
};
ManageCopiesPresenter presenter = new ManageCopiesPresenter(fakeView, item, fakeCopyServiceFactory);
// act
presenter.CopySelected(null, null);
// assert
Assert.AreEqual("test copy", fakeView.SelectedDescription);
Assert.AreEqual("test copy", fakeView.SelectedNotes);
Assert.IsTrue(fakeView.DeleteSelectedButtonEnabled);
Assert.IsTrue(fakeView.SelectedDescriptionFieldEnabled);
Assert.IsTrue(fakeView.SelectedNotesFieldEnabled);
}
public IHttpActionResult UpdateBookCopy(BookCopy bookCopy)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Entry(bookCopy).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!BookCopyExists(bookCopy.BookCopiesID))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok("Success"));
}
// GET: Loans/Create/1
public ActionResult Create(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BookCopy copy = db.BookCopies.Where(c => c.Available && c.ID == id).FirstOrDefault();
if (copy == null)
{
return(HttpNotFound());
}
ViewBag.BookCopy = copy;
ViewBag.BookCopyID = id;
ViewBag.LoanTypeID = new SelectList(db.LoanTypes, "ID", "Name");
var members = db.Members.Select(m => new {
ID = m.ID,
Name = m.ID + " - " + m.FirstName + " " + m.MiddleName + " " + m.LastName
}).ToList();
ViewBag.MemberID = new SelectList(members, "ID", "Name");
return(View());
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id is null)
{
return(NotFound());
}
BookCopy = await _context.BookCopies.FirstOrDefaultAsync(m => m.Id == id);
if (BookCopy is null)
{
return(NotFound());
}
var tempStates = BookStates.GetBookStates().Where(s => !_context.BookCopies.Any(x => x.BookId == BookCopy.BookId && x.State == s) || s == BookCopy.State).ToList();
foreach (var item in tempStates)
{
AvailableStates.Add(new SelectListItem {
Value = item, Text = item
});
}
return(Page());
}
public BorrowBookTransaction(LibraryUser libUser, BookCopy bookCopy)
: base(bookCopy)
{
_BookCopyService = new BookCopyService();
_HolidayService = new HolidayService();
_BookInfoService = new BookService();
_SectionService = new SectionService();
var bookInfo = _BookInfoService.BookInfoOf(BookCopy);
var section = _SectionService.GetBookSection(bookInfo);
if (section == null)
{
throw new InvalidOperationException("The book does not belong to a section.");
}
if (section.MaxDaysAllowedForBorrowing == 0)
{
TransactionType = "Not Allowed For Borrowing.";
}
bookTransInfo = new TransactionInfo
{
BookCopyId = BookCopy.Id,
LibraryUserId = libUser.Id,
BorrowDate = TransactionDate,
ExpectedReturnDate = _HolidayService.GetNonHolidayDateFrom(TransactionDate.AddDays(section.MaxDaysAllowedForBorrowing))
};
}
public async Task HandleSaveSelectedClicked(object sender, EventArgs args)
{
this._view.StatusText = "Please Wait...";
if (this._item.GetType() == typeof(Book))
{
var copyService = this._serviceFactory.GetBookCopyService();
BookCopy copy = (BookCopy)this._view.ModifiedSelectedCopy;
copy.BookId = this._item.Id;
await copyService.Update(copy);
this._view.DisplayCopies(await copyService.GetByItemId(this._item.Id));
}
else if (this._item.GetType() == typeof(MediaItem))
{
var copyService = this._serviceFactory.GetMediaItemCopyService();
MediaItemCopy copy = (MediaItemCopy)this._view.ModifiedSelectedCopy;
copy.MediaItemId = this._item.Id;
await copyService.Update(copy);
this._view.DisplayCopies(await copyService.GetByItemId(this._item.Id));
}
this._view.StatusText = "Ready.";
}
/// <summary>
/// Removes the input book from the database and notifies subscribers of the update.
/// </summary>
/// <param name="bc">BookCopy reference to be removed from the DB</param>
public void Remove(BookCopy bc)
{
bookCopyRepository.Remove(bc);
var e = EventArgs.Empty;
OnUpdated(e);
}
public void AddMoreCopiesOfBook_AddOneBookToEmptyList_ReturnCountNrOne()
{
////Arrange
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("MDLibrary_AddMoreCopies")
.Options;
var context = new ApplicationDbContext(options);
var expectedResult = 1;
var testBook = new BookCopy()
{
ID = 1,
BookDetailsID = 2
};
var testBookService = new BookServices(context);
//Act
testBookService.AddMoreCopiesOfBook(testBook);
var actualResult = context.BookCopy.ToList().Count;
//Assert
Assert.Equal(expectedResult, actualResult);
}
