import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
protected QueryByCriteria buildInactivationBlockerCriteria(Object blockedObject, InactivationBlockingMetadata inactivationBlockingMetadata) {
    DataObjectMetadata blockingObjectMetadata =
            getDataObjectService().getMetadataRepository().getMetadata(inactivationBlockingMetadata.getBlockingDataObjectClass());
    DataObjectRelationship dataObjectRelationship =
            blockingObjectMetadata.getRelationship(inactivationBlockingMetadata.getBlockedAttributeName());

    // note, this method assumes that all PK fields of the blockedBo have a non-null and, for strings, non-blank values
    if (dataObjectRelationship != null && !dataObjectRelationship.getAttributeRelationships().isEmpty()) {
        DataObjectWrapper<?> wrap = getDataObjectService().wrap(blockedObject);
        List<Predicate> predicates = new ArrayList<Predicate>();
        for (DataObjectAttributeRelationship relationship : dataObjectRelationship.getAttributeRelationships()) {
            String fieldName = relationship.getParentAttributeName();
            Object fieldValue = wrap.getPropertyValue(relationship.getChildAttributeName());
            if (fieldValue != null && StringUtils.isNotBlank(fieldValue.toString())) {
                predicates.add(PredicateFactory.equal(fieldName, fieldValue));
            }
        }
        return QueryByCriteria.Builder.fromPredicates(predicates.toArray(new Predicate[predicates.size()]));
    }
    return null;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
/**
 * This method takes in a multi-value predicate which has more values than
 * can fit into a single SQL clause and splits them up into multiple
 * clauses which are concatenated by an OR statement.
 * @param p The predicate which needs to be split into smaller predicates
 * @param parent The criteria to add the predicate to
 */
private void splitMultiValuePredicate(MultiValuedPredicate p, C parent) {
    final String pp = p.getPropertyPath();
    int chunkCount = (int)Math.ceil(p.getValues().size() / (double)MULTI_VALUE_CHUNK_SIZE);
    Predicate[] multiValuePredicateChunks = new Predicate[chunkCount];
    Object[] values = p.getValues().toArray();
    int start = 0;
    for(int i = 0; i < chunkCount; i++) {
        Object[] valueChunk = Arrays.copyOfRange(values, start, start + MULTI_VALUE_CHUNK_SIZE);
        if (p instanceof InPredicate) {
            multiValuePredicateChunks[i] = PredicateFactory.in(pp, valueChunk);
        } else if (p instanceof InIgnoreCasePredicate) {
            multiValuePredicateChunks[i] = PredicateFactory.inIgnoreCase(pp, (CharSequence[])valueChunk);
        } else if (p instanceof NotInPredicate) {
            multiValuePredicateChunks[i] = PredicateFactory.notIn(pp, valueChunk);
        } else if (p instanceof NotInIgnoreCasePredicate) {
            multiValuePredicateChunks[i] = PredicateFactory.notInIgnoreCase(pp, (CharSequence[])valueChunk);
        } else {
            throw new UnsupportedPredicateException(p);
        }

        start += MULTI_VALUE_CHUNK_SIZE;
    }
    addPredicate(PredicateFactory.or(multiValuePredicateChunks), parent);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
protected List<RoleMemberBo> getRoleMembersForPrincipalId(Collection<String> roleIds, String principalId, Map<String,String> qualification ) {
    List<Predicate> criteria = new ArrayList<Predicate>();

    if (CollectionUtils.isNotEmpty(roleIds)) {
        if (roleIds.size() == 1) {
            criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.ROLE_ID, roleIds.iterator().next()) );
        } else {
            criteria.add( PredicateFactory.in(KIMPropertyConstants.RoleMember.ROLE_ID, roleIds) );
        }
    }

    if ( StringUtils.isNotBlank(principalId) ) {
        criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_ID, principalId) );
    }

    criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.PRINCIPAL.getCode()));

    Predicate roleQualificationPredicate = getRoleQualificationPredicate(qualification);
    if ( roleQualificationPredicate != null ) {
        criteria.add( roleQualificationPredicate );
    }

    return getRoleMembershipsForPredicates(criteria);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
protected List<RoleMemberBo> getRoleMembersForGroupIds(String roleId, List<String> groupIds) {
    if (CollectionUtils.isEmpty(groupIds)) {
        return new ArrayList<RoleMemberBo>();
    }

    List<RoleMemberBo> coll = getDataObjectService().findMatching( RoleMemberBo.class,
            QueryByCriteria.Builder.fromPredicates(
                    PredicateFactory.equal(KIMPropertyConstants.RoleMember.ROLE_ID, roleId),
                    PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.GROUP.getCode()),
                    PredicateFactory.in(KIMPropertyConstants.RoleMember.MEMBER_ID, groupIds) ) ).getResults();
    List<RoleMemberBo> results = new ArrayList<RoleMemberBo>(coll.size());
    DateTime now = new DateTime( getDateTimeService().getCurrentTimestamp().getTime() );

    for (RoleMemberBo rm : coll) {
        if (rm.isActive(now)) {
            results.add(rm);
        }
    }

    return results;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
