/// <summary>
/// Constructor
/// </summary>
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.memberService = new MemberService(repFactory);
this.loanService = new LoanService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
ShowAllBooks(bookService.All());
ShowAllAuthors(authorService.All());
ShowAllMembers(memberService.All());
ShowActiveLoans(loanService.GetActiveLoans());
//Observers
bookService.Updated += OnChanged;
authorService.Updated += OnChanged;
memberService.Updated += OnChanged;
loanService.Updated += OnChanged;
bookCopyService.Updated += OnChanged;
loanService.Updated += new EventHandler(OnChangedLoanState);
rbActive.CheckedChanged += new EventHandler(OnChangedLoanState);
rbReturned.CheckedChanged += new EventHandler(OnChangedLoanState);
rbOverdue.CheckedChanged += new EventHandler(OnChangedLoanState);
}
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.authorService = new AuthorService(repFactory);
this.memberService = new MemberService(repFactory);
this.loanService = new LoanService(repFactory);
//Adds event listener to bookService.
this.bookService.Updated += UpdateBookListEvent;
this.bookCopyService.Updated += UpdateBookCopyListEvent;
this.authorService.Updated += UpdatedAuthorEvent;
this.memberService.Updated += UpdateMemberListEvent;
this.loanService.Updated += UpdatedLoansEvent;
UpdateBookList(bookService.All().ToList());
currentBookDisplay = bookService.All().ToList();
currentBookCopyDisplay = new List <BookCopy>();
currentMemberDisplay = memberService.All().ToList();
currentLoanDisplay = loanService.All().ToList();
SetAllColors();
editAuthorTB.AutoCompleteCustomSource.AddRange(authorService.GetAllAuthorNames().ToArray()); //Adds all the current authors to autocomplete list.
}
public UnborrowedBookMonitor(BookCopyService bookCopyService,
IRFIDReader longRangeReader)
{
_BookCopyService = bookCopyService;
longRangeReader.TagRead += LongRangeReader_TagRead;
(longRangeReader as LongRangeRFID).StartReader();
}
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
// Service intialization
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.memberService = new MemberService(repFactory);
this.loanService = new LoanService(repFactory);
// Event declaration
this.bookService.Updated += BookService_Updated;
this.authorService.Updated += AuthorService_Updated;
this.memberService.Updated += MemberService_Updated;
this.loanService.Updated += LoanService_Updated;
this.bookCopyService.Updated += BookCopyService_Updated;
// Start up methods that populate the lists
ShowAllBooks(bookService.All());
ShowAllAuthors(authorService.All());
ShowAvailableCopies(bookCopyService.AllAvailable());
}
public LibraryForm()
{
InitializeComponent();
RepositoryFactory repoFactory = new RepositoryFactory();
_bookService = new BookService(repoFactory);
_bookCopyService = new BookCopyService(repoFactory);
_authorService = new AuthorService(repoFactory);
_loanService = new LoanService(repoFactory);
_memberService = new MemberService(repoFactory);
//Subscribe to event
_bookService.Updated += ListAllBooks;
_bookCopyService.Updated += ListAllBookCopies;
_authorService.Updated += ListAllAuthors;
_loanService.Updated += ListAllLoans;
_memberService.Updated += ListAllMembers;
//Call the event to print to print the "test-objects"
_authorService.OnChanged(this, EventArgs.Empty);
_bookService.OnChanged(this, EventArgs.Empty);
_bookCopyService.OnChanged(this, EventArgs.Empty);
_loanService.OnChanged(this, EventArgs.Empty);
_memberService.OnChanged(this, EventArgs.Empty);
}
/// <summary>
/// Constructor of form.
/// </summary>
public LibraryForm()
{
InitializeComponent();
// Register derived strategy with seed method
Database.SetInitializer <LibraryContext>(new LibraryDbInit());
// We create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// We use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.copyService = new BookCopyService(repFactory);
this.memberService = new MemberService(repFactory);
this.loanService = new LoanService(repFactory);
// All objects that should show up at the start.
ShowAllAuthors(authorService.All());
ShowAllBooks(bookService.All(), lbBooks);
ShowAllBooks(bookService.All(), lbOfBooks);
ShowAllMembers(memberService.All());
ShowAllLoans(loanService.All());
ShowAllCopies(CopyNotOnLoan(), lbCopies);
// Subscribe to event
bookService.Updated += BookService_Updated;
copyService.Updated += CopyService_Updated;
authorService.Updated += AuthorService_Updated;
memberService.Updated += MemberService_Updated;
loanService.Updated += LoanService_Updated;
}
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 ReadAll_Test()
{
// arrange
var fakeUowProvider = A.Fake <IUnitOfWorkProvider>();
var fakeRepoProvider = A.Fake <IBookCopyRepositoryProvider>();
var fakeRepo = A.Fake <IBookCopyRepository>();
var fakeUow = A.Fake <IUnitOfWork>();
A.CallTo(() => fakeUowProvider.Get()).Returns(fakeUow);
A.CallTo(() => fakeRepoProvider.Get(fakeUow)).Returns(fakeRepo);
BookCopyService service = new BookCopyService(fakeUowProvider, fakeRepoProvider);
List <BookCopy> copies = new List <BookCopy>
{
new BookCopy {
Id = 1, BookId = 1, Description = "copy", Notes = "copy"
}
};
A.CallTo(() => fakeRepo.ReadAll()).Returns(copies);
// act
var result = await service.GetAll();
// assert
Assert.IsTrue(result.ToList().Count == 1);
Assert.IsTrue(result.ToList()[0].Id == 1);
Assert.IsTrue(result.ToList()[0].BookId == 1);
Assert.IsTrue(result.ToList()[0].Description.Equals("copy"));
Assert.IsTrue(result.ToList()[0].Notes.Equals("copy"));
A.CallTo(() => fakeUow.Dispose()).MustHaveHappened();
}
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.authorService = new AuthorService(repFactory);
this.memberService = new MemberService(repFactory);
this.loanService = new LoanService(repFactory);
//Can we do this another way?
ShowAllBooks(bookService.All());
AuthorTabShowAllAuthors(authorService.All());
BookTabShowAllAuthors(authorService.All());
MemberTabShowAllMembers(memberService.All());
BookTabBooksByAuthor(authorService.All());
ShowAllBooksInComboBox(bookService.All());
LoanTabShowMembers(memberService.All());
LoanTabShowCopies(bookCopyService.GetAvailableBookCopies(loanService.All(), bookCopyService.All()));
ShowAllLoans(loanService.GetAllCurrentLoans(), loanService.GetAllPreviousLoans(), loanService.GetAllOverdueLoans());
LoanTabShowLoansByMember(memberService.All());
TEST(loanService.All(), bookCopyService.All());
}
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
bookService = new BookService(repFactory);
copyService = new BookCopyService(repFactory);
authorService = new AuthorService(repFactory);
memberService = new MemberService(repFactory);
returnedLoanService = new ReturnedLoanService(repFactory);
loanService = new LoanService(repFactory, returnedLoanService);
ShowAllBooks(bookService.All());
ShowAllBookCopies(copyService.All());
ShowAllMembers(memberService.All());
ShowAllAuthors(authorService.All());
ShowAllLoans(loanService.All());
ShowAllAvailableBooks(copyService.All(), loanService.All());
ShowAllOverDueBooks(copyService.All());
bookService.Updated += BookService_Updated;
authorService.Updated += AuthorService_Updated;
copyService.Updated += CopyService_Updated;
memberService.Updated += MemberService_Updated;
loanService.Updated += LoanService_Updated;
backgroundWorker1.DoWork += BackgroundWorker1_DoWork;
backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
}
public PaymentService()
{
_SectionService = new SectionService();
_BookInfoService = new BookService();
_BookCopyService = new BookCopyService();
_LibraryUserService = new LibraryUserService();
_BookTransactionInfoRepository = new BookTransactionInfoRepository();
}
public AddCopyForm(BookCopyService bookCopyService, BookService bookService, Book book, string bookString)
{
InitializeComponent();
this.bookCopyService = bookCopyService;
this.bookService = bookService;
this.book = book;
tbBook.Text = bookString;
}
public UCAuthorBook(AuthorService aService, BookService bService, BookCopyService bcService, Author author, Book book)
{
InitializeComponent();
pBook = book;
pAuthor = author;
pAuthorService = aService;
pBookService = bService;
pBookCopyService = bcService;
init();
}
public UCBookLoan(AuthorService aService, BookService bService, BookCopyService bcService, LoanService lService, Book book, Loan loan)
{
InitializeComponent();
pAuthorService = aService;
pBookService = bService;
pBookCopyService = bcService;
pLoanService = lService;
pBook = book;
pLoan = loan;
init();
}
public MemberList(MemberService ms, LoanService ls, BookCopyService bk)
{
memberService = ms;
loanService = ls;
bookCopyService = bk;
InitializeComponent();
memberService.Updated += MemberService_Updated;
loanService.Updated += LoanService_Updated;
ShowAllMembers(memberService.All());
}
public UCMemberBook(AuthorService aService, BookService bService, BookCopyService bcService, LoanService lService, MemberService mService, Member member, Book book)
{
InitializeComponent();
pMember = member;
pBook = book;
pAuthorService = aService;
pBookService = bService;
pBookCopyService = bcService;
pLoanService = lService;
pMemberService = mService;
init();
}
public BookForm(AuthorService aa, BookService bb, BookCopyService bc)
{
InitializeComponent();
RepositoryFactory repoFactory = new RepositoryFactory();
_bookService = bb;
_authorService = aa;
_bookCopyService = bc;
_authorService.Updated += ListAllAuthors;
_authorService.OnChanged(this, EventArgs.Empty);
}
public CreateNewLoan(MemberService ms, LoanService ls, int mId, BookCopyService bk)
{
memberService = ms;
loanService = ls;
bookCopyService = bk;
memberId = mId;
InitializeComponent();
bookCopyService.Updated += BookCopyService_Updated;
memberService.Updated += MemberService_Updated;
loanService.Updated += LoanService_Updated;
ShowAvailableCopies(bookCopyService.AllAvailable());
}
public LibraryForm()
{
InitializeComponent();
_authorService = new AuthorService(RepoFactory);
_bookService = new BookService(RepoFactory);
_bookCopyService = new BookCopyService(RepoFactory);
_loanService = new LoanService(RepoFactory);
_memberService = new MemberService(RepoFactory);
_bookService.Updated += bookService_change;
_memberService.Updated += memberService_change;
_loanService.Updated += loanService_change;
_authorService.Updated += authorService_change;
_bookCopyService.Updated += bookCopyService_change;
loanComboBox.SelectedIndex = 0;
ListAll();
}
public async Task DeleteById_Test()
{
// arrange
var fakeUowProvider = A.Fake <IUnitOfWorkProvider>();
var fakeRepoProvider = A.Fake <IBookCopyRepositoryProvider>();
var fakeRepo = A.Fake <IBookCopyRepository>();
var fakeUow = A.Fake <IUnitOfWork>();
A.CallTo(() => fakeUowProvider.Get()).Returns(fakeUow);
A.CallTo(() => fakeRepoProvider.Get(fakeUow)).Returns(fakeRepo);
BookCopyService service = new BookCopyService(fakeUowProvider, fakeRepoProvider);
// act
await service.DeleteById(1);
// assert
A.CallTo(() => fakeRepo.DeleteById(1)).MustHaveHappened();
A.CallTo(() => fakeUow.Dispose()).MustHaveHappened();
}
public LibraryForm()
{
InitializeComponent();
// we create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// we use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.memberService = new MemberService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.loanService = new LoanService(repFactory);
ShowAllBooks(bookService.All());
bookService.Updated += BookService_Updated;
}
public LibraryForm()
{
InitializeComponent();
// Uncomment the line you wish to use
// Use a derived strategy with a Seed-method
Database.SetInitializer <LibraryContext>(new LibraryDbInit());
ContextSingelton.GetContext().Database.Initialize(true);
// Recreate the database only if the models change
//Database.SetInitializer<LibraryContext>(new DropCreateDatabaseIfModelChanges<LibraryContext>());
var test = ContextSingelton.GetContext().Loans.ToList();
var test2 = test.Where(loan => loan.Copy != null).ToList();
// Always drop and recreate the database
//Database.SetInitializer<LibraryContext>(new DropCreateDatabaseAlways<LibraryContext>());
// MessageBox.Show(LibraryDbInit.GetRandomMember(new Random(DateTime.Now.Second)).PersonalID);
authorService = new AuthorService();
bookService = new BookService();
bookCopyService = new BookCopyService();
memberService = new MemberService();
loanService = new LoanService();
SelectedAuthor = null;
SelectedBookCopy = null;
SelectedBook = null;
SelectedLoan = null;
SelectedMember = null;
FirstListBox = SelectedServiceList.SSL_NONE;
authorService.Updated += new EventHandler(AuthorUpdated);
bookService.Updated += new EventHandler(BookUpdated);
loanService.Updated += new EventHandler(LoanUpdated);
memberService.Updated += new EventHandler(MemberUpdated);
lbl_firstbox.Text = string.Empty;
}
public async Task Create_Test()
{
// arrange
var fakeUowProvider = A.Fake <IUnitOfWorkProvider>();
var fakeRepoProvider = A.Fake <IBookCopyRepositoryProvider>();
var fakeRepo = A.Fake <IBookCopyRepository>();
var fakeUow = A.Fake <IUnitOfWork>();
A.CallTo(() => fakeUowProvider.Get()).Returns(fakeUow);
A.CallTo(() => fakeRepoProvider.Get(fakeUow)).Returns(fakeRepo);
BookCopyService service = new BookCopyService(fakeUowProvider, fakeRepoProvider);
BookCopy copy = new BookCopy {
Id = 1, BookId = 1, Description = "copy1", Notes = "copy1"
};
// act
await service.Create(copy);
// assert
A.CallTo(() => fakeRepo.Create(copy)).MustHaveHappened();
A.CallTo(() => fakeUow.Dispose()).MustHaveHappened();
}
public LibraryForm()
{
InitializeComponent();
// We create only one context in our application, which gets shared among repositories
LibraryContext context = new LibraryContext();
// We use a factory object that will create the repositories as they are needed, it also makes
// sure all the repositories created use the same context.
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.loanService = new LoanService(repFactory);
this.memberService = new MemberService(repFactory);
//Set all starting values.
ShowAllBooks(bookService.All());
ShowAllBookCopies(bookCopyService.All());
IEnumerable <Loan> allCurrentLoans = loanService.AllBookCopiesOnLoan();
ShowAllCurrentLoans(allCurrentLoans);
IEnumerable <BookCopy> bookCopiesNotOnLoan = bookCopyService.AllExcept(allCurrentLoans);
ShowAllAvailableCopies(bookCopiesNotOnLoan);
FillDropDownMembers(memberService.All().OrderBy(m => m.Name));
FillDropDownAuthors(authorService.All().OrderBy(a => a.Name));
//Subscribe to the Updated() event in each service to update the GUI when changes in the database has been made.
bookService.Updated += bookUpdated;
bookCopyService.Updated += bookCopyUpdated;
authorService.Updated += authorUpdated;
memberService.Updated += memberUpdated;
loanService.Updated += loanUpdated;
}
public LibraryForm()
{
InitializeComponent();
RepositoryFactory repoFactory = new RepositoryFactory(ContextSingelton.GetContext());
_bookService = new BookService(repoFactory);
_authorService = new AuthorService(repoFactory);
_bookCopyService = new BookCopyService(repoFactory);
_memberService = new MemberService(repoFactory);
_loanService = new LoanService(repoFactory);
// Fills Combos from start
FillComboBoxes();
// Event subsciptions
_bookService.Updated += OnUpdateFillComboBoxes;
_authorService.Updated += OnUpdateFillComboBoxes;
_loanService.Updated += OnUpdateFillComboBoxes;
_memberService.Updated += OnUpdateFillComboBoxes;
_bookCopyService.Updated += OnUpdateFillComboBoxes;
// You need to choose a member to make a loan
LoanBook_Btn.Enabled = false;
}
public LoanForm(LibraryForm libraryForm)
{
InitializeComponent();
LibraryContext context = new LibraryContext();
RepositoryFactory repFactory = new RepositoryFactory(context);
this.bookService = new BookService(repFactory);
this.authorService = new AuthorService(repFactory);
this.memberService = new MemberService(repFactory);
this.bookCopyService = new BookCopyService(repFactory);
this.loanService = new LoanService(repFactory);
this.libraryForm = libraryForm;
ShowAllBooks(bookService.All());
ShowAllBookCopies(bookCopyService.AllAvailableCopies());
ShowAllMembers(memberService.All());
ShowAllAuthors(authorService.All());
ShowAllLoans(loanService.AllCurrentLoans());
ShowAllReturns(loanService.Returns());
loanService.Updated += LoanService_Updated;
}
public BookCopyPageViewModel(BookCopyService bookCopyService)
{
BookCopyService = bookCopyService;
SetupRFIDReader();
}
public AddBookCopyForm(Book book, BookCopyService bookCopyService)
{
BCS = bookCopyService;
selectedBook = book;
InitializeComponent();
}
