package org.kuali.ole.patron.inquiry;
   
   import org.kuali.ole.deliver.loan.LoanProcessor;
   import org.kuali.ole.deliver.request.service.OleDeliverRequestDocumentHelperServiceImpl;
   import org.kuali.ole.patron.bo.OleAddressBo;
   import org.kuali.ole.patron.bo.OleEntityAddressBo;
   import org.kuali.ole.patron.bo.OlePatronDocument;
   import org.kuali.rice.kim.impl.identity.address.EntityAddressBo;
   import org.kuali.rice.kim.impl.identity.entity.EntityBo;
  import org.kuali.rice.krad.bo.BusinessObject;
  import org.kuali.rice.krad.bo.ExternalizableBusinessObject;
  import org.kuali.rice.krad.datadictionary.exception.UnknownBusinessClassAttributeException;
  import org.kuali.rice.krad.inquiry.InquirableImpl;
  import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
  import org.kuali.rice.krad.service.ModuleService;
  
  import java.security.GeneralSecurityException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  /**
   * OlePatronInquirableImpl supports to get the data object and patron document.
   */
  public class OlePatronInquirableImpl extends InquirableImpl {
      private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(OlePatronInquirableImpl.class);
  
      /**
       * This method will retrieve the patron document based on the olePatronId
       * @param parameters
       * @return patronDocument(Object)
       */
      public Object retrieveDataObject(Map<String, String> parameters) {
          if (dataObjectClass == null) {
              LOG.error("Data object class must be set in inquirable before retrieving the object");
              throw new RuntimeException("Data object class must be set in inquirable before retrieving the object");
          }
  
          // build list of key values from the map parameters
          List<String> pkPropertyNames = getDataObjectMetaDataService().listPrimaryKeyFieldNames(dataObjectClass);
  
          // some classes might have alternate keys defined for retrieving
          List<List<String>> alternateKeyNames = this.getAlternateKeysForClass(dataObjectClass);
  
          // add pk set as beginning so it will be checked first for match
          alternateKeyNames.add(0, pkPropertyNames);
  
          List<String> dataObjectKeySet = retrieveKeySetFromMap(alternateKeyNames, parameters);
          if ((dataObjectKeySet == null) || dataObjectKeySet.isEmpty()) {
              LOG.warn("Matching key set not found in request for class: " + getDataObjectClass());
  
              return null;
          }
  
          // found key set, now build map of key values pairs we can use to retrieve the object
          Map<String, Object> keyPropertyValues = new HashMap<String, Object>();
          for (String keyPropertyName : dataObjectKeySet) {
              String keyPropertyValue = parameters.get(keyPropertyName);
  
              // uppercase value if needed
              Boolean forceUppercase = Boolean.FALSE;
              try {
                  forceUppercase = getDataDictionaryService().getAttributeForceUppercase(dataObjectClass,
                          keyPropertyName);
              } catch (UnknownBusinessClassAttributeException ex) {
                  // swallowing exception because this check for ForceUppercase would
                  // require a DD entry for the attribute, and we will just set force uppercase to false
                  LOG.warn("Data object class "
                          + dataObjectClass
                          + " property "
                          + keyPropertyName
                          + " should probably have a DD definition.", ex);
              }
  
              if (forceUppercase.booleanValue() && (keyPropertyValue != null)) {
                  keyPropertyValue = keyPropertyValue.toUpperCase();
              }
  
              // check security on key field
              if (getDataObjectAuthorizationService().attributeValueNeedsToBeEncryptedOnFormsAndLinks(dataObjectClass,
                      keyPropertyName)) {
                  try {
                      keyPropertyValue = getEncryptionService().decrypt(keyPropertyValue);
                  } catch (GeneralSecurityException e) {
                      LOG.error("Data object class "
                              + dataObjectClass
                              + " property "
                              + keyPropertyName
                              + " should have been encrypted, but there was a problem decrypting it.", e);
                      throw new RuntimeException("Data object class "
                              + dataObjectClass
                              + " property "
                              + keyPropertyName
                              + " should have been encrypted, but there was a problem decrypting it.", e);
                  }
              }
  
              keyPropertyValues.put(keyPropertyName, keyPropertyValue);
         }
 
         // now retrieve the object based on the key set
         Object dataObject = null;
 
         ModuleService moduleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(
                 getDataObjectClass());
         if (moduleService != null && moduleService.isExternalizable(getDataObjectClass())) {
             dataObject = moduleService.getExternalizableBusinessObject(getDataObjectClass().asSubclass(
                     ExternalizableBusinessObject.class), keyPropertyValues);
         } else if (BusinessObject.class.isAssignableFrom(getDataObjectClass())) {
             dataObject = getBusinessObjectService().findByPrimaryKey(getDataObjectClass().asSubclass(
                     BusinessObject.class), keyPropertyValues);
         }
         OleEntityAddressBo entityAddressBo = new OleEntityAddressBo();
         EntityAddressBo entityAddress = new EntityAddressBo();
         List<OleEntityAddressBo> oleEntityAddressList = new ArrayList<OleEntityAddressBo>();
         OlePatronDocument patronDocument = (OlePatronDocument)dataObject;
         if (patronDocument != null) {
             EntityBo kimEnity = patronDocument.getEntity();
             patronDocument.setName(kimEnity.getNames().get(0));
             List<EntityAddressBo> entityAddressList = kimEnity.getEntityTypeContactInfos().get(0).getAddresses();
             for (EntityAddressBo entityAdd : entityAddressList) {
                 entityAddressBo.setEntityAddressBo(entityAdd);
                 Map addMap = new HashMap();
                 addMap.put("oleAddressId",entityAdd.getId());
                 OleAddressBo oleAddressBo=  getBusinessObjectService().findByPrimaryKey(OleAddressBo.class, addMap);
                 entityAddressBo.setOleAddressBo(oleAddressBo);
                 oleEntityAddressList.add(entityAddressBo);
             }
             patronDocument.setOleEntityAddressBo(oleEntityAddressList);
             patronDocument.setPhones(kimEnity.getEntityTypeContactInfos().get(0).getPhoneNumbers());
             patronDocument.setEmails(kimEnity.getEntityTypeContactInfos().get(0).getEmailAddresses());
             LoanProcessor loanProcessor = new LoanProcessor();
             OleDeliverRequestDocumentHelperServiceImpl requestService = new OleDeliverRequestDocumentHelperServiceImpl();
             try{
                 patronDocument.setOleLoanDocuments(loanProcessor.getPatronLoanedItem(patronDocument.getOlePatronId()));
                 patronDocument.setOleTemporaryCirculationHistoryRecords(loanProcessor.getPatronTemporaryCirculationHistoryRecords(patronDocument.getOlePatronId()));
             }catch (Exception e){
                 LOG.error("Cannot fetch the patron loaned items.");
             }
         }
 
         return patronDocument;
     }
 
 }