public List<RoleMemberBo> getRoleGroupsForGroupIdsAndRoleIds(Collection<String> roleIds, Collection<String> groupIds, Map<String, String> qualification) {
    List<Predicate> criteria = new ArrayList<Predicate>();

    if (CollectionUtils.isNotEmpty(roleIds)) {
        criteria.add( PredicateFactory.in(KIMPropertyConstants.RoleMember.ROLE_ID, roleIds) );
    }

    if (CollectionUtils.isNotEmpty(groupIds)) {
        criteria.add( PredicateFactory.in(KIMPropertyConstants.RoleMember.MEMBER_ID, groupIds) );
    }
    criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.GROUP.getCode()));

    Predicate roleQualificationPredicate = getRoleQualificationPredicate(qualification);
    if ( roleQualificationPredicate != null ) {
        criteria.add( roleQualificationPredicate );
    }

    return getRoleMembershipsForPredicates(criteria);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
protected List<RoleMemberBo> getRoleMembershipsForRoleIdsAsMembers(Collection<String> roleIds,
        Map<String, String> qualification) {
    List<Predicate> criteria = new ArrayList<Predicate>();

    if (CollectionUtils.isNotEmpty(roleIds)) {
        criteria.add( PredicateFactory.in(KIMPropertyConstants.RoleMember.ROLE_ID, roleIds) );
    }

    criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, MemberType.ROLE.getCode()));

    Predicate roleQualificationPredicate = getRoleQualificationPredicate(qualification);
    if ( roleQualificationPredicate != null ) {
        criteria.add( roleQualificationPredicate );
    }

    return getRoleMembershipsForPredicates(criteria);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
protected List<RoleMemberBo> getRoleMembershipsForMemberId(String memberType, String memberId, Map<String, String> qualification) {
    if (StringUtils.isBlank(memberId) || StringUtils.isBlank(memberType)) {
        return new ArrayList<RoleMemberBo>(0);
    }

    List<Predicate> criteria = new ArrayList<Predicate>();

    criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_ID, memberId) );
    criteria.add( PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE, memberType) );

    Predicate roleQualificationPredicate = getRoleQualificationPredicate(qualification);
    if ( roleQualificationPredicate != null ) {
        criteria.add( roleQualificationPredicate );
    }

    return getRoleMembershipsForPredicates(criteria);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
/**
 *
 */
