protected void populateRoutingExceptionResponsibility(DocumentConfigurationViewForm form) {
    DocumentType docType = form.getDocumentType();
    List<ResponsibilityForDisplay> responsibilities = new ArrayList<ResponsibilityForDisplay>();
    while (docType != null) {
      QueryByCriteria.Builder builder = QueryByCriteria.Builder.create();
      Predicate p =
          and(
              equal("template.namespaceCode", KRADConstants.KUALI_RICE_WORKFLOW_NAMESPACE),
              equal(
                  "template.name", KewApiConstants.EXCEPTION_ROUTING_RESPONSIBILITY_TEMPLATE_NAME),
              equal("active", "Y"),
              equal("attributes[documentTypeName]", docType.getName()));
      builder.setPredicates(p);
      List<Responsibility> resps =
          getResponsibilityService().findResponsibilities(builder.build()).getResults();

      for (Responsibility r : resps) {
        if (responsibilities.isEmpty()) {
          responsibilities.add(new ResponsibilityForDisplay(r, false));
        } else {
          responsibilities.add(new ResponsibilityForDisplay(r, true));
        }
      }
      docType = docType.getParentDocType();
    }
    form.setExceptionResponsibilities(responsibilities);
    for (ResponsibilityForDisplay responsibility : responsibilities) {
      List<String> roleIds =
          getResponsibilityService().getRoleIdsForResponsibility(responsibility.getResp().getId());
      if (!roleIds.isEmpty()) {
        form.getResponsibilityRoles()
            .put(responsibility.getResponsibilityId(), getRoleService().getRoles(roleIds));
      }
    }
  }
 @Override
 public List<StateInfo> performSearch(
     LookupForm lookupForm, Map<String, String> searchCriteria, boolean bounded) {
   QueryByCriteria.Builder qBuilder = QueryByCriteria.Builder.create();
   List<Predicate> pList = new ArrayList<Predicate>();
   // Code Changed for JIRA-8997 - SONAR Critical issues - Performance - Inefficient use of keySet
   // iterator instead of entrySet iterator
   for (Map.Entry<String, String> entry : searchCriteria.entrySet()) {
     String fieldName = entry.getKey();
     String value = entry.getValue();
     if (value != null && !value.isEmpty()) {
       if (fieldName.equals("maxResultsToReturn")) {
         qBuilder.setMaxResults(Integer.parseInt(value));
         continue;
       }
       pList.add(PredicateFactory.equal(fieldName, value));
     }
   }
   if (!pList.isEmpty()) {
     qBuilder.setPredicates(PredicateFactory.and(pList.toArray(new Predicate[pList.size()])));
   }
   try {
     return this.getStateService().searchForStates(qBuilder.build(), getContextInfo());
   } catch (Exception ex) {
     throw new RuntimeException(ex);
   }
 }
  protected PeopleFlowBo getPeopleFlowBoByName(String namespaceCode, String name) {
    if (StringUtils.isBlank(namespaceCode)) {
      throw new RiceIllegalArgumentException("namespaceCode was a null or blank value");
    }
    if (StringUtils.isBlank(name)) {
      throw new RiceIllegalArgumentException("name was a null or blank value");
    }

    QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
    criteria.setPredicates(
        equal(KewImplConstants.PropertyConstants.NAMESPACE_CODE, namespaceCode),
        equal(KewImplConstants.PropertyConstants.NAME, name));
    Collection<PeopleFlowBo> peopleFlows =
        dataObjectService.findMatching(PeopleFlowBo.class, criteria.build()).getResults();

    if (CollectionUtils.isEmpty(peopleFlows)) {
      return null;
    } else if (peopleFlows.size() > 1) {
      throw new RiceIllegalStateException(
          "Found more than one PeopleFlow with the given namespace code '"
              + namespaceCode
              + "' and name '"
              + name
              + "'");
    }
    return peopleFlows.iterator().next();
  }
  protected static List<String> getOptionKeys(
      CourseOfferingCreateWrapper createWrapper, CourseOfferingInfo existingCO) {

    List<String> optionKeys =
        getDefaultOptionKeysService().getDefaultOptionKeysForCopySingleCourseOffering();

    if (createWrapper.isExcludeInstructorInformation()) {
      optionKeys.add(CourseOfferingSetServiceConstants.NO_INSTRUCTORS_OPTION_KEY);
    }

    if (createWrapper.isExcludeSchedulingInformation()) {
      optionKeys.add(CourseOfferingSetServiceConstants.NO_SCHEDULE_OPTION_KEY);
    }

    if (createWrapper.isExcludeCancelledActivityOfferings()) {
      optionKeys.add(CourseOfferingSetServiceConstants.IGNORE_CANCELLED_AO_OPTION_KEY);
    }

    ContextInfo contextInfo = ContextUtils.createDefaultContextInfo();

    try {
      // if source term differs from target term determine if add suffix or not
      if (StringUtils.equals(existingCO.getTermId(), createWrapper.getTerm().getId())) {
        optionKeys.add(CourseOfferingServiceConstants.APPEND_COURSE_OFFERING_IN_SUFFIX_OPTION_KEY);
      } else {
        QueryByCriteria.Builder qbcBuilder = QueryByCriteria.Builder.create();
        qbcBuilder.setPredicates(
            PredicateFactory.and(
                PredicateFactory.like(
                    "courseOfferingCode", existingCO.getCourseOfferingCode() + "%"),
                PredicateFactory.equalIgnoreCase("atpId", createWrapper.getTerm().getId())));
        QueryByCriteria criteria = qbcBuilder.build();
        List<String> courseOfferingIds =
            CourseOfferingManagementUtil.getCourseOfferingService()
                .searchForCourseOfferingIds(criteria, contextInfo);

        if (courseOfferingIds.size() > 0) {
          optionKeys.add(
              CourseOfferingServiceConstants.APPEND_COURSE_OFFERING_IN_SUFFIX_OPTION_KEY);
        }
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }

    //  According to Jira 4353 copy the title from CO instead of CLU. So set the property not to
    // copy from CLU
    optionKeys.add(CourseOfferingSetServiceConstants.NOT_COURSE_TITLE_OPTION_KEY);
    return optionKeys;
  }
  /** @see BulkUpdateMaintainable#generateUpdatableObjects() */
  @Override
  public List<Object> generateUpdatableObjects() {
    List<Object> updatableObjects = new ArrayList<Object>();

    BulkUpdateMaintenanceDataObject bulkUpdateMaintenanceDataObject =
        (BulkUpdateMaintenanceDataObject) getDataObject();
    List<?> targetUpdateDataObjects = bulkUpdateMaintenanceDataObject.getTargetUpdateDataObjects();

    for (Object targetUpdateDataObject : targetUpdateDataObjects) {
      Map<String, Object> primaryKeys =
          getDataObjectService().wrap(targetUpdateDataObject).getPrimaryKeyValues();
      Object updatableObject =
          getDataObjectService()
              .findUnique(
                  targetUpdateDataObject.getClass(),
                  QueryByCriteria.Builder.andAttributes(primaryKeys).build());

      for (Map.Entry<String, ?> updateFieldValue :
          bulkUpdateMaintenanceDataObject.getUpdateFieldValues().entrySet()) {
        String propertyName = updateFieldValue.getKey();
        Object propertyValue = updateFieldValue.getValue();

        if (ObjectPropertyUtils.isWritableProperty(updatableObject, propertyName)) {
          ObjectPropertyUtils.setPropertyValue(updatableObject, propertyName, propertyValue);
          updatableObjects.add(updatableObject);
        }
      }
    }

    return updatableObjects;
  }
  public void populatePermissions(DocumentConfigurationViewForm form) {

    DocumentType docType = form.getDocumentType();
    Map<String, List<Role>> permRoles = new HashMap<String, List<Role>>();
    // loop over the document hierarchy
    Set<String> seenDocumentPermissions = new HashSet<String>();
    while (docType != null) {
      String documentTypeName = docType.getName();
      Predicate p =
          and(
              equal("active", "Y"),
              equal(
                  "attributes[" + KimConstants.AttributeConstants.DOCUMENT_TYPE_NAME + "]",
                  docType.getName()));
      List<Permission> perms =
          getPermissionService()
              .findPermissions(QueryByCriteria.Builder.fromPredicates(p))
              .getResults();
      for (Permission perm : perms) {
        PermissionBo permBo = PermissionBo.from(perm);
        List<String> roleIds =
            getPermissionService().getRoleIdsForPermission(perm.getNamespaceCode(), perm.getName());
        if (!roleIds.isEmpty()) {
          permRoles.put(perm.getId(), getRoleService().getRoles(roleIds));
        }
        for (String attributeName : permBo.getDetails().keySet()) {
          addAttributeLabel(form, attributeName);
        }
      }
      // show the section if the current document or permissions exist
      if (perms.size() > 0 || documentTypeName.equals(form.getDocumentTypeName())) {
        ArrayList<PermissionForDisplay> dispPerms =
            new ArrayList<PermissionForDisplay>(perms.size());
        for (Permission perm : perms) {
          PermissionBo permBo = PermissionBo.from(perm);
          if (permBo.getDetails().size() == 1) { // only the document type
            // this is a document type-specific permission, check if seen earlier
            if (seenDocumentPermissions.contains(
                perm.getTemplate().getNamespaceCode() + "|" + perm.getTemplate().getName())) {
              dispPerms.add(new PermissionForDisplay(permBo, true));
            } else {
              dispPerms.add(new PermissionForDisplay(permBo, false));
              seenDocumentPermissions.add(
                  perm.getTemplate().getNamespaceCode() + "|" + perm.getTemplate().getName());
            }
          } else {
            // other attributes, can't determine whether this is overridden at another level
            dispPerms.add(new PermissionForDisplay(permBo, false));
          }
        }
        form.setPermissionsForDocumentType(documentTypeName, dispPerms);
        form.addDocumentType(documentTypeName);
      }
      docType = docType.getParentDocType();
    }

    form.setPermissionRoles(permRoles);
  }
 protected QueryByCriteria setUpEntityLookupCriteria(String principalId) {
   PersonServiceImpl personServiceImpl =
       (PersonServiceImpl)
           KIMServiceLocatorInternal.getService(KimApiServiceLocator.KIM_PERSON_SERVICE);
   Map<String, String> criteria = new HashMap<String, String>(1);
   criteria.put(KIMPropertyConstants.Person.PRINCIPAL_ID, principalId);
   Map<String, String> entityCriteria =
       personServiceImpl.convertPersonPropertiesToEntityProperties(criteria);
   entityCriteria.put("entityTypeContactInfos.entityTypeCode", "PERSON");
   QueryByCriteria.Builder query = QueryByCriteria.Builder.create();
   List<Predicate> predicates = new ArrayList<Predicate>();
   for (String key : entityCriteria.keySet()) {
     predicates.add(like(key, entityCriteria.get(key)));
   }
   if (!predicates.isEmpty()) {
     query.setPredicates(and(predicates.toArray(new Predicate[predicates.size()])));
   }
   return query.build();
 }
 public void refreshBudgetDocumentVersions() {
   final List<BudgetDocumentVersion> v =
       getDataObjectService()
           .findMatching(
               BudgetDocumentVersion.class,
               QueryByCriteria.Builder.andAttributes(
                       Collections.singletonMap("parentDocumentKey", documentNumber))
                   .build())
           .getResults();
   budgetDocumentVersions = v;
 }
  /**
   * @param dataObjectClass the dataobject class
   * @param formProperties the incoming lookup form properties
   * @param unbounded whether the search is unbounded
   * @param searchResultsLimit the searchResultsLimit; null implies use of default KNS value if set
   *     for the class
   * @param <T> the data object type
   * @return collection of lookup results
   */
  protected <T> Collection<T> performDataObjectServiceLookup(
      Class<T> dataObjectClass,
      Map<String, String> formProperties,
      boolean unbounded,
      boolean allPrimaryKeyValuesPresentAndNotWildcard,
      Integer searchResultsLimit) {
    if (!unbounded && searchResultsLimit == null) {
      // use KRAD LookupUtils.getSearchResultsLimit instead of KNS version. we have no LookupForm,
      // so pass null, only the class will be used
      // searchResultsLimit = LookupUtils.getSearchResultsLimit(example, null);
      searchResultsLimit =
          org.kuali.rice.kns.lookup.LookupUtils.getSearchResultsLimit(dataObjectClass);
    }
    QueryByCriteria.Builder query =
        lookupCriteriaGenerator.generateCriteria(
            dataObjectClass, formProperties, allPrimaryKeyValuesPresentAndNotWildcard);
    if (!unbounded && searchResultsLimit != null) {
      query.setMaxResults(searchResultsLimit);
    }

    Collection<T> results =
        dataObjectService.findMatching(dataObjectClass, query.build()).getResults();
    return filterCurrentDataObjects(dataObjectClass, results, formProperties);
  }
 private void updatePersonCertificationInfo(ProposalPerson person, String proposalNumber) {
   // Update certified by and certified time with current info
   Map<String, Object> criteria = new HashMap<>();
   criteria.put(DEVELOPMENT_PROPOSAL_NUMBER, proposalNumber);
   QueryResults<ProposalPerson> currentPersons =
       getDataObjectService()
           .findMatching(
               ProposalPerson.class, QueryByCriteria.Builder.andAttributes(criteria).build());
   for (ProposalPerson currentPerson : currentPersons.getResults()) {
     if (currentPerson.getUniqueId().equals(person.getUniqueId())) {
       person.setCertifiedBy(currentPerson.getCertifiedBy());
       person.setCertifiedTime(currentPerson.getCertifiedTime());
       break;
     }
   }
 }
  /**
   * Helper method to get the role member objects.
   *
   * @param principalId The person to get the role for
   * @param roleIds The role
   * @param asOfDate The effective date of the role
   * @param activeOnly Whether or not to consider only active role members
   * @return the list of role member objects
   */
  private List<RoleMember> getPrincipalIdRoleMembers(
      String principalId, List<String> roleIds, DateTime asOfDate, boolean activeOnly) {
    List<String> groupIds = getGroupService().getGroupIdsByPrincipalId(principalId);

    List<Predicate> predicates = new ArrayList<Predicate>();
    predicates.add(
        in(
            KimConstants.PrimaryKeyConstants.SUB_ROLE_ID,
            roleIds.toArray(new String[roleIds.size()])));

    List<Predicate> principalPredicates = new ArrayList<Predicate>();
    principalPredicates.add(
        equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.PRINCIPAL.getCode()));
    if (principalId != null) {
      principalPredicates.add(equal(KIMPropertyConstants.RoleMember.MEMBER_ID, principalId));
    }
    Predicate principalPredicate = and(principalPredicates.toArray(new Predicate[] {}));

    Predicate rolePredicate =
        equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.ROLE.getCode());

    List<Predicate> groupPredicates = new ArrayList<Predicate>();
    groupPredicates.add(
        equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.GROUP.getCode()));
    if (CollectionUtils.isNotEmpty(groupIds)) {
      groupPredicates.add(
          in(KIMPropertyConstants.RoleMember.MEMBER_ID, groupIds.toArray(new String[] {})));
    }
    Predicate groupPredicate = and(groupPredicates.toArray(new Predicate[] {}));

    predicates.add(or(principalPredicate, rolePredicate, groupPredicate));

    if (activeOnly) {
      predicates.add(
          or(isNull("activeFromDateValue"), lessThanOrEqual("activeFromDateValue", asOfDate)));
      predicates.add(or(isNull("activeToDateValue"), greaterThan("activeToDateValue", asOfDate)));
    }

    return getRoleService()
        .findRoleMembers(
            QueryByCriteria.Builder.fromPredicates(predicates.toArray(new Predicate[] {})))
        .getResults();
  }
  protected List<RoleMember> getPrimaryRoleMembers(
      Role role, Map<String, String> qualification, DateTime asOfDate, boolean isActiveOnly) {
    // define the return value
    List<RoleMember> primaryRoleMembers = new ArrayList<RoleMember>();

    if (role != null) {
      RoleTypeService roleTypeService = getRoleTypeService(role);
      // use predicate based filtering only on non-derived role.
      if (roleTypeService == null || !roleTypeService.isDerivedRoleType()) {
        List<Predicate> predicates = new ArrayList<Predicate>();
        predicates.add(equal(KimConstants.PrimaryKeyConstants.SUB_ROLE_ID, role.getId()));
        if (isActiveOnly) {
          predicates.add(
              or(isNull("activeFromDateValue"), lessThanOrEqual("activeFromDateValue", asOfDate)));
          predicates.add(
              or(isNull("activeToDateValue"), greaterThan("activeToDateValue", asOfDate)));
        }

        // LookupCustomizer<RoleMemberBo> lookupCustomizer = builder.build();
        // guard for default type roles
        if (roleTypeService != null) {
          if (MapUtils.isEmpty(qualification)) {
            primaryRoleMembers =
                getRoleService()
                    .findRoleMembers(
                        QueryByCriteria.Builder.fromPredicates(
                            predicates.toArray(new Predicate[predicates.size()])))
                    .getResults();
          } else {
            // get the keys (name) of the qualifiers needed for membership in this role
            List<String> attributesForExactMatch = roleTypeService.getQualifiersForExactMatch();
            if (CollectionUtils.isNotEmpty(attributesForExactMatch)) {
              if (attributesForExactMatch.size() <= 1) {
                for (Map.Entry<String, String> qualificationEntry : qualification.entrySet()) {
                  // do not add a qualification predicate for an attribute unless it is required for
                  // matching

                  if (attributesForExactMatch.contains(qualificationEntry.getKey())) {
                    predicates.add(
                        equal(
                            "attributes[" + qualificationEntry.getKey() + "]",
                            qualificationEntry.getValue()));
                  }
                }
                primaryRoleMembers =
                    getRoleService()
                        .findRoleMembers(
                            QueryByCriteria.Builder.fromPredicates(
                                predicates.toArray(new Predicate[predicates.size()])))
                        .getResults();

              } else {
                // rice's transformation doesn't work with more than one attribute.
                // here is a terrible hack
                List<RoleMember> intersectedMembers = null;
                for (Map.Entry<String, String> qualificationEntry : qualification.entrySet()) {
                  // do not add a qualification predicate for an attribute unless it is required for
                  // matching

                  if (attributesForExactMatch.contains(qualificationEntry.getKey())) {
                    Predicate attrPredicates =
                        equal(
                            "attributes[" + qualificationEntry.getKey() + "]",
                            qualificationEntry.getValue());
                    Predicate[] tempPredicates =
                        predicates.toArray(new Predicate[predicates.size() + 1]);
                    tempPredicates[predicates.size()] = attrPredicates;
                    List<RoleMember> tempMembers =
                        new ArrayList<RoleMember>(
                            getRoleService()
                                .findRoleMembers(
                                    QueryByCriteria.Builder.fromPredicates(tempPredicates))
                                .getResults());
                    if (intersectedMembers == null) {
                      intersectedMembers = new ArrayList<>();
                      intersectedMembers.addAll(tempMembers);
                    } else {
                      intersectedMembers = intersect(intersectedMembers, tempMembers);
                    }
                  }
                }
                primaryRoleMembers = intersectedMembers;
              }
            }
          }
        }
      } else {
        // for derived roles just add the as-of date and active only flag to a copy of the
        // qualification
        Map<String, String> derivedRoleQualification = new HashMap<String, String>(qualification);
        derivedRoleQualification.put("asOfDate", asOfDate.toString());
        derivedRoleQualification.put("activeOnly", String.valueOf(isActiveOnly));
        List<RoleMembership> derivedRoleMembers =
            roleTypeService.getRoleMembersFromDerivedRole(
                role.getNamespaceCode(), role.getName(), derivedRoleQualification);
        // convert the role memberships into role members
        for (RoleMembership derivedRoleMember : derivedRoleMembers) {
          RoleMember roleMember =
              RoleMember.Builder.create(
                      derivedRoleMember.getRoleId(),
                      derivedRoleMember.getId(),
                      derivedRoleMember.getMemberId(),
                      derivedRoleMember.getType(),
                      null,
                      null,
                      derivedRoleMember.getQualifier(),
                      role.getName(),
                      role.getNamespaceCode())
                  .build();

          primaryRoleMembers.add(roleMember);
        }
      }
    }

    return primaryRoleMembers;
  }
