package org.wcb.model.service.impl;
   
   import org.wcb.model.manager.*;
   import org.wcb.model.service.ILogbookService;
   import org.wcb.model.vo.hibernate.*;
   import org.wcb.model.vo.hibernate.FAA8710ApplicationBO;
   import org.wcb.exception.ServiceException;
   import org.wcb.exception.ManagerException;
   
  import java.util.List;
  import java.util.Collection;
  
  /**
   * <small>
   * Copyright (c)  2006  wbogaardt.
   * Permission is granted to copy, distribute and/or modify this document
   * under the terms of the GNU Free Documentation License, Version 1.2
   * or any later version published by the Free Software Foundation;
   * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
   * Texts.  A copy of the license is included in the section entitled "GNU
   * Free Documentation License".
   * <p/>
   * $File:  $ <br>
   * $Change:  $ submitted by $Author: wbogaardt $ at $DateTime: Mar 24, 2006 12:19:51 PM $ <br>
   * </small>
   *
   * @author wbogaardt
   * @version 1
   *          Date: Mar 24, 2006
   *          Time: 12:19:51 PM
   */
  
  public class LogbookService implements ILogbookService {
  
      private ILogbookManager logbookManager;
      private IAircraftManager aircraftManager;
      private IAircraftTypeManager aircraftTypeManager;
      private IAirportManager airportManager;
      private IApplicantManager applicantManager;
  
      public ILogbookManager getLogbookManager() {
          return logbookManager;
      }
  
      public void setLogbookManager(ILogbookManager logbookManager) {
          this.logbookManager = logbookManager;
      }
  
      public IAircraftManager getAircraftManager() {
          return aircraftManager;
      }
  
      public void setAircraftManager(IAircraftManager aircraftManager) {
          this.aircraftManager = aircraftManager;
      }
  
      public IAircraftTypeManager getAircraftTypeManager() {
          return aircraftTypeManager;
      }
  
      public void setAircraftTypeManager(IAircraftTypeManager aircraftTypeManager) {
          this.aircraftTypeManager = aircraftTypeManager;
      }
  
      public IAirportManager getAirportManager() {
          return airportManager;
      }
  
      public void setAirportManager(IAirportManager airportManager) {
          this.airportManager = airportManager;
      }
  
  
      public IApplicantManager getApplicantManager() {
          return applicantManager;
      }
  
      public void setApplicantManager(IApplicantManager applicantManager) {
          this.applicantManager = applicantManager;
      }
  
      public Logbook findLogBookEntry(Integer pkId) throws ServiceException {
          try
          {
              return logbookManager.findEntry(pkId);
          } catch (ManagerException me) {
              throw new ServiceException("Logbook entry was not found for id " + pkId);
          }
      }
  
      public void saveLogBookEntry(Logbook oEntry) throws ServiceException {
          try
          {
              logbookManager.saveEntry(oEntry);
          }
          catch (ManagerException me)
          {
              throw new ServiceException("Logbook entry failed to be saved.");
          }
     }
 
     public void saveLogBookEntry(Collection<Logbook> oSaveEntries) throws ServiceException {
         try
         {
             logbookManager.saveOrUpdateLogbook(oSaveEntries);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to save logbook entries from importing # " + oSaveEntries.size(), me);
         }
     }
 
     public void deleteLogBookEntry(Logbook oEntry) throws ServiceException {
         try
         {
             logbookManager.deleteEntry(oEntry);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Logbook entry failed to be deleted.");
         }
     }
 
     public List<Logbook> getAllLogbookEntries() throws ServiceException {
         try
         {
             return logbookManager.findAll();
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Manager Exception", me);
         }
     }
 
     public List<Logbook> findByRegistration(String reg) throws ServiceException {
         try
         {
             return logbookManager.findByRegistration(reg);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find any log entries");
         }
     }
 
     public AircraftBO getAircraftByRegistration(String regid) throws ServiceException {
         try
         {
             return aircraftManager.findByRegistry(regid);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find the aircraft with registration " + regid, me);
         }
     }
 
     public void saveAircraft(AircraftBO craft) throws ServiceException {
         try
         {
             aircraftManager.saveOrUpdateAircraft(craft);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Unable to save aircraft");
         }
     }
 
     public AircraftTypeBO getAircraftTypeById(Integer id) throws ServiceException {
         try
         {
             return aircraftTypeManager.getAircraftTypeById(id);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find aircraft type by id " + id, me);
         }
     }
 
     public List<AircraftTypeBO> findAllAircraftType() throws ServiceException {
         try
         {
             return aircraftTypeManager.getAllAircraftTypes();
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find any aircraft types", me);
         }
     }
 
     public void saveAircraftType(AircraftTypeBO type) throws ServiceException {
         try
         {
             aircraftTypeManager.saveAircraftType(type);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to save aircraft types", me);
         }
 
     }
 
     public void deleteAircraft(AircraftBO craft) throws ServiceException {
         try
         {
             aircraftManager.deleteAircraftEntry(craft);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to delete aircraft" + craft.getRegistrationNumber(), me);
         }
     }
 
     public List<AircraftBO> findAllAircraft() throws ServiceException {
         try
         {
             return aircraftManager.findAll();
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find any aircraft ", me);
         }
     }
 
     public List<AirportBO> findAllAirport() throws ServiceException {
         try
         {
             return airportManager.findAll();
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find any airport ", me);
         }
     }
 
     public AirportBO findByAirportFaa(String faaCode) throws ServiceException {
         try
         {
             return airportManager.findByAirportFaa(faaCode);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find airport as " + faaCode, me);
         }
     }
 
     public void saveAirport(AirportBO oSave) throws ServiceException {
         try
         {
             airportManager.saveOrUpdateAirport(oSave);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to save Airport" + oSave.getFaa(), me);
         }
     }
 
     public void saveAirports(Collection<AirportBO> oSave) throws ServiceException {
         try
         {
             airportManager.saveOrUpdateAirports(oSave);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to save Airports # " + oSave.size(), me);
         }
     }
 
     public void deleteAirport(AirportBO oAirport) throws ServiceException {
         try
         {
             airportManager.deleteAirportEntry(oAirport);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to delete airport " + oAirport.getFaa(), me);
         }
     }
 
     /**
      * Logbook user information.
      * @param oSave
      * @throws ServiceException
      */
      public void saveApplicant(FAA8710ApplicationBO oSave) throws ServiceException {
         try
         {
             applicantManager.saveApplicant(oSave);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to save Applicant " + oSave.getName(), me);
         }
     }
 
     public FAA8710ApplicationBO getApplicant() throws ServiceException {
         try
         {
             return applicantManager.findEntry(1);
         }
         catch (ManagerException me)
         {
             throw new ServiceException("Failed to find applicant as " + 1, me);
         }
     }
 }