protected Map<String, DelegateTypeBo> getStoredDelegationImplMapFromRoleIds(Collection<String> roleIds) {
    if (roleIds != null && !roleIds.isEmpty()) {
        Map<String, DelegateTypeBo> results = new HashMap<String, DelegateTypeBo>();
        Collection<DelegateTypeBo> coll = getDataObjectService().findMatching(DelegateTypeBo.class,
                QueryByCriteria.Builder.fromPredicates(
                        PredicateFactory.in(KIMPropertyConstants.Delegation.ROLE_ID, roleIds),
                        PredicateFactory.equal(KIMPropertyConstants.Delegation.ACTIVE, Boolean.TRUE) ) ).getResults();

        for (DelegateTypeBo delegateBo : coll) {
            results.put(delegateBo.getDelegationId(), delegateBo);
        }

        return results;
    }

    return Collections.emptyMap();
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
public List<DelegateTypeBo> getPersonDelegations(String principalId){
	if(principalId==null) {
		return new ArrayList<DelegateTypeBo>();
       }
	List<DelegateMemberBo> delegationMembers =
       		getDataObjectService().findMatching(DelegateMemberBo.class, QueryByCriteria.Builder.fromPredicates(
       		        PredicateFactory.equal(KimConstants.PrimaryKeyConstants.MEMBER_ID, principalId),
       		        PredicateFactory.equal(KIMPropertyConstants.DelegationMember.MEMBER_TYPE_CODE, MemberType.PRINCIPAL.getCode()))).getResults();
	List<DelegateTypeBo> delegations = new ArrayList<DelegateTypeBo>();
	List<String> delegationIds = new ArrayList<String>();
	if(ObjectUtils.isNotNull(delegationMembers)){
		for(DelegateMemberBo delegationMember: delegationMembers){
			if( delegationMember.getDelegationId() != null && !delegationIds.contains(delegationMember.getDelegationId())){
				delegationIds.add(delegationMember.getDelegationId());
				delegations.add(getDataObjectService().find(DelegateTypeBo.class, delegationMember.getDelegationId()));
			}
		}
	}
	return delegations;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
public Map<String, Group> findGroupsForRole(final String roleId) {
    Map<String, Group> roleGroupMembers = new HashMap<String, Group>();

    // Find group members of a given role
    List<RoleMember> groupRoleMembers = getRoleService().findRoleMembers( QueryByCriteria.Builder.fromPredicates(
            PredicateFactory.equal(KIMPropertyConstants.RoleMember.ROLE_ID, roleId)
            , PredicateFactory.equal(KIMPropertyConstants.RoleMember.MEMBER_TYPE_CODE,MemberType.GROUP.getCode()))).getResults();

    List<String> groupIds = new ArrayList<String>( groupRoleMembers.size() );
    for ( RoleMember rm : groupRoleMembers ) {
        groupIds.add( rm.getMemberId() );
    }

    List<Group> groups = getGroupService().getGroups(groupIds);
    for ( Group g : groups ) {
        roleGroupMembers.put(g.getId(), g);
    }
    return roleGroupMembers;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindEquals1() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.equal("typeId", "Consumer"));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
        expectedIds.add("ID-AA");
        expectedIds.add("ID-CR");
        expectedIds.add("ID-ARP");
//        expectedIds.add("ID-NRA");
//        expectedIds.add("ID-UFT");
//        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindEquals2() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.equal("active", "true"));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
        expectedIds.add("ID-AA");
        expectedIds.add("ID-CR");
//        expectedIds.add("ID-ARP");
        expectedIds.add("ID-NRA");
        expectedIds.add("ID-UFT");
        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindLike() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.like("name", "%Association%"));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
        expectedIds.add("ID-AA");
//        expectedIds.add("ID-CR");
//        expectedIds.add("ID-ARP");
        expectedIds.add("ID-NRA");
//        expectedIds.add("ID-UFT");
//        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindDeepLike() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.like("description", "%magazine%"));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
//        expectedIds.add("ID-AA");
        expectedIds.add("ID-CR");
//        expectedIds.add("ID-ARP");
//        expectedIds.add("ID-NRA");
//        expectedIds.add("ID-UFT");
//        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindOr() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.or (
                PredicateFactory.equal("typeId", "Lobby"),
                PredicateFactory.equal("active", "false")));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
//        expectedIds.add("ID-AA");
//        expectedIds.add("ID-CR");
        expectedIds.add("ID-ARP");
        expectedIds.add("ID-NRA");
        expectedIds.add("ID-UFT");
//        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
    public void testFindAnd() {
        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
        QueryByCriteria.Builder criteria = QueryByCriteria.Builder.create();
        criteria.setPredicates(PredicateFactory.and (
                PredicateFactory.equal("typeId", "Consumer"),
                PredicateFactory.equal("active", "true")));
        instance.setCriteria(criteria.build());
        Collection<ContextDefinition> result = instance.findMatching(getTestContexts());
        Set<String> expectedIds = new LinkedHashSet<String>();
        expectedIds.add("ID-AA");
        expectedIds.add("ID-CR");
//        expectedIds.add("ID-ARP");
//        expectedIds.add("ID-NRA");
//        expectedIds.add("ID-UFT");
//        expectedIds.add("ID-AFL");
        testIds(expectedIds, result);
    }
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
/**
 * Finds the role membership (if exists) for the given role and member id
 * 
 * @param roleId id of role to find member for
 * @param memberRoleId id of member role
 * @param membershipQualifications Qualifications to match role membership
 * @return RoleMembership containing information on the member record, or null if the member id is not assigned to the role
 */