Beispiel #13
0
  @Override
  protected void prepareData(ProposalDevelopmentDocument document) throws Exception {

    Organization organization =
        getService(DataObjectService.class)
            .findUnique(
                Organization.class,
                QueryByCriteria.Builder.forAttribute("organizationId", "000001").build());
    document.getDevelopmentProposal().getApplicantOrganization().setOrganization(organization);

    NarrativeAttachment narrativeAttachment = new NarrativeAttachment();
    DefaultResourceLoader resourceLoader =
        new DefaultResourceLoader(ClassLoaderUtils.getDefaultClassLoader());
    Resource resource = resourceLoader.getResource(S2STestConstants.ATT_PACKAGE + "/exercise2.pdf");
    InputStream inputStream = resource.getInputStream();
    BufferedInputStream bis = new BufferedInputStream(inputStream);
    byte[] narrativePdf = new byte[bis.available()];
    narrativeAttachment.setData(narrativePdf);
    narrativeAttachment.setName("exercise1");
    Narrative narrative = new Narrative();
    List<Narrative> narrativeList = new ArrayList<Narrative>();
    narrative.setDevelopmentProposal(document.getDevelopmentProposal());
    NarrativeType narrativeType =
        getService(DataObjectService.class)
            .findUnique(
                NarrativeType.class, QueryByCriteria.Builder.forAttribute("code", "7").build());
    narrative.setName("exercise1");
    narrative.setNarrativeType(narrativeType);
    narrative.setNarrativeTypeCode(narrativeType.getCode());
    narrative.setNarrativeAttachment(narrativeAttachment);
    narrative.setModuleNumber(1);
    narrative.setModuleSequenceNumber(1);
    narrative.setModuleStatusCode("C");
    narrativeList.add(narrative);
    document.getDevelopmentProposal().setNarratives(narrativeList);

    List<ProposalPerson> proposalPersons = new ArrayList<ProposalPerson>();
    ProposalPerson principalInvestigator = new ProposalPerson();
    principalInvestigator.setFirstName("ALAN");
    principalInvestigator.setLastName("MCAFEE");
    principalInvestigator.setProposalPersonRoleId("PI");
    principalInvestigator.setPersonId("0001");
    principalInvestigator.setRolodexId(0010);
    principalInvestigator.setProposalPersonNumber(1);
    principalInvestigator.setDevelopmentProposal(document.getDevelopmentProposal());
    proposalPersons.add(principalInvestigator);
    document.getDevelopmentProposal().setProposalPersons(proposalPersons);

    ProposalDevelopmentBudgetExt proposalDevelopmentBudgetExt = new ProposalDevelopmentBudgetExt();
    proposalDevelopmentBudgetExt.setDevelopmentProposal(document.getDevelopmentProposal());
    proposalDevelopmentBudgetExt.setBudgetVersionNumber(1);
    proposalDevelopmentBudgetExt.setBudgetStatus("1");
    proposalDevelopmentBudgetExt.setBudgetId(1L);
    proposalDevelopmentBudgetExt.setName("test Document Description");
    proposalDevelopmentBudgetExt.setOnOffCampusFlag("Y");
    proposalDevelopmentBudgetExt.setStartDate(new Date(new Long("1183316613046")));
    proposalDevelopmentBudgetExt.setEndDate(new Date(new Long("1214852613046")));
    proposalDevelopmentBudgetExt.setOhRateTypeCode("1");
    proposalDevelopmentBudgetExt.setOhRateClassCode("1");
    proposalDevelopmentBudgetExt.setModularBudgetFlag(false);
    proposalDevelopmentBudgetExt.setUrRateClassCode("1");

    List<BudgetPeriod> budgetPeriods = new ArrayList<BudgetPeriod>();
    BudgetPeriod budgetPeriod = new BudgetPeriod();
    budgetPeriod.setBudgetPeriodId(1L);
    budgetPeriod.setStartDate(new Date(new Long("1183316613046")));
    budgetPeriod.setEndDate(new Date(new Long("1214852613046")));
    budgetPeriod.setBudgetPeriod(1);

    budgetPeriod.setBudget(proposalDevelopmentBudgetExt);
    budgetPeriods.add(budgetPeriod);
    proposalDevelopmentBudgetExt.setBudgetPeriods(budgetPeriods);

    List<ProposalDevelopmentBudgetExt> proposalDevelopmentBudgetExtList =
        new ArrayList<ProposalDevelopmentBudgetExt>();
    proposalDevelopmentBudgetExtList.add(proposalDevelopmentBudgetExt);
    document.getDevelopmentProposal().setBudgets(proposalDevelopmentBudgetExtList);
    document.getDevelopmentProposal().setFinalBudget(proposalDevelopmentBudgetExt);
  }
 protected ScienceKeyword getScienceKeyword(Object element) {
   return getDataObjectService()
       .findUnique(
           ScienceKeyword.class, QueryByCriteria.Builder.forAttribute("code", element).build());
 }
 protected ExemptionType getExemptionType(Object element) {
   return getDataObjectService()
       .findUnique(
           ExemptionType.class, QueryByCriteria.Builder.forAttribute("code", element).build());
 }
  protected PropAwardPersonRoleServiceImpl getPropAwardPersonRoleService() {
    final PropAwardPersonRoleServiceImpl roleService = new PropAwardPersonRoleServiceImpl();
    final DataObjectService dataObjectService = context.mock(DataObjectService.class);
    final ParameterService parameterService = context.mock(ParameterService.class);
    final SponsorHierarchyService hierarchyService = context.mock(SponsorHierarchyService.class);

    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findMatching(
                    PropAwardPersonRole.class,
                    QueryByCriteria.Builder.forAttribute(
                            "sponsorHierarchyName",
                            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY)
                        .build());
            will(returnValue(roleListBuilder.build()));
          }
        });

    final QueryByCriteria.Builder criteriaCoInvestigator1 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.COI_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleCoInvestigator1 =
        createTestRole(
            3L, ContactRole.COI_CODE, PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaCoInvestigator1.build());
            will(returnValue(roleCoInvestigator1));
          }
        });

    final QueryByCriteria.Builder criteriaCoInvestigator2 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.COI_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleCoInvestigator2 =
        createTestRole(
            3L, ContactRole.COI_CODE, PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaCoInvestigator2.build());
            will(returnValue(roleCoInvestigator2));
          }
        });

    final QueryByCriteria.Builder criteriaKeyPerson1 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.KEY_PERSON_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleKeyPerson1 =
        createTestRole(
            3L,
            ContactRole.KEY_PERSON_CODE,
            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaKeyPerson1.build());
            will(returnValue(roleKeyPerson1));
          }
        });

    final QueryByCriteria.Builder criteriaKeyPerson2 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.KEY_PERSON_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleKeyPerson2 =
        createTestRole(
            3L,
            ContactRole.KEY_PERSON_CODE,
            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaKeyPerson2.build());
            will(returnValue(roleKeyPerson2));
          }
        });

    final QueryByCriteria.Builder criteriaKeyPerson3 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.KEY_PERSON_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleKeyPerson3 =
        createTestRole(
            3L,
            ContactRole.KEY_PERSON_CODE,
            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaKeyPerson3.build());
            will(returnValue(roleKeyPerson3));
          }
        });

    final QueryByCriteria.Builder criteriaKeyPerson4 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.KEY_PERSON_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleKeyPerson4 =
        createTestRole(
            3L,
            ContactRole.KEY_PERSON_CODE,
            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaKeyPerson4.build());
            will(returnValue(roleKeyPerson4));
          }
        });

    final QueryByCriteria.Builder criteriaKeyPerson5 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.KEY_PERSON_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole roleKeyPerson5 =
        createTestRole(
            3L,
            ContactRole.KEY_PERSON_CODE,
            PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaKeyPerson5.build());
            will(returnValue(roleKeyPerson5));
          }
        });

    final QueryByCriteria.Builder criteriaPrincipalInvestigator1 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.PI_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole rolePrincipalInvestigator1 =
        createTestRole(
            3L, ContactRole.PI_CODE, PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaPrincipalInvestigator1.build());
            will(returnValue(rolePrincipalInvestigator1));
          }
        });

    final QueryByCriteria.Builder criteriaPrincipalInvestigator2 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.PI_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole rolePrincipalInvestigator2 =
        createTestRole(
            3L, ContactRole.PI_CODE, PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaPrincipalInvestigator2.build());
            will(returnValue(rolePrincipalInvestigator2));
          }
        });

    final QueryByCriteria.Builder criteriaPrincipalInvestigator3 =
        QueryByCriteria.Builder.create()
            .setPredicates(
                PredicateFactory.equal("code", ContactRole.PI_CODE),
                PredicateFactory.equal(
                    "sponsorHierarchyName",
                    PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY));
    final PropAwardPersonRole rolePrincipalInvestigator3 =
        createTestRole(
            3L, ContactRole.PI_CODE, PropAwardPersonRoleServiceImpl.NIH_MULTIPLE_PI_HIERARCHY);
    context.checking(
        new Expectations() {
          {
            one(parameterService)
                .getParameterValueAsBoolean(
                    Constants.MODULE_NAMESPACE_PROPOSAL_DEVELOPMENT,
                    Constants.PARAMETER_COMPONENT_DOCUMENT,
                    PropAwardPersonRoleServiceImpl.ALL_SPONSOR_HIERARCHY_NIH_MULTI_PI);
            will(returnValue(true));
            one(dataObjectService)
                .findUnique(PropAwardPersonRole.class, criteriaPrincipalInvestigator3.build());
            will(returnValue(rolePrincipalInvestigator3));
          }
        });

    roleService.setDataObjectService(dataObjectService);
    roleService.setSponsorHierarchyService(hierarchyService);
    roleService.setParameterService(parameterService);
    return roleService;
  }
  @SuppressWarnings("unchecked")
  public void populateRoutingResponsibilities(DocumentConfigurationViewForm form) {
    // pull all the responsibilities
    // merge the data and attach to route levels
    // pull the route levels and store on form
    // List<RouteNode> routeNodes = getRouteNodeService().getFlattenedNodes(form.getDocumentType(),
    // true);
    Map<String, List<Role>> respToRoleMap = new HashMap<String, List<Role>>();
    List<ProcessDefinitionBo> processes =
        (List<ProcessDefinitionBo>) form.getDocumentType().getProcesses();
    if (!(processes.isEmpty())) {
      RouteNode rootNode = processes.get(0).getInitialRouteNode();
      LinkedHashMap<String, RouteNode> routeNodeMap = new LinkedHashMap<String, RouteNode>();
      flattenRouteNodes(rootNode, routeNodeMap);

      form.setRouteNodes(new ArrayList<RouteNode>(routeNodeMap.values()));
      // pull all the responsibilities and store into a map for use by the JSP

      // FILTER TO THE "Review" template only
      // pull responsibility roles
      DocumentType docType = form.getDocumentType();
      Set<Responsibility> responsibilities = new HashSet<Responsibility>();
      Map<String, List<ResponsibilityForDisplay>> nodeToRespMap =
          new LinkedHashMap<String, List<ResponsibilityForDisplay>>();
      while (docType != null) {
        QueryByCriteria.Builder builder = QueryByCriteria.Builder.create();
        Predicate p =
            and(
                equal("template.namespaceCode", KRADConstants.KUALI_RICE_WORKFLOW_NAMESPACE),
                equal("template.name", KewApiConstants.DEFAULT_RESPONSIBILITY_TEMPLATE_NAME),
                equal("active", "Y"),
                equal("attributes[documentTypeName]", docType.getName()));
        builder.setPredicates(p);
        List<Responsibility> resps =
            getResponsibilityService().findResponsibilities(builder.build()).getResults();

        for (Responsibility r : resps) {
          String routeNodeName =
              r.getAttributes().get(KimConstants.AttributeConstants.ROUTE_NODE_NAME);
          if (StringUtils.isNotBlank(routeNodeName)) {
            if (!nodeToRespMap.containsKey(routeNodeName)) {
              nodeToRespMap.put(routeNodeName, new ArrayList<ResponsibilityForDisplay>());
              nodeToRespMap.get(routeNodeName).add(new ResponsibilityForDisplay(r, false));
            } else {
              // check if the responsibility in the existing list is for the current document
              // if so, OK to add.  Otherwise, a lower level document has overridden this
              // responsibility (since we are walking up the hierarchy
              if (nodeToRespMap
                  .get(routeNodeName)
                  .get(0)
                  .getDetails()
                  .get(KimConstants.AttributeConstants.DOCUMENT_TYPE_NAME)
                  .equals(docType.getName())) {
                nodeToRespMap.get(routeNodeName).add(new ResponsibilityForDisplay(r, false));
              } else { // doc type name did not match, mark as overridden
                nodeToRespMap.get(routeNodeName).add(new ResponsibilityForDisplay(r, true));
              }
            }
            responsibilities.add(r);
          }
        }
        docType = docType.getParentDocType();
      }
      form.setResponsibilityMap(nodeToRespMap);

      for (Responsibility responsibility : responsibilities) {
        List<String> roleIds =
            getResponsibilityService().getRoleIdsForResponsibility(responsibility.getId());
        if (!roleIds.isEmpty()) {
          respToRoleMap.put(responsibility.getId(), getRoleService().getRoles(roleIds));
        }
      }
    }
    form.setResponsibilityRoles(respToRoleMap);
  }