Java PredicateFactory类代码示例

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);
    }