protected RoleMember getRoleMembershipForMemberType(String roleId, String memberId, String memberType, Map<String,String> membershipQualifications) {
    RoleService roleService = KimApiServiceLocator.getRoleService();

    RoleMemberQueryResults results = roleService.findRoleMembers( 
            QueryByCriteria.Builder.fromPredicates( 
                    PredicateFactory.equal("roleId", roleId),
                    PredicateFactory.equal("typeCode", memberType),
                    PredicateFactory.equal("memberId", memberId) ) );
    for (RoleMember roleMembershipInfo : results.getResults() ) {
        // no qualifiers - then an automatic match
        if (membershipQualifications == null || membershipQualifications.isEmpty() ) {
            return roleMembershipInfo;
        }
        // otherwise, check the qualifier attributes
        if (doQualificationsMatch(membershipQualifications, roleMembershipInfo.getAttributes())) {
            return roleMembershipInfo;
        }
    }

    return null;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
/**
 * Validates all the field requirements by chart. It obtains a List of parameters where the parameter names are like
 * "CHARTS_REQUIRING%" then loop through these parameters. If the system type is individual then invoke the
 * validateFieldRequirementByChartForIndividualSystemType for further validation, otherwise invoke the
 * validateFieldRequirementByChartForOneOrMultipleSystemType for further validation.
 *
 * @param systemState
 * @param capitalAssetSystems
 * @param capitalAssetItems
 * @param chartCode
 * @param documentType
 * @param systemType
 * @return
 */
protected boolean validateAllFieldRequirementsByChart(String systemState, List<CapitalAssetSystem> capitalAssetSystems, List<PurchasingCapitalAssetItem> capitalAssetItems, String chartCode, String documentType, String systemType) {
    boolean valid = true;
    Builder qbc = QueryByCriteria.Builder.create();
    qbc.setPredicates(and(
            equal(CabPropertyConstants.Parameter.PARAMETER_NAMESPACE_CODE, CabConstants.Parameters.NAMESPACE),
            equal(CabPropertyConstants.Parameter.PARAMETER_DETAIL_TYPE_CODE, CabConstants.Parameters.DETAIL_TYPE_DOCUMENT),
            PredicateFactory.like(CabPropertyConstants.Parameter.PARAMETER_NAME, "CHARTS_REQUIRING%" + documentType)));

    List<Parameter> results = parameterRepositoryService.findParameters(qbc.build()).getResults();
    for (Parameter parameter : results) {
        if (ObjectUtils.isNotNull(parameter)) {
            if (systemType.equals(PurapConstants.CapitalAssetSystemTypes.INDIVIDUAL)) {
                valid &= validateFieldRequirementByChartForIndividualSystemType(systemState, capitalAssetItems, chartCode, parameter.getName(), parameter.getValue());
            } else {
                valid &= validateFieldRequirementByChartForOneOrMultipleSystemType(systemType, systemState, capitalAssetSystems, capitalAssetItems, chartCode, parameter.getName(), parameter.getValue());
            }
        }
    }
    return valid;
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
/**
 * Generates a batch of test objects and returns a single query that will select them all.
 * The order of the returned list of test objects should match the order of the results returned
 * by the underlying platform (i.e., if they are returned in a sorted order, then the test object
 * list should be sorted).
 */
protected Map.Entry<List<Object>, QueryByCriteria.Builder> createForQuery(int count) {
    List<Object> objects = new ArrayList<Object>();
    List<Predicate> predicates = new ArrayList<Predicate>(count);
    for (int i = 0; i < count; i++) {
        Object a = createLinkedTestObject();
        objects.add(a);
        predicates.add(queryFor(a).getPredicate());
    }
    QueryByCriteria.Builder qbc = QueryByCriteria.Builder.create();
    qbc.setPredicates(PredicateFactory.or(predicates.toArray(new Predicate[count])));
    return new AbstractMap.SimpleImmutableEntry<List<Object>, QueryByCriteria.Builder>(objects, qbc);
}
 

import org.kuali.rice.core.api.criteria.PredicateFactory; //导入依赖的package包/类
@Test
public void testExistsSubQueryCriteria() {

    Logger.getLogger(getClass()).info( "Adding Account" );
    Account acct = new Account();
    acct.setNumber("a1");
    acct.setName("a1 name");
    provider.save(acct, PersistenceOption.FLUSH);

    Logger.getLogger(getClass()).info( "Testing Account Saved" );
    acct = provider.find(Account.class, "a1");
    assertNotNull( "a1 SimpleAccount missing", acct );
    /*
     * Testing query of form:
     *
     * SELECT * FROM SimpleAccount WHERE EXISTS ( SELECT 'x' FROM SimpleAccountExtension WHERE SimpleAccountExtension.number = SimpleAccount.number )
     */
    Predicate subquery = PredicateFactory.existsSubquery(AccountExtension.class.getName(), PredicateFactory.equalsProperty("number", null, "parent.number"));
    QueryByCriteria q = QueryByCriteria.Builder.fromPredicates(subquery);
    Logger.getLogger(getClass()).info( "Performing Lookup with Exists Query: " + q );
    QueryResults<Account> results = provider.findMatching(Account.class, q);

    assertNotNull( "Results should not have been null", results );
    assertEquals( "Should have been no results in the default data", 0, results.getResults().size() );

    Logger.getLogger(getClass()).info( "Building extension object for retest" );
    AccountExtension ext = new AccountExtension();
    ext.setAccount(acct);
    ext.setAccountTypeCode("EAX");
    provider.save(ext, PersistenceOption.FLUSH);

    Logger.getLogger(getClass()).info( "Running query again to test results" );
    results = provider.findMatching(Account.class, q);
    assertNotNull( "Results should not have been null", results );
    assertEquals( "We added an extension record, so there should have been one result", 1, results.getResults().size() );
}