@SuppressWarnings("unchecked")
 @Override
 public List<String> listPrimaryKeyFieldNames(Class<?> type) {
   List<String> keys = new ArrayList<String>();
   if (type == null) {
     return keys;
   }
   if (isPersistable(type)) {
     keys = persistenceStructureService.listPrimaryKeyFieldNames(type);
   } else {
     ModuleService responsibleModuleService = kualiModuleService.getResponsibleModuleService(type);
     if (responsibleModuleService != null && responsibleModuleService.isExternalizable(type)) {
       keys = responsibleModuleService.listPrimaryKeyFieldNames(type);
     } else {
       // check the Data Dictionary for PK's of non PBO/EBO
       DataObjectEntry dataObjectEntry =
           dataDictionaryService.getDataDictionary().getDataObjectEntry(type.getName());
       if (dataObjectEntry != null) {
         List<String> pks = dataObjectEntry.getPrimaryKeys();
         if (pks != null) {
           keys = pks;
         }
       } else {
         LOG.warn(
             "Unable to retrieve data object entry for non-persistable KNS-managed class: "
                 + type.getName());
       }
     }
   }
   return keys;
 }
Esempio n. 2
0
  /** @return the nested diagnostic context string for this step's log file */
  @SuppressWarnings("unchecked")
  private String getNestedDiagnosticContext() {
    Step unProxiedStep = (Step) ProxyUtils.getTargetIfProxied(step);
    Class stepClass = unProxiedStep.getClass();
    ModuleService module =
        SpringContext.getBean(KualiModuleService.class).getResponsibleModuleService(stepClass);

    String nestedDiagnosticContext =
        StringUtils.substringAfter(module.getModuleConfiguration().getNamespaceCode(), "-")
                .toLowerCase()
            + File.separator
            + step.getName()
            + "-"
            + dateTimeService.toDateTimeStringForFilename(dateTimeService.getCurrentDate());

    return nestedDiagnosticContext;
  }
  /**
   * Determines the module associated with the given request and then checks whether the module is
   * locked
   *
   * @param request request object to pull parameters from
   * @return boolean true if the associated module is locked, false if not or no associated module
   *     was found
   */
  protected boolean isModuleLocked(HttpServletRequest request) {
    ModuleService moduleService = getModuleService(request);

    if (moduleService != null && moduleService.isLocked()) {
      String principalId = GlobalVariables.getUserSession().getPrincipalId();
      String namespaceCode = KRADConstants.KUALI_RICE_SYSTEM_NAMESPACE;
      String permissionName = KimConstants.PermissionNames.ACCESS_LOCKED_MODULE;

      Map<String, String> permissionDetails = new HashMap<String, String>();
      Map<String, String> qualification = new HashMap<String, String>();
      if (!KimApiServiceLocator.getPermissionService()
          .isAuthorized(principalId, namespaceCode, permissionName, qualification)) {
        return true;
      }
    }

    return false;
  }
 public CountryEbo getVendorCountry() {
   if (StringUtils.isBlank(vendorCorpCitizenCode)) {
     vendorCountry = null;
   } else {
     if (vendorCountry == null
         || !StringUtils.equals(vendorCountry.getCode(), vendorCorpCitizenCode)) {
       ModuleService moduleService =
           SpringContext.getBean(KualiModuleService.class)
               .getResponsibleModuleService(CountryEbo.class);
       if (moduleService != null) {
         Map<String, Object> keys = new HashMap<String, Object>(1);
         keys.put(LocationConstants.PrimaryKeyConstants.CODE, vendorCorpCitizenCode);
         vendorCountry = moduleService.getExternalizableBusinessObject(CountryEbo.class, keys);
       } else {
         throw new RuntimeException(
             "CONFIGURATION ERROR: No responsible module found for EBO class.  Unable to proceed.");
       }
     }
   }
   return vendorCountry;
 }
  /**
   * Invoked to request an inquiry view for a data object class
   *
   * <p>Checks if the data object is externalizable and we need to redirect to the appropriate
   * inquiry URL, else continues with the inquiry view display
   *
   * <p>Data object class name and values for a primary or alternate key set must be sent in the
   * request
   *
   * <p>Invokes the inquirable to perform the query for the data object record, if not found an
   * exception will be thrown. If found the object is set on the form and then the view is rendered
   */
  @RequestMapping(params = "methodToCall=start")
  @Override
  public ModelAndView start(
      @ModelAttribute("KualiForm") UifFormBase form,
      BindingResult result,
      HttpServletRequest request,
      HttpServletResponse response) {
    InquiryForm inquiryForm = (InquiryForm) form;

    // if request is not a redirect, determine if we need to redirect for an externalizable object
    // inquiry
    if (!inquiryForm.isRedirectedInquiry()) {
      Class inquiryObjectClass = null;
      try {
        inquiryObjectClass = Class.forName(inquiryForm.getDataObjectClassName());
      } catch (ClassNotFoundException e) {
        throw new RiceRuntimeException(
            "Unable to get class for name: " + inquiryForm.getDataObjectClassName());
      }

      ModuleService responsibleModuleService =
          KRADServiceLocatorWeb.getKualiModuleService()
              .getResponsibleModuleService(inquiryObjectClass);
      if (responsibleModuleService != null
          && responsibleModuleService.isExternalizable(inquiryObjectClass)) {
        String inquiryUrl =
            responsibleModuleService.getExternalizableDataObjectInquiryUrl(
                inquiryObjectClass,
                KRADUtils.convertRequestMapToProperties(request.getParameterMap()));

        Properties redirectUrlProps = new Properties();
        redirectUrlProps.put(UifParameters.REDIRECTED_INQUIRY, "true");

        // clear current form from session
        GlobalVariables.getUifFormManager().removeSessionForm(form);

        return performRedirect(form, inquiryUrl, redirectUrlProps);
      }
    }

    // initialize data object class in inquirable
    try {
      inquiryForm
          .getInquirable()
          .setDataObjectClass(Class.forName(inquiryForm.getDataObjectClassName()));
    } catch (ClassNotFoundException e) {
      LOG.error(
          "Unable to get new instance for object class: " + inquiryForm.getDataObjectClassName(),
          e);
      throw new RuntimeException(
          "Unable to get new instance for object class: " + inquiryForm.getDataObjectClassName(),
          e);
    }

    // invoke inquirable to retrieve inquiry data object
    Object dataObject =
        inquiryForm
            .getInquirable()
            .retrieveDataObject(KRADUtils.translateRequestParameterMap(request.getParameterMap()));

    inquiryForm.setDataObject(dataObject);

    return super.start(form, result, request, response);
  }
