/**
    * @version $Revision$ $Date$
    *
    */
   package org.sourceforge.vlibrary.user.logic;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.sourceforge.vlibrary.Constants;
  import org.sourceforge.vlibrary.exceptions.LibraryException;
  import org.sourceforge.vlibrary.user.dao.AuthorDAO;
  import org.sourceforge.vlibrary.user.dao.BookDAO;
  import org.sourceforge.vlibrary.user.dao.LibraryTransactionDAO;
  import org.sourceforge.vlibrary.user.dao.LocationDAO;
  import org.sourceforge.vlibrary.user.dao.ReaderDAO;
  import org.sourceforge.vlibrary.user.dao.SubjectDAO;
  import org.sourceforge.vlibrary.user.domain.Author;
  import org.sourceforge.vlibrary.user.domain.Book;
  import org.sourceforge.vlibrary.user.domain.Location;
  import org.sourceforge.vlibrary.user.domain.Reader;
  import org.sourceforge.vlibrary.user.domain.Subject;
  import org.sourceforge.vlibrary.user.exceptions.BookAwaitingPickupException;
  import org.sourceforge.vlibrary.user.exceptions.BookNotFoundException;
  import org.sourceforge.vlibrary.user.exceptions.DuplicateRequestException;
  import org.sourceforge.vlibrary.user.exceptions.ReaderNotFoundException;
  import org.sourceforge.vlibrary.user.valuebeans.BookMoveTransaction;
  import org.sourceforge.vlibrary.user.valuebeans.LibraryTransaction;
  import org.sourceforge.vlibrary.user.workers.MailWorker;
  import org.sourceforge.vlibrary.util.Crypto;
  import org.sourceforge.vlibrary.util.SruSrwClientInterface;
  import org.springframework.context.support.ResourceBundleMessageSource;
  
  /**
   * Implementation of {@link LibraryManagerFacade} interface providing
   * the business logic functions for the Virtual Library. Data access is
   * mediated by DAO objects, which are instantiated using Spring dependency
   * injection.
   *
   */
  
  public class LibraryManager {
      private ResourceBundleMessageSource resourceBundleMessageSource;
  
      /** log4j category */
      private static Logger logger =
              Logger.getLogger(LibraryManager.class.getName());
  
      // DAO instances - injected by Spring
      private AuthorDAO authorDAO;
      private BookDAO bookDAO;
      private ReaderDAO readerDAO;
      private SubjectDAO subjectDAO;
      private LocationDAO locationDAO;
      private LibraryTransactionDAO libraryTransactionDAO;
      private MailWorker mailWorker;
      private Crypto crypto;
      private SruSrwClientInterface sruClient;
  
  
      //-------------------------------------------------------------------------
      // Setter methods for dependency injection
      //-------------------------------------------------------------------------
  
      /**
       * Used for Spring Dependency Injection
       */
      public void setResourceBundleMessageSource(
              ResourceBundleMessageSource resourceBundleMessageSource) {
          this.resourceBundleMessageSource = resourceBundleMessageSource;
      }
  
      /**
       * @param mailWorker The mailWorker to set.
       */
      public void setMailWorker(MailWorker mailWorker) {
          this.mailWorker = mailWorker;
      }
  
      /**
       * @param authorDAO The authorDAO to set.
       */
      public void setAuthorDAO(AuthorDAO authorDAO) {
          this.authorDAO = authorDAO;
      }
  
      /**
       * @param bookDAO The bookDAO to set.
       */
      public void setBookDAO(BookDAO bookDAO) {
          this.bookDAO = bookDAO;
      }
  
      /**
       * @param readerDAO The readerDAO to set.
      */
     public void setReaderDAO(ReaderDAO readerDAO) {
         this.readerDAO = readerDAO;
     }
 
     public ReaderDAO getReaderDAO() {
         return this.readerDAO;
     }
 
     /**
      * @param subjectDAO The subjectDAO to set.
      */
     public void setSubjectDAO(SubjectDAO subjectDAO) {
         this.subjectDAO = subjectDAO;
     }
 
     /**
      * @param libraryTransactionDAO The libraryTransactionDAO to set.
      */
     public void setLibraryTransactionDAO(
             LibraryTransactionDAO libraryTransactionDAO) {
         this.libraryTransactionDAO = libraryTransactionDAO;
     }
 
     /**
      * Used for Spring Dependency Injection
      */
     public void setCrypto( Crypto crypto) {
         this.crypto = crypto;
     }
 
     /**
      * @param subjectDAO The subjectDAO to set.
      */
     public void setLocationDAO(LocationDAO locationDAO) {
         this.locationDAO = locationDAO;
     }
 
     /**
      * Used for Spring Dependency Injection
      */
     public void setSruSrwClientInterface( SruSrwClientInterface sruClient) {
         this.sruClient = sruClient;
     }
 
     //-------------------------------------------------------------------------
     // Operation methods
     //-------------------------------------------------------------------------
 
     /**
      * Returns an ArrayList including all subjects currently defined in the
      * Virtual Library.
      *
      * @return list of currently defined subjects
      * @throws LibraryException if an error occurs retrieving the list of
      * subjects
      */
     public ArrayList<Subject> getSubjects() throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("");
         }
 
         return subjectDAO.getSubjects();
     }
 
     /**
      * Walks the input ArrayList of {@link org.sourceforge.vlibrary.user.domain.Subject} instances, looking up and
      * setting ID properties for each Subject in the list.  Lookup is based on
      * the description property. If a Subject is not found, a new entry is
      * inserted into the database and the ID of the newly created record is
      * assigned to the instance.
      *
      * @param subjects ArrayList of Subjects
      * @exception LibraryException if a data access error occurs
      */
     public void createSubjectIds(ArrayList<Subject> subjects) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(subjects);
         }
 
         subjectDAO.setSubjectIds(subjects);
     }
 
     /**
      * Returns an ArrayList including all currently defined locations.
      *
      * @return list of currently defined locations
      * @throws LibraryException if an error occurs retrieving the list of
      * subjects
      */
     public ArrayList<Location> getLocations() throws LibraryException {
         if (logger.isDebugEnabled()) {
             final String message = resourceBundleMessageSource.getMessage("retrieving.locations",
                     new Object[] { new String("") }, Locale.US);
             logger.debug(message);
         }
         try {
             return locationDAO.getLocations();
         } catch (final Exception ex) {
             final String errString = resourceBundleMessageSource.getMessage("error.retrieving.locations",
                     new Object[] { new String("") }, Locale.US);
             logger.error(errString, ex);
             throw new LibraryException(errString);
         }
 
     }
 
     /**
      * Determines whether or not the supplied desk phone number belongs to a
      * reader.
      *
      * @param phoneNo  phone number to validate
      * @return true if the phone mumber belongs to a Virtual Library reader
      * @throws LibraryException if a data access error occurs validating
      * the phone number
      */
     public boolean isUserValidByPhone(String phoneNo) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("phoneNo="+phoneNo);
         }
 
         final Reader rd = readerDAO.retrieveByPhone(phoneNo);
 
         if (rd == null) {
             return false;
         } else {
             return true;
         }
     }
 
     /**
      * <p>Returns the ID of the reader who has the given desk phone.
      * </p>
      * Returns <code>0</code> if there is no reader with the given desk
      * phone.
      *
      * @param phoneNo the desk phone to look up
      * @return the ID of the reader, or 0 if not found
      * @throws LibraryException if a data access error occurs
      */
     public long retrieveIDByPhone(String phoneNo) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("phoneNo=" + phoneNo);
         }
 
         Reader rd = new Reader();
 
         rd = readerDAO.retrieveByPhone(phoneNo);
 
         if ( rd == null) {
             return 0;
         }
 
         return rd.getId();
     }
 
     /**
      * Determines whether or not the given ID corresponds to a reader.
      *
      * @param id ID to validate
      * @return true if the ID belongs to a reader; false otherwiase
      * @throws LibraryException if a data access error occurs looking up the ID
      */
     public boolean isUserIDValid(long id) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("userId" + id);
         }
 
         return readerDAO.readerExists(id);
     }
 
     /**
      * Determines whether or not the given UID (user id) belongs to a reader.
      *
      * @param id UID to validate
      * @return true if the UID belongs to a reader; false otherwise
      * @throws LibraryException if a data access error occurs looking up
      * the UID
      */
     public boolean isUserIDValid(String UID)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("userId" + UID);
         }
 
         return readerDAO.uidExists(UID);
     }
 
     /**
      * Determines whether or not there is a reader with the given first and
      * last name.
      *
      * @param firstName first name
      * @param lastName  last name
      * @return true if there is a reader with the given first and last name;
      * false otherwise
      * @throws LibraryException if a data access error occurs
      */
     public boolean readerExists(String firstName, String lastName)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(
                     "firstName="+firstName + ", lastName=" + lastName);
         }
 
         return readerDAO.readerExists( firstName, lastName);
     }
 
     /**
      * Determines whether or not there is a reader with the given ID.
      *
      * @param id the ID to validate
      * @return true if there is a reader with the given ID;
      * false otherwise
      * @throws LibraryException if a data access error occurs
      */
     public boolean readerExists(long id) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("reader="+id);
         }
 
         return readerDAO.readerExists(id);
     }
 
     /**
      * Determines whether or not there is a reader with the given
      * desk phone.
      *
      * @param deskPhone the phone number to validate
      * @return true if there is a reader with the given desk phone;
      * false otherwise
      * @throws LibraryException if a data access error occurs
      */
     public boolean deskPhoneExists(String deskPhone) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("deskPhone="+deskPhone);
         }
 
         return readerDAO.deskPhoneExists(deskPhone);
     }
 
     /**
      * Returns an <code>ArrayList</code> of {@link Reader} instances including
      * all currently registered Virtual Library readers.
      *
      * @return all readers in the database
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Reader> getReaders() throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("");
         }
 
         return readerDAO.getReaders();
     }
 
     /**
      * Returns the {@link LibraryTransaction} with the given transaction id.
      *
      * @param id the ID of the transaction to retrieve
      * @throws LibraryException if a data access error occurs retrieving the
      * transaction
      */
     public LibraryTransaction retrieveTransaction(long id)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("tranId="+id);
         }
 
         return libraryTransactionDAO.retrieve(id );
     }
 
     /**
      * Returns a list including all {org.sourceforge.vlibrary.user.domain.Author}s with the the given
      * last name.
      *
      * @param authorLastName the last name to look up
      * @return list of author instances
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Book> authorSearch(String authorLastName)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("authorLastName="+authorLastName);
         }
 
         return bookDAO.authorSearch( authorLastName );
     }
 
     /**
      * Returns an ArrayList of {@link Book} instances consisting of all books
      * associated with one or more of the {@link org.sourceforge.vlibrary.user.domain.Subject}s in the input array.
      *
      * @param subjects list of subjects
      * @return list of associated books
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Book> subjectOrSearch(ArrayList<Subject> subjects)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(subjects);
         }
 
         return bookDAO.subjectOrSearch( subjects );
     }
 
     /**
      * Returns an ArrayList of {@link Book} instances consisting of all books
      * that are associated with <strong>all</strong> of the {@link org.sourceforge.vlibrary.user.domain.Subject}s
      * in the input array.
      *
      * @param subjects list of subjects
      * @return list of associated books
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Book> subjectAndSearch(ArrayList subjects)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(subjects);
         }
 
         return bookDAO.subjectAndSearch(subjects);
     }
 
     /**
      * Returns an ArrayList of {@link Book} instances consisting of all books
      * that are owned by the reader with the given ID.
      *
      * @param owner ID of owner
      * @return list of books owned
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Book> ownerSearch(long owner)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("owner="+owner);
         }
 
         return bookDAO.ownerSearch( owner );
     }
 
     /**
      * Returns an ArrayList of {@link Book} instances consisting of all books
      * having the given title.
      *
      * @param title title to look for
      * @return list of books with the given title
      * @throws LibraryException if a data access error occurs
      */
     public  ArrayList<Book> titleSearch(String title)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("bookTitle="+title);
         }
 
         return bookDAO.titleSearch( title );
     }
 
     /**
      * Returns an ArrayList of {@link Book} instances consisting of all books
      * in the library.
      *
      * @return list of all books
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Book> dump()
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("");
         }
 
         return bookDAO.dump();
     }
 
     /**
      * <p>Retrieves a {@link Reader} by user id (UID).
      * </p>
      * <p>Returns <code>null</code> if the supplied uid is not associated
      * with a reader in the datablase.
      *
      * @param uid the UID of the reader to lookup
      * @return the reader with the given uid; or null if there is no such
      * reader
      * @throws LibraryException if a data access error occurs
      */
     public Reader retrieveByUid(String uid) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("readerUid="+uid);
         }
 
         return readerDAO.retrieveByUid( uid );
     }
 
     /**
      * Returns an ArrayList of {@link }Author} instances including the authors
      * of the given book.
      *
      * @param book the book
      * @return list of authors of the book
      * @throws LibraryException if a data access error occurs
      */
     public ArrayList<Author> getAuthors(Book book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString());
         }
 
         return bookDAO.getAuthors(book);
     }
 
     /**
      * Returns an ArrayList including all subjects currently defined in the
      * Virtual Library.
      *
      * @return list of currently defined subjects
      * @throws LibraryException if an error occurs retrieving the list of
      * subjects
      */
     public ArrayList<Subject> getSubjects(Book book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString());
         }
 
         return bookDAO.getSubjects(book);
     }
 
 
     /**
      * Processes a book checkin or checkout transaction. Records the
      * transaction in the transaction table and sends appropriate
      * email notifications. Returns a {@link BookMoveTransaction} representing
      * the transaction.
      * <p>
      * Delegates to one of {@link #processCheckin(long, long)} or
      * {@link #processCheckout(long, long)}, depending on the
      * <code>transactionType</code>, which must be either
      * <code>Contants.CHECKIN</code> or <code>Contants.CHECKOUT</code>.
      * </p>
      *
      * @param reader the id of the reader initiating the transaction
      * @param book the id of the book being checked in or out
      * @param transactionType transaction type - must be either
      * <code>Contants.CHECKIN</code> or <code>Contants.CHECKOUT</code>
      * @param location the location of the checkin or checkout
      * @return the resulting transaction
      * @throws LibraryException if an error occurs processing the transaction,
      * or if the parameters are not valid
      */
     public BookMoveTransaction processExchange(long reader, long book, String transactionType, long location)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             String message;
             if (transactionType.equals(Constants.CHECKIN)) {
                 message = resourceBundleMessageSource.getMessage("trans.checking.in", new Object[] {
                         (new Long(reader)).toString(), (new Long(book)).toString(), Long.toString(location) },
                         Locale.US);
             } else {
                 message = resourceBundleMessageSource.getMessage("trans.checking.out", new Object[] {
                         (new Long(reader)).toString(), (new Long(book)).toString(), Long.toString(location) },
                         Locale.US);
             }
             logger.debug(message);
         }
 
         Book bk = new Book();
         bk.setId(book);
 
         try {
             bk = bookDAO.retrieve(book);
             if (bk == null) {
                 throw new Exception();
             }
         } catch (final Throwable e) {
             final String errString = resourceBundleMessageSource.getMessage("error.book.retrieve",
                     new Object[] { bk == null ? "" : bk.toString() }, Locale.US);
             logger.error(errString, e);
             throw new LibraryException(errString, e);
         }
 
         Reader rd = new Reader();
         try {
             rd = readerDAO.retrieveById(reader);
             if (rd == null) {
                 throw new Exception();
             }
         } catch (final Throwable e) {
             final String errString = resourceBundleMessageSource.getMessage("error.reader.retrieve",
                     new Object[] { rd == null ? "" : rd.toString() }, Locale.US);
             logger.error(errString, e);
             throw new LibraryException(errString, e);
         }
 
         // Fire transaction -- checkin or checkout
         try {
             if (transactionType.equals(Constants.CHECKIN)) {
                 processCheckin(reader, book, location);
             } else if (transactionType.equals(Constants.CHECKOUT)) {
                 processCheckout(reader, book, location);
             } else {
                 final String errString = resourceBundleMessageSource.getMessage("error.trans.request.badrequest",
                         new Object[] { (new Long(reader)).toString(), (new Long(book)).toString() }, Locale.US);
                 logger.error(errString);
                 throw new LibraryException(errString);
             }
         } catch (final Throwable e) {
             final String errString = resourceBundleMessageSource.getMessage("error.trans.request.badrequest",
                     new Object[] { (new Long(reader)).toString(), (new Long(book)).toString() }, Locale.US);
             logger.error(errString, e);
             throw new LibraryException(e.getMessage(), e);
         }
 
         // Put a BookMoveTransaction VO in the request for confirmation page
         final BookMoveTransaction t = new BookMoveTransaction();
         t.setReaderEmail(rd.getEmail());
         t.setReaderName(rd.getFirstName() + " " + rd.getLastName());
         t.setBookTitle(bk.getTitle());
         t.setTransaction(transactionType);
         t.setLocation(location);
 
         if (logger.isDebugEnabled()) {
             final String message = resourceBundleMessageSource.getMessage("trans.checkin.successful", new Object[] {
                     (new Long(reader)).toString(), (new Long(book)).toString(), Long.toString(location) }, Locale.US);
             logger.debug(message);
         }
 
         return t;
     }
 
     /**
      * Determines whether or not there is a book with the given id.
      *
      * @param book id to check
      * @return true if there is a book with the given id; false otherwise
      */
     public boolean bookExists(long book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("book="+book);
         }
 
         return bookDAO.bookExists(book);
     }
 
     /**
      * <p>Returns the ID of a reader with the given first and last name, if
      * there is such a reader, throwing <code>LibraryException</code> if
      * there is no reader with the given name.
      * </p>
      * <p>Does not check for uniqueness - i.e., if there is more than one
      * reader with the given first and last name, no exception is generated.
      * </p>
      *
      * @param firstName the first name of the reader
      * @param lastName the last name of the reader
      * @return the ID of a reader with the given name
      * @throws LibraryException if no such reader exists or a data access
      * error occurs looking up the reader
      *
      */
     public long getReaderID(String firstName,String lastName)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(
                     "firstname=" +firstName + ", lastName=" + lastName);
         }
 
         return readerDAO.getReaderID( firstName, lastName );
     }
 
     /**
      * Walks input ArrayList, looking up and setting ID properties for
      * each Author in the list.  Lookup is based on first name + last name.
      * If an Author is not found, a new entry is inserted into the database
      * and the ID of the newly created record is assigned to the instance.
      *
      * @param authors = ArrayList of Authors
      * @exception LibraryException
      */
     public void createAuthorIds(ArrayList<Author> authors) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(authors);
         }
 
         authorDAO.setAuthorIds(authors);
     }
 
     /**
      * Returns the book with the given ID, or <code>null</code> if there is no
      * such book.
      *
      * @param bookID the ID of the book
      * @return the <code>Book</code> instance with the given ID
      * @throws LibraryException if a data access error occurs
      */
     public Book retrieveBook(long bookID) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("book=" + bookID);
         }
 
         return bookDAO.retrieve(bookID);
     }
 
     /**
      * Returns a fully populated <code>Reader</code> corresponding to the
      * reader having the given ID. Returns <code>null</code> if there is no
      * such reader.
      *
      * @param id the ID to lookup
      * @return fully populated <code>Reader</code> instance
      * @throws LibraryException f a data access error occurs
      */
     public Reader retrieveReader( long id ) throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug("reader=" + id);
         }
 
         return readerDAO.retrieveById( id );
     }
 
     /**
      * Sets the authors for the given book. Creates author records in the
      * database for any authors that do not exist and associates the given
      * list of authors with the book. Updates IDs of authors in the list to
      * match database entries for those that already exist in the database.
      *
      * @param book the book to attach authors to
      * @param authors the authors of the book
      * @throws LibraryException if an error occurs accessing the database or
      * the ID of the given Book does not correspond to a book in the database
      */
     public void createBookAuthors(Book book, ArrayList<Author> authors)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString() + authors);
         }
 
         bookDAO.setAuthors( book, authors );
     }
 
     /**
      * Sets the subjects for the given book. Creates subject records in the
      * database for any authors that do not exist and associates the given
      * list of authors with the book. Updates IDs of authors in the list to
      * match database entries for those that already exist in the database.
      *
      * @param book the book to attach subjects to
      * @param subjects the subjects of the book
      * @throws LibraryException if an error occurs accessing the database or
      * the ID of the given Book does not correspond to a book in the database
      */
     public void createBookSubjects(Book book, ArrayList<Subject> subjects)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString() +  subjects);
         }
 
         bookDAO.setSubjects( book, subjects );
     }
 
     /**
      * <p>Creates a book in the database and associates the given lists of
      * subjects and authors with the book. Authors and subjects are created
      * in the database if they do not already exist. Returns a new
      * <code>Book</code> instance with the ID set to the database ID of the
      * newly created book.
      * </p>
      * <p>The supplied book must have minimally a title and isbn, otherwise
      * a LibraryException is thrown.
      * </p>
      *
      * @param book the book to create
      * @param subjects the subjects to associate with the book
      * @param authors the authors of the book
      * @return a <code>Book</code> instance with the ID of the newly created
      * book
      * @throws LibraryException if the supplied book does not have sufficient
      * data or a database access error occurs
      */
     public Book createBook(Book book, ArrayList<Subject> subjects, ArrayList<Author> authors)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString() + subjects + authors);
         }
         // Create the book in the database and set the id to the db-generated ID
         book = bookDAO.insert(book);
         // Associate the authors and subjects with the book
         bookDAO.setAuthors(book, authors);
         bookDAO.setSubjects(book, subjects);
         return book;
     }
 
     /**
      * Updates the database record associated with <code>book</code> with the
      * properties that the given instance has.  Uses the ID property to locate
      * the record to update.  If the ID does not correspond to a book in the
      * database, a <code>LibraryException</code> is thrown.
      *
      * @param book the book to update
      * @throws LibraryException if the book does not exist, or a data access
      * error occurs
      */
     public void updateBook(Book book) throws
     LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(book.toString());
         }
 
         bookDAO.update( book );
     }
 
     /**
      * <p>Inserts a record corresponding to the given reader into the database.
      * </p>
      * <p>Ignores the ID field on input, but sets this field to the value of the
      * database ID of the newly created reader.</p>
      * <p>Throws <code>LibraryException</code> if the reader is missing
      * first name, last name, email or desk phone properties; or if the email
      * or desk phone already exist in the database.</p>
      *
      * @param reader the reader to add
      * @throws LibraryException if the reader is a duplicate, is missing data,
      * or a data access error occurs
      */
     public void insertReader(Reader reader)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug( reader.toString() );
         }
 
         readerDAO.insert(reader);
     }
 
     /**
      * Updates the database record associated with <code>reader</code> with the
      * properties that the given instance has.  Uses the ID property to locate
      * the record to update.  If the ID does not correspond to a reader in the
      * database, a <code>LibraryException</code> is thrown.
      *
      * @param reader the reader to update
      * @throws LibraryException if the reader does not exist, or a data access
      * error occurs
      */
     public void updateReader(Reader reader)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(reader.toString());
         }
 
         readerDAO.update(reader);
     }
 
     /**
      * <p>Processes book checkin transaction.
      * </p>
      * <p>Records the checkin in the transaction table and sends email
      * notifications to current requesters.
      * </p>
      * <p>Allows redundant checkins - i.e., a book that is already checked in
      * can be checked in again.</p>
      *
      * @param book the id of the book being checked in
      * @param reader the id of the reader checking in the book
      * @param location the id of the location of the transaction
      * @throws LibraryException if an error occurs recording the checkin or
      * sending notifications
      */
     public void processCheckin(long reader, long book, long location) throws LibraryException {
         if (logger.isInfoEnabled()) {
             final String message = resourceBundleMessageSource.getMessage("trans.checking.in", new Object[] {
                     (new Long(reader)).toString(), (new Long(book)).toString(), Long.toString(location) }, Locale.US);
             logger.info(message);
         }
         libraryTransactionDAO.processCheckin(reader, book, location);
 
         // send mail to current requesters
         Book bk = new Book();
         bk.setId(book);
         bk = retrieveBook(book);
         final ArrayList<Reader> requestors = getRequestors(book, location);
 
         for (int i = 0; i < requestors.size(); i++) {
             final Reader rd = requestors.get(i);
             try {
                 mailWorker.sendReturnNotification(rd, bk, locationDAO.getLocationDescription(location));
             } catch (final Exception ex) {
                 final String errString = resourceBundleMessageSource.getMessage("error.trans.checkin",
                         new Object[] { (new Long(reader)).toString(), (new Long(book)).toString() }, Locale.US);
 
                 logger.error(errString, ex);
             }
         }
 
         // log the transaction
         if (logger.isInfoEnabled()) {
             logger.info(resourceBundleMessageSource.getMessage("trans.checkin.successful",
                     new Object[] { Long.toString(reader), Long.toString(book), Long.toString(location) }, Locale.US));
         }
     }
 
 
     /**
      * <p>Processes book checkout transaction.
      * </p>
      * <p>Records the checkout in the transaction table and sends email
      * notifications to current requesters.
      * </p>
      *
      * @param book the id of the book being checked out
      * @param reader the id of the reader checking out the book
      * @param location the id of the location of the transaction
      * @throws LibraryException if an error occurs recording the checkout or
      * sending notifications
      */
     public void processCheckout(long reader, long book, long location)
             throws LibraryException {
 
         // log the transaction
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "trans.checking.out",
                     new Object[] {(new Long(reader)).toString(),
                             (new Long(book)).toString()},
                     Locale.US));
         }
 
         // verify that the reader and the book both exist
         if (!readerDAO.readerExists(reader)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.reader",
                     new Object[] {  new Long(reader) },
                     Locale.US);
             logger.error(errString);
             throw new ReaderNotFoundException(errString);
         }
 
         if (!bookExists(book)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.book",
                     new Object[] {  new Long(book) },
                     Locale.US);
             logger.error(errString);
             throw new BookNotFoundException(errString);
         }
 
         // Construct newPossessor Reader object
         Reader newPossessor = new Reader();
         newPossessor.setId(reader);
         newPossessor = readerDAO.retrieve(newPossessor);
 
         // Perform checkout and cancel any requests that the reader has for <book.isbn, location>
         libraryTransactionDAO.processCheckout(reader, book, bookDAO.getIsbn(book), location);
 
         // send mail to current requesters
         final Book bk = bookDAO.retrieve(book);
         final ArrayList<Reader> requestors = getRequestors(book, location);
         for (int i=0; i<requestors.size(); i++) {
             final Reader requestor = requestors.get(i);
             try {
                 mailWorker.sendCheckoutNotification(requestor,newPossessor, bk,
                         locationDAO.getLocationDescription(location));
             } catch( final Exception ex) {
                 final String errString =
                         resourceBundleMessageSource.getMessage(
                                 "error.trans.checkout",
                                 new Object[] {(new Long(reader)).toString(),
                                         (new Long(book)).toString()},
                                 Locale.US);
 
                 logger.error(errString, ex);
             }
         }
 
         // log the transaction
         if (logger.isDebugEnabled()) {
             logger.info(resourceBundleMessageSource
                     .getMessage("trans.checkout.successful",
                             new Object[] {
                                     Long.toString(reader), Long.toString(book),
                                     Long.toString(location)
                     }, Locale.US));
         }
     }
 
     /**
      * Queries the transaction table to determine the whereabouts of a book.
      * Returns the id of the reader who is currently holding the book.
      * If the book is "checked in", returns <code>CHECKED_IN.</code>
      *
      * <p>If there are no transactions associated with the book,
      * then the book's owner is assumed to have the book, so the
      * owner's ID is returned in this case.</p>
      *
      * @param book the id of the book being sought
      * @exception LibraryException will be thrown if the book does not exist
      * or a data access error occurs
      */
     public long getPossessor(long book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "retrieving.book.possesor",
                     new Object[] {(new Long(book)).toString()},
                     Locale.US));
         }
 
         if (!bookExists(book)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.book",
                     new Object[] {  new Long(book) },
                     Locale.US);
             logger.error(errString);
             throw new BookNotFoundException(errString);
         }
 
         final long result = libraryTransactionDAO.getPossessor(book);
 
         if (result == Constants.CHECKED_IN || readerExists(result)) {
             return result;
         }
 
         // No checkout/checkin transactions, so assume owner has the book
         Book bk = new Book();
         bk.setId(book);
         bk = bookDAO.retrieve(book);
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "retrieving.book.possesor.successful",
                     new Object[] {(new Long(book)).toString()},
                     Locale.US));
         }
         return bk.getOwner();
     }
 
     /**
      * Processes book request transaction. Records request(s) in transaction
      * table, sends email notification to possessors and confirmation email to
      * requester.
      * <p>
      * The algorithm works as follows:
      * First, we get a list of all copies of the given book whose last known location
      * is the given location.  If there are no such copies, BookNotFoundAtLocationException
      * is thrown.  If the reader has a pending request for one of these copies,
      * DuplicateRequestException is thrown.  If any are checked in, BookAwaitingPickupException
      * is thrown.
      * Otherwise, a request is created for each of the copies and the current possessor of each
      * is notified.
      *
      * @param book the id of the book being requested
      * @param reader the id of the reader making the request
      * @param location the location where the book is being requested
      * @exception LibraryException if an error occurs processing the
      * transaction
      * @exception DuplicateRequestException if the requester already has a
      * request pending for the book
      * @exception ReaderNotFoundException if the <code>reader</code> is not
      * found
      */
     public void processRequest(long reader, long book, long location)
             throws Exception {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "processing.request",
                     new Object[] {(new Long(reader)).toString(),
                             (new Long(book)).toString()},
                     Locale.US));
         }
 
         // verify that the reader and the book both exist
         if (!readerExists(reader)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.reader",
                     new Object[] {  new Long(reader) },
                     Locale.US);
             logger.error(errString);
             throw new ReaderNotFoundException(errString);
         }
 
         if (!bookExists(book)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.book",
                     new Object[] {  new Long(book) },
                     Locale.US);
             logger.error(errString);
             throw new BookNotFoundException(errString);
         }
 
         final String isbn = bookDAO.retrieve(book).getIsbn();
         // Get list of all copies of the book whose last known location is location
         final long[] copies = libraryTransactionDAO.getCopies(isbn, location);
         if (copies.length == 0) { // There is no copy of the book associated with the location
             // Record the request
             libraryTransactionDAO.processRequest(reader, book, location);
             Reader requestor = new Reader();
             Book bk = new Book();
             bk.setId(book);
             bk = bookDAO.retrieve(book);
             requestor.setId(reader);
             requestor = readerDAO.retrieve(requestor);
             // Notify the admin
             final String locationString = locationDAO.getLocationDescription(location);
             mailWorker.sendAcquisitionNotification(requestor, bk, locationString);
             // Send request confirmation
             mailWorker.sendAcquisitionRequestConfirmation(requestor, bk, locationString);
         }
         // Walk the list - throw BookAwaitingPickupException if any are in; otherwise
         // add a request transaction and send notifications for each one
         for (int i = 0; i < copies.length; i++) {
             if (requestPending(reader, copies[i])) {
                 final String warning = resourceBundleMessageSource.getMessage(
                         "error.trans.duplicate.request",
                         new Object[] {  (new Long(reader)).toString(),
                                 Long.valueOf(copies[i]).toString()},
                         Locale.US);
                 logger.warn(warning);
                 throw new DuplicateRequestException(warning);
             }
             final long possessorId = getPossessor(copies[i]);
             if (possessorId == Constants.CHECKED_IN) {
                 throw new BookAwaitingPickupException();
             }
             libraryTransactionDAO.processRequest(reader, copies[i], location);
             Reader possessor = new Reader();
             Reader requestor = new Reader();
             Book bk = new Book();
             bk.setId(copies[i]);
             bk = bookDAO.retrieve(copies[i]);
             possessor.setId(possessorId);
             possessor = readerDAO.retrieve(possessor);
             requestor.setId(reader);
             requestor = readerDAO.retrieve(requestor);
             mailWorker.sendRequestNotification(possessor, requestor, bk,
                     locationDAO.getLocationDescription(location));
             mailWorker.sendRequestConfirmation(possessor, requestor, bk,
                     locationDAO.getLocationDescription(location));
         }
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "request.processed",
                     new Object[] {(new Long(reader)).toString(),
                             (new Long(book)).toString()},
                     Locale.US));
         }
     }
 
     /**
      * Gets the list of readers with outstanding requests for a copy of the book in the given location.
      *
      * @param book id of the book (used to get the ISBN to search for)
      * @param location id of location
      * @return list of requesters who have requested a copy of the book in the given location
      * @throws LibraryException
      */
     private ArrayList<Reader> getRequestors(long book, long location)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "retrieving.requesters",
                     new Object[] {Long.toString(book), Long.toBinaryString(location)},
                     Locale.US));
         }
 
         final Book bk = retrieveBook(book);
         final List<Long> readerIdList = libraryTransactionDAO.getRequestors(bk.getIsbn(), location);
         final ArrayList<Reader> outList = new ArrayList<Reader>();
         final Iterator<Long> it = readerIdList.iterator();
 
         while(it.hasNext()) {
             final Long readerId = it.next();
             Reader rd = new Reader();
             rd.setId(readerId);
             rd = readerDAO.retrieve(rd);
             if ( rd != null ) {
                 outList.add(rd);
             }
         }
 
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "requesters.retrieved",
                     new Object[] {Long.toString(book), Long.toString(location), Integer.toString(outList.size())},
                     Locale.US));
         }
 
         return outList;
     }
 
 
     /**
      * Determines whether or not a reader has a request pending for a book.
      *
      * @param reader the ID of the reader
      * @param book the ID of the book
      * @return true if the reader with ID <code>reader</code> has a request
      * pending for the book with ID <code>book</code>; false otherwise
      * @throws LibraryException if a data access error occurs
      */
     public boolean requestPending(long reader,long book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(
                     "reader=" + reader+ ", book=" + book);
         }
 
         return libraryTransactionDAO.requestPending( reader, book );
     }
 
     /**
      * Cancels a pending request for a book and sends confirmation email to
      * the reader canceling the request.
      *
      * @param reader the ID of the reader canceling the request
      * @param book the ID of the book
      * @throws LibraryException if the reader or book does not exist, or if
      * there is an error canceling the request
      */
     public void cancelRequest(long reader, long book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "cancelling.request",
                     new Object[] {(new Long(reader)).toString(),
                             (new Long(book)).toString()},
                     Locale.US));
         }
 
         // verify that the reader and the book both exist
         if (!readerDAO.readerExists(reader)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.reader",
                     new Object[] {  new Long(reader) },
                     Locale.US);
             logger.error(errString);
             throw new ReaderNotFoundException(errString);
         }
 
         if (!bookExists(book)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.book",
                     new Object[] {  new Long(book) },
                     Locale.US);
             logger.error(errString);
             throw new BookNotFoundException(errString);
         }
 
         libraryTransactionDAO.cancelRequest(reader, retrieveBook(book).getIsbn());
 
         // send confirmation email
         final Book bk = bookDAO.retrieve(book);
         Reader rd = new Reader();
         rd.setId(reader);
         rd = readerDAO.retrieve(rd);
         try {
             mailWorker.sendDeleteConfirmation(rd,bk);
         } catch( final Exception ex) {
             logger.error(ex);
         }
 
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "request.cancelled",
                     new Object[] {(new Long(reader)).toString(),
                             (new Long(book)).toString()},
                     Locale.US));
         }
     }
 
     /**
      * Gets the entire transaction history for a book and returns
      * an ArrayList of {@link LibraryTransaction} instances.
      *
      * @param book id of the book to retrieve transactions for
      * @throws LibraryException if a data access error occurs
      */
     public List<LibraryTransaction> getTransactions(long book)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "retrieving.transactions",
                     new Object[] {(new Long(book)).toString()},
                     Locale.US));
         }
 
         if (!bookExists(book)) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.book",
                     new Object[] {new Long(book)},
                     Locale.US);
             logger.error(errString);
             throw new BookNotFoundException(errString);
         }
 
         // Create dummy "add" transaction
         final Book bk = bookDAO.retrieve(book);
         final LibraryTransaction trans = new LibraryTransaction();
         trans.setBook(book);
         trans.setBookTitle(bk.getTitle());
         final long reader = bk.getOwner();
         trans.setReader(reader);
         Reader rd = new Reader();
         rd.setId(reader);
         rd = readerDAO.retrieve(rd);
         if (rd != null) {
             trans.setReaderName(rd.getFirstName() + " " + rd.getLastName());
             trans.setReaderPhone(rd.getDeskPhone());
             trans.setTimeString(bk.getCreated());
             trans.setAction(Constants.ADD_ACTION);
             final String action = resourceBundleMessageSource.getMessage(
                     "trans.add.label",
                     null,
                     Locale.US);
             trans.setActionString( action );
         }
 
         // Create output list, starting with dummy add transaction
         final ArrayList<LibraryTransaction> result = new ArrayList<LibraryTransaction>();
         result.add(trans);
 
         // Get actual transactions for the book and append to output list
         result.addAll(libraryTransactionDAO.getTransactions(book));
 
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "transactions.retrieved",
                     new Object[] {(new Long(book)).toString()},
                     Locale.US));
         }
 
         return result;
     }
 
     /**
      * Resets a user's password.
      *
      * <p>Fails silently if the user does not exist.
      * </p>
      * @param user UID of the user
      * @param newPwd new password
      * @exception LibraryException if an error occurs resetting the password
      */
     public void resetPassword(String user, String newPwd)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(
                     "user=" + user + ", newPwd=" + newPwd);
         }
 
         readerDAO.resetPassword(user, newPwd);
     }
 
     /**
      * Validates that <code>uid</code> exists and has <code>email</code> as
      * email address of record, then resets the associated password to a
      * randomly generated string and sends the reader an email with the new
      * password.
      *
      * @param uid  UID to reset password for
      * @param email = email address - for confirmation and message target
      * @throws LibraryException if the <code>uid</code> is not found or if an
      * error occurs resetting the password or sending the notification
      */
     public void forgotPassword(String uid, String email)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "forgotPassword.processing",
                     new Object[] { uid, email },
                     Locale.US));
         }
 
         final Reader rd = retrieveByUid(uid);
 
         if (rd == null || !rd.getEmail().equalsIgnoreCase(email) ) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.nonexistent.reader",
                     new Object[] {  uid + ", " + email },
                     Locale.US);
             logger.error(errString);
             throw new LibraryException(errString);
         }
 
         // Randomly generate a new password
         final byte[] bytes = new byte[8];
         new java.util.Random().nextBytes( bytes );
         final String newPassword = crypto.convert( bytes );
 
         try {
             // Reset the password
             resetPassword(uid, newPassword);
 
             // Send email with the new password
             mailWorker.sendNewPasswordConfirmation( rd, newPassword );
         } catch( final Exception ex) {
             final String errString = resourceBundleMessageSource.getMessage(
                     "error.trans.request.badrequest",
                     new Object[] {  uid, email },
                     Locale.US);
             logger.error(errString);
             throw new LibraryException(errString);
         }
 
         if (logger.isDebugEnabled()) {
             logger.info( resourceBundleMessageSource.getMessage(
                     "forgotPassword.processed.successfully",
                     new Object[] {uid, email},
                     Locale.US));
         }
     }
 
     /**
      * Looks up the book indicated by the ISBN with SRU/SRW provider, returning
      * a Map of key-value pairs expressing attributes of the book.  The map
      * has the following keys:
      * <pre>
      *         Constants.BOOKTITLE
      *         Constants.BOOKSUBJECTSLIST
      *         Constants.BOOKAUTHOR
      *         Constants.BOOKPUBLISHER
      *         Constants.BOOKDATE
      * </pre>
      * All keys are mapped to String values, except Constants.BOOKSUBJECTSLIST
      * which maps to a List of Strings.
      *
      * @param isbn  ISBN of the book
      * @return Map of key-value pairs describing the book
      * @throws LibraryException if the <code>isbn</code> is not found or if an error occurs
      */
     public Map lookupBook(String isbn)
             throws LibraryException {
         if (logger.isDebugEnabled()) {
             logger.debug(
                     "isbn=" + isbn);
         }
 
         try {
             return sruClient.callSruSrwProvider(isbn);
         } catch(final Throwable ex) {
             if (logger.isDebugEnabled()) {
                 logger.debug( ex.getCause() );
             }
 
             throw new LibraryException(ex.getMessage(), ex);
         }
     }
 }