private static void AddReservedBook()
{
var context = new BookClubContext();
string firstName = "Morgan";
string lastName = "Berglund";
string bookTitle = "Djunglebook";
var member = context.Members.FirstOrDefault(a => a.FirstName.StartsWith(firstName) && a.LastName.StartsWith(lastName));
var book = context.Books.FirstOrDefault(b => b.Title.StartsWith(bookTitle));
if (member.FirstName != null && book.Title != null)
{
var borroweBook = new BorrowedBook {
MemberId = member.Id, BookId = book.Id
};
context.Add(borroweBook);
context.SaveChanges();
Console.WriteLine("Member {0} {1} loaned the book {2}", member.FirstName, member.LastName, book.Title);
}
else
{
Console.WriteLine("Book or member not found.");
}
}
public BorrowEditor(BorrowedBook BB)
{
InitializeComponent();
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
Borrower.ItemsSource = ReaderDataProvider.GetAllAsList();
List <Book> BookList = BookDataProvider.GetAllAsList() as List <Book>;
BookToLend.ItemsSource = BookList.FindAll(x => x.IsBorrowed == false);
if (!(BB == null))
{
_borrowedBook = BB;
CurrantBorrower.Content = _borrowedBook.ReaderName;
CurrantBorrower.Visibility = Visibility.Visible;
CurrantBook.Content = _borrowedBook.BookName;
CurrantBook.Visibility = Visibility.Visible;
StartOfBorrow.SelectedDate = _borrowedBook.DateOfBorrow;
DateOfDeadline.SelectedDate = _borrowedBook.Deadline;
AddButton.Visibility = Visibility.Hidden;
}
else
{
_borrowedBook = new BorrowedBook();
DeleteButton.Visibility = Visibility.Hidden;
SaveButton.Visibility = Visibility.Hidden;
}
}
public BorrowResult Borrow(int id)
{
var username = _httpContext.HttpContext.User.Identity.Name;
Book book = _context.Books.Single(
b => b.Id == id);
User user = _context.Users.Single(
u => u.Username == username);
if (!book.Availability)
{
return(BorrowResult.NotAvailable);
}
book.Availability = false;
var newBorrow = new BorrowedBook
{
User = user,
Book = book,
DateBorrowed = DateTime.Now,
DateReturned = DateTime.Now.AddDays(30),
};
_context.BorrowedBooks.Add(newBorrow);
_context.SaveChanges();
return(BorrowResult.Success);
}
public void Delete_delete_borrowed_book_properly()
{
//Arrange
BookCategory category = BorrowedBookFactory.GenerateDummyBookCategory();
context.Manipulate(_ => _.BookCategories.Add(category));
Writer writer = BorrowedBookFactory.GenerateDummyWriter();
context.Manipulate(_ => _.Writers.Add(writer));
Book book = BorrowedBookFactory.GenerateDummyBook();
book.CategoryId = category.Id;
book.WriterId = writer.Id;
context.Manipulate(_ => _.Books.Add(book));
Member member = BorrowedBookFactory.GenerateDummyMember();
context.Manipulate(_ => _.Members.Add(member));
BorrowedBook borrowedBook = new BorrowedBook()
{
Title = book.Title,
ReturnDate = DateTime.Parse("02/02/2022")
};
context.Manipulate(_ => _.BorrowedBooks.Add(borrowedBook));
//Act
sut.Delete(borrowedBook.Id);
//Assert
var expected = readContext.BorrowedBooks.FirstOrDefault(_ => _.Id == borrowedBook.Id);
expected.Should().BeNull();
}
public void Update(BorrowedBook entity)
{
var result = Find(entity.Id);
result.IdBook = entity.IdBook;
result.IdSubscriber = entity.IdSubscriber;
borrowedBookContext.SaveChanges();
}
public void GetBookInfoTest()
{
BorrowedBook b = new BorrowedBook(1);
Assert.AreEqual(b.BookInfo(), "\r\nTitle: " + BookCRUD.getTitle(1) + "\r\nAuthor: " + BookCRUD.getAuthor(1)
+ "\r\nType: " + BookCRUD.getType(1) + "\r\nPenalty Cost: " + BookCRUD.getPenaltyCost(1)
+ "\r\nReturn Date: " + BookCRUD.getReturnDate(1));
}
public Boolean isPeriodOfTimeRespected(BorrowedBook borrowedBook)
{
if (borrowedBook.BorrowPassedTimeInDays >= timeLimitInSeconds)
{
return(false);
}
return(true);
}
public List <User> GetUsers()
{
var userList = new List <User>();
var cmd = _connection.CreateCommand();
cmd.CommandText = "select id, name from User";
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var userId = int.Parse(reader["id"].ToString());
var user = new User
{
Id = userId,
Name = (string)reader["name"],
BorrowedBooks = new List <BorrowedBook>()
};
userList.Add(user);
}
}
foreach (var user in userList)
{
cmd.CommandText = "select bb.UserId, bb.BookId, bb.BorrowingDate, b.Name, b.Borrowed " +
"from BorrowedBook bb " +
"join Book b on b.Id = bb.BookId " +
"where UserId = :userId";
cmd.Parameters.AddWithValue("userId", user.Id);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Book book;
var bookId = int.Parse(reader["bookId"].ToString());
if (_bookCache.ContainsKey(bookId))
{
book = _bookCache[bookId];
}
else
{
book = new Book
{
Id = bookId,
Name = (string)reader["name"],
Borrowed = bool.Parse(reader["borrowed"].ToString())
};
_bookCache.Add(bookId, book);
}
var borrowedBook = new BorrowedBook(book, DateTime.Parse(reader["borrowingDate"].ToString()));
user.BorrowedBooks.Add(borrowedBook);
}
}
}
return(userList);
}
// Given[("تنها یک کتاب با عنوان راهنمای اشپزی
// و تاریخ برگشت 05/05/2021 در فهرست کتابهای به امانت سپرده شده موجود باشد")]
//
private void Given()
{
borrowedBook = new BorrowedBook()
{
Title = "راهنمای اشپزی",
ReturnDate = DateTime.Parse("05/05/2021")
};
context.Manipulate(_ => _.BorrowedBooks.Add(borrowedBook));
}
public bool remove(BorrowedBook borrowedBook)
{
if (books.Contains(borrowedBook))
{
books.Remove(borrowedBook);
return(true);
}
return(false);
}
public bool save(BorrowedBook borrowedBook)
{
if (books.Contains(borrowedBook))
{
return(false);
}
books.Add(borrowedBook);
return(true);
}
public String returnTheBook(IListUserBorrowedBooks borrowedBooks,
BorrowedBook borrowedBook)
{
if (borrowedBooks.getOne(borrowedBook.bookUUID) != null)
{
borrowedBooks.remove(borrowedBook);
return($"{borrowedBook.bookTitle} returned");
}
return("no such a book in your collection");
}
public void Add(string title)
{
var borrowedBook = new BorrowedBook()
{
Title = title,
ReturnDate = DateTime.Parse("02/02/2022")
};
_dBContext.BorrowedBooks.Add(borrowedBook);
}
public ActionResult DisplayBooks(int id, int code)
{
using (var db = new LIBRARYEntities())
{
try {
var account = db.Accounts.Where(x => x.AccountID == id).Single();
var reader = db.Readers.Where(x => x.ReaderID == account.ReaderID).Single();
var book = db.Books.Where(x => x.BookID == code).Single();
var bbook = new BorrowedBook
{
BookID = book.BookID,
ReaderID = reader.ReaderID,
BorrowedDate = DateTime.Now,
ExpectDate = DateTime.Now.AddMonths(1)
};
book.IsBorrowed = true;
db.BorrowedBooks.Add(bbook);
db.SaveChanges();
var notBorrowed = new List <Book>();
foreach (var item in db.Books)
{
if (item.IsBorrowed == false)
{
notBorrowed.Add(item);
}
}
if (notBorrowed.Count == 0)
{
ViewBag.Message = "No books to display";
}
var model = new Models.Readers.SearchedBooks
{
id = id,
SearchedBook = notBorrowed,
Count = reader.NrOfBooks()
};
return(View(model));
}
catch (Exception)
{
ViewBag.Message = "No account with the give id";
return(View("Login"));
}
}
}
public ObservableCollection <BorrowedBook> GetBorrowedBooks()
{
borroweds = new ObservableCollection <BorrowedBook>();
for (int i = 1; i <= BorrowedBookCRUD.getMaxId(); i++)
{
BorrowedBook bb = new BorrowedBook(i);
if (bb.BCustomerId != -1)
{
borroweds.Add(bb);
}
}
return(borroweds);
}
public ActionResult Edit(int id, BorrowedBook borrowedBook)
{
try
{
var cbook = db.borrowdbooks.Single(s => s.id == id);
cbook.isReturned = borrowedBook.isReturned;
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public static void Update(BorrowedBook borrowedBook)
{
using (var client = new HttpClient())
{
var rawData = JsonConvert.SerializeObject(borrowedBook);
var content = new StringContent(rawData, Encoding.UTF8, "application/json");
var response = client.PutAsync(url + "/" + borrowedBook.Id, content).Result;
if (!response.IsSuccessStatusCode)
{
throw new InvalidOperationException(response.StatusCode.ToString());
}
}
}
public HttpResponseMessage Post(int id)
{
Book book = service.Books.GetById(id);
if (book == null)
{
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.NotFound, Content = new StringContent("Book not found in Library, please contact Administrator.")
});
}
var currentUser = service.Users.Get(user => user.UserName == User.Identity.Name).FirstOrDefault();
if (currentUser == null)
{
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.NotFound, Content = new StringContent("User not authenticated, please contact Administrator.")
});
}
if (book.Quantity > book.Queued)
{
BorrowedBook borrowedBook = new BorrowedBook()
{
BookId = book.Id, UserId = currentUser.Id, ReturnDate = DateTime.Today.AddMonths(1)
};
book.Queued += 1;
service.BorrowedBooks.Insert(borrowedBook);
service.Books.Update(book);
}
else
{
BookQueue queuedBook = new BookQueue()
{
AwaitedBook = book, AwaitingReader = currentUser
};
service.QueuedBooks.Insert(queuedBook);
}
service.Save();
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK, Content = new StringContent("{\"result\":\"Book borrowed.\"}", Encoding.UTF8, "text/plain")
});
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
BorrowedBook = await _context.BorrowedBook
.Include(b => b.BookCopy.Book)
.Include(b => b.Member).FirstOrDefaultAsync(m => m.BorrowedBookId == id);
if (BorrowedBook == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
BorrowedBook = await _context.BorrowedBook.FindAsync(id);
if (BorrowedBook != null)
{
_context.BorrowedBook.Remove(BorrowedBook);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public Boolean PostForBorroweBook(BorrowBookModel book)
{
BorrowedBook Bbook = new BorrowedBook();
Bbook.Title = book.Title;
Bbook.AutherName = book.AutherName;
Bbook.PublicherName = book.PublicherName;
Bbook.NumberOfPage = book.NumberOfPage;
Bbook.Image = book.Image;
Bbook.TimeOfPost = DateTime.Now;
Bbook.Request = false;
Bbook.ISborrwed = false;
Bbook.UserID = null;
context.BorrowedBooks.Add(Bbook);
context.SaveChanges();
return(true);
}
public bool deleteBorrowedBook(BorrowedBook borrowedBook)
{
Book book = BookDAOMySql.Instance().getBook(borrowedBook.books_isbn);
if (!borrowedBook.returned) book.is_available = true;
if (BookDAOMySql.Instance().updateBook(book))
{
if (DBConnection.Instance().IsConnect())
{
string query = "DELETE FROM borrowed_books WHERE members_ssn = '" + borrowedBook.members_ssn +
"' AND books_isbn = '" + borrowedBook.books_isbn +
"' AND given_date = '" + DateTime.Parse(borrowedBook.given_date).ToString("yyyy-MM-dd HH:mm:ss") + "'";
MySqlCommand cmd = new MySqlCommand(query, DBConnection.Instance().GetConnection());
cmd.ExecuteNonQuery();
return true;
}
}
return false;
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
BorrowedBook = await _context.BorrowedBook
.Include(b => b.BookCopy)
.Include(b => b.Member).FirstOrDefaultAsync(m => m.BorrowedBookId == id);
if (BorrowedBook == null)
{
return(NotFound());
}
ViewData["BookCopyId"] = new SelectList(_context.BookCopy, "BookCopyId", "BookCopyId");
ViewData["MemberId"] = new SelectList(_context.Member, "MemberId", "IDNumber");
return(Page());
}
public void execute()
{
IRepository bookLibrary = ListLibrayRepository.GetInstance();
Librarian librarian = new Librarian(bookLibrary);
Guest guest = new Guest(bookLibrary);
Member member = new Member(bookLibrary);
var testBookOne = new Book("Kahina", "Gisele Halimi");
var testBookTwo = new Book("Power", "Robert Green");
var testBookThree = new Book("Ainsi parlait zarathoustra", "Frediric Neitch");
var testBookFour = new Book("discoure sur l'art et la science", "jean jack rousseau");
var testBookFive = new Book("l'etranger", "albert camus");
librarian.save(testBookOne);
librarian.save(testBookTwo);
librarian.save(testBookThree);
librarian.save(testBookFour);
librarian.save(testBookFive);
printLibrary(guest.getAllBooks());
var testBorrowBookOne = new BorrowedBook(testBookOne, 4 * 7);
var testBorrowBookTwo = new BorrowedBook(testBookTwo, 3 * 7);
var testBorrowBookThree = new BorrowedBook(testBookThree, 2 * 7);
var testBorrowBookFour = new BorrowedBook(testBookFour, 1 * 7);
var testBorrowBookFive = new BorrowedBook(testBookFive, 1);
member.borrowTheBook(testBorrowBookOne);
member.borrowTheBook(testBorrowBookTwo);
member.borrowTheBook(testBorrowBookThree);
member.borrowTheBook(testBorrowBookFour);
member.borrowTheBook(testBorrowBookFive);
member.returnTheBook(testBorrowBookFive);
member.returnTheBook(testBorrowBookThree);
printLibrary(member.getAlllBooks());
librarian.remove(testBookOne);
printLibrary(member.getAlllBooks());
}
public bool addBorrowedBook(BorrowedBook borrowedBook)
{
if (DBConnection.Instance().IsConnect())
{
Book book = BookDAOMySql.Instance().getBook(borrowedBook.books_isbn);
book.is_available = false;
if (BookDAOMySql.Instance().updateBook(book))
{
string query = "INSERT INTO borrowed_books" +
" VALUES ('" + borrowedBook.books_isbn + "','"
+ borrowedBook.members_ssn + "','"
+ borrowedBook.given_date + "','"
+ borrowedBook.due_date + "',"
+ borrowedBook.returned + ",'"
+ borrowedBook.return_date + "')";
MySqlCommand cmd = new MySqlCommand(query, DBConnection.Instance().GetConnection());
cmd.ExecuteNonQuery();
}
return true;
}
return false;
}
public ActionResult Create(BorrowedBook borrowedB)
{
try
{
var booksList = db.Books.Single(b => b.Title == borrowedB.Title);
var students = db.students.Single(s => s.studendID == borrowedB.StudentId);
borrowedB.StudentId = students.studendID;
borrowedB.StudentName = students.Name;
borrowedB.Title = booksList.Title;
borrowedB.Publisher = booksList.Publisher;
borrowedB.author = booksList.author;
borrowedB.subjectMatter = booksList.subjectMatter;
borrowedB.imagePath = booksList.imagePath;
var brdBooks = db.borrowdbooks;
brdBooks.Add(borrowedB);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public String borrowTheBook(IListUserBorrowedBooks borrowedBooks,
BorrowedBook borrowedBook)
{
String numberOfBookIssueMessage = $"You have reached the maximum of books return some if you want to borrow {borrowedBook.bookTitle}";
String periodOfTimeIssueMessage = $"You can't borrow {borrowedBook.bookTitle} due to exceeded time limit on at least one borrow";
if (!isNumberOfBooksLessThenThree(borrowedBooks) && !isPeriodOfTimeRespected(borrowedBook))
{
return($"{numberOfBookIssueMessage} and {periodOfTimeIssueMessage}");
}
if (!isNumberOfBooksLessThenThree(borrowedBooks))
{
return(numberOfBookIssueMessage);
}
if (!isPeriodOfTimeRespected(borrowedBook))
{
return(periodOfTimeIssueMessage);
}
borrowedBooks.save(borrowedBook);
return($"{borrowedBook.bookTitle} borrowed");
}
public bool updateBorrowedBook(BorrowedBook borrowedBook)
{
Book book = BookDAOMySql.Instance().getBook(borrowedBook.books_isbn);
book.is_available = true;
if (BookDAOMySql.Instance().updateBook(book))
{
if (DBConnection.Instance().IsConnect())
{
string query = "UPDATE borrowed_books" +
" SET returned = 1, " +
" return_date = '" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "'" +
" WHERE books_isbn = '" + borrowedBook.books_isbn + "'" +
" AND members_ssn = '" + borrowedBook.members_ssn + "'" +
" AND given_date = '" + DateTime.Parse(borrowedBook.given_date).ToString("yyyy-MM-dd HH:mm:ss") + "'";
MySqlCommand cmd = new MySqlCommand(query, DBConnection.Instance().GetConnection());
cmd.ExecuteNonQuery();
return true;
}
}
return false;
}
public BorrowedBook getBorrowedBook(string ssn, string isbn, string given_date)
{
BorrowedBook borrowed = new BorrowedBook();
if (DBConnection.Instance().IsConnect())
{
string query = "SELECT * FROM borrowed_books WHERE members_ssn = '" + ssn + "'"
+ " books_isbn = '" + isbn + "'"
+ " given_date = '" + given_date + "'";
MySqlCommand cmd = new MySqlCommand(query, DBConnection.Instance().GetConnection());
MySqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
borrowed.members_ssn = reader.GetString("members_ssn");
borrowed.books_isbn = reader.GetString("books_isbn");
borrowed.given_date = reader.GetMySqlDateTime("given_date").ToString();
borrowed.due_date = reader.GetMySqlDateTime("due_date").ToString();
borrowed.returned = reader.GetBoolean("returned");
borrowed.return_date = reader.GetMySqlDateTime("return_date").ToString();
}
reader.Close();
borrowed.member = MemberDAOMySql.Instance().getMember(borrowed.members_ssn);
borrowed.book = BookDAOMySql.Instance().getBook(borrowed.books_isbn);
}
return borrowed;
}
public void GetCustomerInfoTest()
{
BorrowedBook b = new BorrowedBook(2);
Assert.AreEqual(b.CustomerInfo(), "\r\nName: " + CustomerCRUD.getName(2) + "\r\nMoney: " + CustomerCRUD.getMoney(2));
}
public void Delete(BorrowedBook borrowedBook)
{
_dBContext.BorrowedBooks.Remove(borrowedBook);
}
/// <summary>
/// Save Book Borrow
/// </summary>
/// <param name="borrowedbook">borrowedbook</param>
/// <returns>Id</returns>
public int SaveBorrowBook(BorrowedBook borrowedbook)
{
return(this.Save(borrowedbook, false, false));
}
/// <summary>
/// Save Book Borrow
/// </summary>
/// <param name="borrowedbook">borrowedbook</param>
/// <returns>Id</returns>
public int SaveBorrowBook(BorrowedBook borrowedbook)
{
return(this.Save(borrowedbook, false, false, borrowedbook.CustomerId));
}
public async Task <ServiceResult> CreateBookReservation(string username, string bookName)
{
//dovati knjigu
var bookResult = await _bookrepo.GetBookByName(bookName);
//dohvati korisnika
var userResult = await _userepo.GetUserByNameAsync(username);
ServiceResult result = new ServiceResult();
User userFromDatabase = new User();
if (userResult == null) //ako korisnik ne postoji u bazi
{
userFromDatabase.UserName = username;
userFromDatabase.HashedPassword = "******";
//dodaj korisnika u bazu
userFromDatabase = await _userepo.AddAsync(userFromDatabase);
if (userFromDatabase == null) //pogreška
{
result.SetErrorMessage("Uff, something went wrong :(");
return(result);
}
}
//knjiga nije pronadena u bazi
if (bookResult == null)
{
result.SetErrorMessage("Uff, something went wrong :(");
return(result);
}
//korisnik je vec posudio ovu knjigu
if (!await _bookrepo.CanUserMakeAReservation(bookName, userResult.Id))
{
result.SetErrorMessage("You already borrowed this book :;");
return(result);
}
//sve kopije knjige su posudene
var bookForReservation = await _bookrepo.GetAvailableBookCopy(bookName);
if (bookForReservation == null)
{
result.SetErrorMessage("This book isnt available :(");
return(result);
}
BorrowedBook borrowedBook = new BorrowedBook()
{
BookCopyId = bookForReservation.Id,
EndDateTime = DateTime.Now.AddDays(30),
StartDateTime = DateTime.Now,
UserId = userResult.Id,
};
bookForReservation.Borrowed = true;
//dodaj rezervaciju
borrowedBook = await _borrowrepo.AddAsync(borrowedBook);
if (borrowedBook != null && (await _copyrepo.UpdateAsync(bookForReservation) != null))
{
return(result);
}
result.SetErrorMessage("Uff, something went wrong :(");
return(result);
}