Esempio n. 6
0
  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;
    }
    String patronHome = parameters.get("flow");

    // 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>();
    List<OleEntityPhoneBo> oleEntityPhoneBoList = new ArrayList<>();
    List<OleEntityEmailBo> oleEntityEmailBoList = new ArrayList<>();
    OlePatronDocument patronDocument = (OlePatronDocument) dataObject;
    if (patronDocument != null) {
      EntityBo kimEnity = patronDocument.getEntity();
      if (kimEnity.getNames().size() > 0) {
        patronDocument.setName(kimEnity.getNames().get(0));
      }
      if (kimEnity.getEntityTypeContactInfos().size() > 0) {
        List<EntityAddressBo> entityAddressList =
            kimEnity.getEntityTypeContactInfos().get(0).getAddresses();
        for (EntityAddressBo entityAdd : entityAddressList) {
          OleEntityAddressBo entityAddressBo = new OleEntityAddressBo();
          entityAddressBo.setEntityAddressBo(entityAdd);
          Map addMap = new HashMap();
          // addMap.put(OLEConstants.OlePatron.OLE_ADDRESS_ID, entityAdd.getId());
          addMap.put(OLEConstants.OlePatron.ENTITY_BO_ID, entityAdd.getId());
          addMap.put(OLEConstants.OlePatron.PATRON_ID, patronDocument.getId());
          List<OleAddressBo> oleAddressBos =
              (List<OleAddressBo>)
                  getBusinessObjectService().findMatching(OleAddressBo.class, addMap);
          if (CollectionUtils.isNotEmpty(oleAddressBos)) {
            entityAddressBo.setOleAddressBo(oleAddressBos.get(0));
          }
          oleEntityAddressList.add(entityAddressBo);
        }
        patronDocument.setOleEntityAddressBo(oleEntityAddressList);
        List<EntityPhoneBo> entityPhoneBoList =
            kimEnity.getEntityTypeContactInfos().get(0).getPhoneNumbers();
        for (EntityPhoneBo entityPhoneBo : entityPhoneBoList) {
          OleEntityPhoneBo oleEntityPhoneBo = new OleEntityPhoneBo();
          oleEntityPhoneBo.setEntityPhoneBo(entityPhoneBo);
          Map map = new HashMap();
          map.put(OLEConstants.OlePatron.ENTITY_BO_ID, entityPhoneBo.getId());
          map.put(OLEConstants.OlePatron.PATRON_ID, patronDocument.getId());
          List<OlePhoneBo> olePhoneBos =
              (List<OlePhoneBo>) getBusinessObjectService().findMatching(OlePhoneBo.class, map);
          if (CollectionUtils.isNotEmpty(olePhoneBos)) {
            oleEntityPhoneBo.setOlePhoneBo(olePhoneBos.get(0));
          }
          oleEntityPhoneBoList.add(oleEntityPhoneBo);
        }
        patronDocument.setOleEntityPhoneBo(oleEntityPhoneBoList);
        List<EntityEmailBo> entityEmailBoList =
            kimEnity.getEntityTypeContactInfos().get(0).getEmailAddresses();
        for (EntityEmailBo entityEmailBo : entityEmailBoList) {
          OleEntityEmailBo oleEntityEmailBo = new OleEntityEmailBo();
          oleEntityEmailBo.setEntityEmailBo(entityEmailBo);
          Map map = new HashMap();
          map.put(OLEConstants.OlePatron.ENTITY_BO_ID, entityEmailBo.getId());
          map.put(OLEConstants.OlePatron.PATRON_ID, patronDocument.getId());
          List<OleEmailBo> oleEmailBos =
              (List<OleEmailBo>) getBusinessObjectService().findMatching(OleEmailBo.class, map);
          if (CollectionUtils.isNotEmpty(oleEmailBos)) {
            oleEntityEmailBo.setOleEmailBo(oleEmailBos.get(0));
          }
          oleEntityEmailBoList.add(oleEntityEmailBo);
        }
        patronDocument.setOleEntityEmailBo(oleEntityEmailBoList);
        patronDocument.setPatronAffiliations(
            getPatronAffiliationFromEntity(
                kimEnity.getAffiliations(), kimEnity.getEmploymentInformation()));
        if (patronHome != null) {
          if (patronHome.equalsIgnoreCase("start")) patronDocument.setPatronHomePage(false);
          else patronDocument.setPatronHomePage(true);
        }
      }
      if (null != patronDocument.getName()) {
        String createBillUrl =
            OLEConstants.OlePatron.PATRON_CREATE_BILL_URL
                + patronDocument.getOlePatronId()
                + "&firstName="
                + patronDocument.getName().getFirstName()
                + "&lastName="
                + patronDocument.getName().getLastName();
        patronDocument.setCreateBillUrl(createBillUrl);
      }
      if (CollectionUtils.isNotEmpty(patronDocument.getPatronBillPayments())) {
        patronDocument.setPatronBillFileName(OLEConstants.OlePatron.PATRON_VIEW_BILLS);
        patronDocument.setViewBillUrl(
            OLEConstants.OlePatron.PATRON_VIEW_BILL_URL + patronDocument.getOlePatronId());
      }
      patronDocument.setShowBillUrlsFlag(true);
    }

    if (CollectionUtils.isNotEmpty(patronDocument.getOleProxyPatronDocuments())) {
      OlePatronDocument olePatronDocument;
      for (OleProxyPatronDocument oleProxyPatronDocument :
          patronDocument.getOleProxyPatronDocuments()) {
        olePatronDocument = oleProxyPatronDocument.getOlePatronDocument();
        oleProxyPatronDocument.setProxyForPatronFirstName(
            olePatronDocument.getEntity().getNames().get(0).getFirstName());
        oleProxyPatronDocument.setProxyForPatronLastName(
            olePatronDocument.getEntity().getNames().get(0).getLastName());
      }
    }
    if (CollectionUtils.isNotEmpty(patronDocument.getOleProxyPatronDocumentList())) {
      OlePatronDocument olePatronDocument;
      for (OleProxyPatronDocument oleProxyPatronDocument :
          patronDocument.getOleProxyPatronDocumentList()) {
        olePatronDocument = oleProxyPatronDocument.getOlePatronDocument();
        oleProxyPatronDocument.setProxyForPatronFirstName(
            olePatronDocument.getEntity().getNames().get(0).getFirstName());
        oleProxyPatronDocument.setProxyForPatronLastName(
            olePatronDocument.getEntity().getNames().get(0).getLastName());
      }
    }

    if (patronDocument.getOleLoanDocuments() != null) {
      patronDocument.setLoanCount(patronDocument.getOleLoanDocuments().size());
    }
    if (patronDocument.getOleTemporaryCirculationHistoryRecords() != null) {
      patronDocument.setTempCirculationHistoryCount(
          patronDocument.getOleTemporaryCirculationHistoryRecords().size());
    }
    if (patronDocument.getOleDeliverRequestBos() != null) {
      patronDocument.setRequestedItemRecordsCount(patronDocument.getOleDeliverRequestBos().size());
    }

    return patronDocument;
  }