Java Filter类代码示例

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
private Set<String> rolesFromDN(String userDN) throws LDAPException, GeneralSecurityException {
  SearchRequest searchRequest = new SearchRequest(config.getRoleBaseDN(),
      SearchScope.SUB, Filter.createEqualityFilter("uniqueMember", userDN));
  Set<String> roles = Sets.newLinkedHashSet();

  LDAPConnection connection = connectionFactory.getLDAPConnection();
  try {
    SearchResult sr = connection.search(searchRequest);

    for (SearchResultEntry sre : sr.getSearchEntries()) {
      X500Name x500Name = new X500Name(sre.getDN());
      RDN[] rdns = x500Name.getRDNs(BCStyle.CN);
      if (rdns.length == 0) {
        logger.error("Could not create X500 Name for role:" + sre.getDN());
      } else {
        String commonName = IETFUtils.valueToString(rdns[0].getFirst().getValue());
        roles.add(commonName);
      }
    }
  } finally {
    connection.close();
  }

  return roles;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
private String getLoginDn(String username) {

		String loginDn = null;

		try {

			Filter userFilter = Filter.create(userSearchFilter);
			Filter loginFilter = getLoginFilter(username);
			Filter filter = Filter.createANDFilter(userFilter, loginFilter);

			List<SearchResultEntry> searchResultEntries = search(filter);
			if (!searchResultEntries.isEmpty()) {
				loginDn = searchResultEntries.get(0).getDN();
			}
		}
		catch (Exception e) {
			LOG.error(e.getMessage(), e);
		}

		return loginDn;
	}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
public List<SearchResultEntry> getAttributeResultEntryLDIF(LDAPConnection connection, List<String> patterns, String baseDN) {
	List<SearchResultEntry> searchResultEntryList = new ArrayList<SearchResultEntry>();
	try {
		for (String pattern : patterns) {
			String[] targetArray = new String[] { pattern };
			Filter inumFilter = Filter.createSubstringFilter("inum", null,targetArray, null);
			Filter searchFilter = Filter.createORFilter(inumFilter);
			SearchResultEntry sr = connection.searchForEntry(baseDN,SearchScope.SUB, searchFilter, null);
			searchResultEntryList.add(sr);
		}

		return searchResultEntryList;
	} catch (LDAPException le) {
		if (le.getResultCode() != ResultCode.NO_SUCH_OBJECT) {
			log.error("Failed to search ldif record", le);
			return null;
		}
	}
	return null;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
@Override
public List<org.geomajas.security.UserInfo> getUsers(UserFilter userFilter) {
	List<org.geomajas.security.UserInfo> users = new ArrayList<org.geomajas.security.UserInfo>();
	if (allUsersDn == null) {
		log.warn("Getting users from LDAP requires configuration of allUsersDn property");
	} else {
		SearchRequest request = createSearchRequest(allUsersDn);
		LdapFilterVisitor visitor = new LdapFilterVisitor();
		Filter ldapFilter = (Filter) userFilter.accept(visitor, null);
		if (ldapFilter != null) {
			Filter f = request.getFilter();
			request.setFilter(Filter.createANDFilter(f, ldapFilter));
		}
		SearchResult result = execute(request, null, null);
		if (result != null) {
			for (SearchResultEntry entry : result.getSearchEntries()) {
				users.add(getUserInfo(entry));
			}
		}
	}
	return users;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
/**
* Search by pattern
* 
* @param pattern Pattern
* @param sizeLimit Maximum count of results
* @return List of scopes
* @throws Exception
*/
public List<IDPEntry> searchIDPs(String pattern, int sizeLimit) throws Exception {
    // filter
    String[] targetArray = new String[] { pattern };
    Filter idFilter = Filter.createSubstringFilter(OxTrustConstants.uniqueIdentifier, null, targetArray, null);
    Filter friendlyNameFilter = Filter.createSubstringFilter(OxTrustConstants.friendlyName, null, targetArray, null);
    Filter descriptionFilter = Filter.createSubstringFilter(OxTrustConstants.description, null, targetArray, null);
    Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);
    Filter searchFilter = Filter.createORFilter(idFilter, friendlyNameFilter, descriptionFilter, inameFilter);

    // search
    final List<LdapIDPEntry> entries = ldapEntryManager.findEntries(getDnForLdapIDPEntry(null), LdapIDPEntry.class, searchFilter, sizeLimit);

    // convert result
    List<IDPEntry> ret = new ArrayList<IDPEntry>();
    for (LdapIDPEntry entry : entries) {
        ret.add(entry.getEntry());
    }
    return ret;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
/**
* Search by pattern
* 
* @param pattern Pattern
* @param sizeLimit Maximum count of results
* @return List of scopes
* @throws Exception
*/
public List<ApplicationSelectorEntry> searchSelectors(String pattern, int sizeLimit) throws Exception {
    // filter
    String[] targetArray = new String[] { pattern };
    Filter idFilter = Filter.createSubstringFilter(OxTrustConstants.uniqueIdentifier, null, targetArray, null);
    Filter friendlyNameFilter = Filter.createSubstringFilter(OxTrustConstants.friendlyName, null, targetArray, null);
    Filter descriptionFilter = Filter.createSubstringFilter(OxTrustConstants.description, null, targetArray, null);
    Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);
    Filter organizationIdFilter = Filter.createSubstringFilter(OxTrustConstants.organizationId, null, targetArray, null);
    Filter searchFilter = Filter.createORFilter(idFilter, friendlyNameFilter, descriptionFilter, inameFilter, organizationIdFilter);

    // search
    List<LDAPApplicationSelectorEntry> entries = ldapEntryManager.findEntries(getDnForLDAPApplicationSelectorEntry(null), LDAPApplicationSelectorEntry.class, searchFilter, sizeLimit);

    // convert result
    List<ApplicationSelectorEntry> ret = new ArrayList<ApplicationSelectorEntry>();
    for (LDAPApplicationSelectorEntry entry : entries) {
        ret.add(entry.getEntry());
    }
    return ret;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
/**
* Search by pattern
* 
* @param pattern Pattern
* @param sizeLimit Maximum count of results
* @return List of scopes
* @throws Exception
*/
public List<RequestorEntry> searchRequestors(String pattern, int sizeLimit) throws Exception {
    // filter
    String[] targetArray = new String[] { pattern };
    Filter idFilter = Filter.createSubstringFilter(OxTrustConstants.uniqueIdentifier, null, targetArray, null);
    Filter friendlyNameFilter = Filter.createSubstringFilter(OxTrustConstants.friendlyName, null, targetArray, null);
    Filter descriptionFilter = Filter.createSubstringFilter(OxTrustConstants.description, null, targetArray, null);
    Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);
    Filter searchFilter = Filter.createORFilter(idFilter, friendlyNameFilter, descriptionFilter, inameFilter);

    // search
    List<LDAPRequestorEntry> entries = ldapEntryManager.findEntries(getDnForLDAPRequestorEntry(null), LDAPRequestorEntry.class, searchFilter, sizeLimit);

    // convert result
    List<RequestorEntry> ret = new ArrayList<RequestorEntry>();
    for (LDAPRequestorEntry entry : entries) {
        ret.add(entry.getEntry());
    }
    return ret;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
/**
* Search by pattern
* 
* @param pattern Pattern
* @param sizeLimit Maximum count of results
* @return List of scopes
* @throws Exception
*/
public List<RequestorPoolEntry> searchRequestorPools(String pattern, int sizeLimit) throws Exception {
    // filter
    String[] targetArray = new String[] { pattern };
    Filter idFilter = Filter.createSubstringFilter(OxTrustConstants.uniqueIdentifier, null, targetArray, null);
    Filter friendlyNameFilter = Filter.createSubstringFilter(OxTrustConstants.friendlyName, null, targetArray, null);
    Filter descriptionFilter = Filter.createSubstringFilter(OxTrustConstants.description, null, targetArray, null);
    Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);
    Filter searchFilter = Filter.createORFilter(idFilter, friendlyNameFilter, descriptionFilter, inameFilter);

    // search
    List<LDAPRequestorPoolEntry> entries = ldapEntryManager.findEntries(getDnForLDAPRequestorPoolEntry(null), LDAPRequestorPoolEntry.class, searchFilter, sizeLimit);

    // convert result
    List<RequestorPoolEntry> ret = new ArrayList<RequestorPoolEntry>();
    for (LDAPRequestorPoolEntry entry : entries) {
        ret.add(entry.getEntry());
    }
    return ret;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
/**
 * Search groups by pattern
 * 
 * @param pattern
 *            Pattern
 * @param sizeLimit
 *            Maximum count of results
 * @return List of groups
 * @throws Exception
 */
public List<GluuAttribute> searchAttributes(String pattern, int sizeLimit) throws Exception {
	String[] targetArray = new String[] { pattern };
	Filter displayNameFilter = Filter.createSubstringFilter(OxTrustConstants.displayName, null, targetArray, null);
	Filter descriptionFilter = Filter.createSubstringFilter(OxTrustConstants.description, null, targetArray, null);
	Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);
	Filter searchFilter = Filter.createORFilter(displayNameFilter, descriptionFilter, inameFilter);

	List<GluuAttribute> result = ldapEntryManager.findEntries(getDnForAttribute(null), GluuAttribute.class, searchFilter, 0, sizeLimit);
	String customOrigin = getCustomOrigin();
	for (GluuAttribute attribute : result) {
		attribute.setCustom(customOrigin.equals(attribute.getOrigin()));
	}
	
	return result;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
private List<String> updateTargetEntriesViaVDS(CacheRefreshConfiguration cacheRefreshConfiguration, LdapServerConnection targetServerConnection, Set<String> changedInums) {
	List<String> result = new ArrayList<String>();

	LdapEntryManager targetLdapEntryManager = targetServerConnection.getLdapEntryManager();
	Filter filter = cacheRefreshService.createObjectClassPresenceFilter();
	for (String changedInum : changedInums) {
		String baseDn = "action=synchronizecache," + personService.getDnForPerson(changedInum);
		try {
			targetLdapEntryManager.findEntries(baseDn, GluuDummyEntry.class, filter, null, cacheRefreshConfiguration.getLdapSearchSizeLimit());
			result.add(changedInum);
			log.debug("Updated entry with inum {0}", changedInum);
		} catch (LdapMappingException ex) {
			log.error("Failed to update entry with inum '{0}' using baseDN {1}", ex, changedInum, baseDn);
		}
	}

	return result;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
private List<BaseScimResource> searchDevices(String filter, String sortBy, SortOrder sortOrder, int startIndex,
                                                int count, VirtualListViewResponse vlvResponse, String url) throws Exception {

    Filter ldapFilter=scimFilterParserService.createLdapFilter(filter, "oxId=*", FidoDeviceResource.class);
    //Transform scim attribute to LDAP attribute
    sortBy = FilterUtil.getLdapAttributeOfResourceAttribute(sortBy, FidoDeviceResource.class).getFirst();

    log.info("Executing search for fido devices using: ldapfilter '{}', sortBy '{}', sortOrder '{}', startIndex '{}', count '{}'",
            ldapFilter.toString(), sortBy, sortOrder.getValue(), startIndex, count);
    List<GluuCustomFidoDevice> list=ldapEntryManager.findEntriesSearchSearchResult(fidoDeviceService.getDnForFidoDevice(null, null),
            GluuCustomFidoDevice.class, ldapFilter, startIndex, count, getMaxCount(), sortBy, sortOrder, vlvResponse, null);

    List<BaseScimResource> resources=new ArrayList<BaseScimResource>();

    for (GluuCustomFidoDevice device : list){
        FidoDeviceResource scimDev=new FidoDeviceResource();
        transferAttributesToFidoResource(device, scimDev, url, getUserInumFromDN(device.getDn()));
        resources.add(scimDev);
    }
    log.info ("Found {} matching entries - returning {}", vlvResponse.getTotalResults(), list.size());
    return resources;

}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
public List<BaseScimResource> searchUsers(String filter, String sortBy, SortOrder sortOrder, int startIndex, int count,
                                          VirtualListViewResponse vlvResponse, String url, int maxCount) throws Exception{

    Filter ldapFilter=scimFilterParserService.createLdapFilter(filter, "inum=*", UserResource.class);
    //Transform scim attribute to LDAP attribute
    sortBy = FilterUtil.getLdapAttributeOfResourceAttribute(sortBy, UserResource.class).getFirst();

    log.info("Executing search for users using: ldapfilter '{}', sortBy '{}', sortOrder '{}', startIndex '{}', count '{}'",
            ldapFilter.toString(), sortBy, sortOrder.getValue(), startIndex, count);

    List<GluuCustomPerson> list=ldapEntryManager.findEntriesSearchSearchResult(personService.getDnForPerson(null),
            GluuCustomPerson.class, ldapFilter, startIndex, count, maxCount, sortBy, sortOrder, vlvResponse, null);
    List<BaseScimResource> resources=new ArrayList<BaseScimResource>();

    for (GluuCustomPerson person : list){
        UserResource scimUsr=new UserResource();
        transferAttributesToUserResource(person, scimUsr, url);
        resources.add(scimUsr);
    }
    log.info ("Found {} matching entries - returning {}", vlvResponse.getTotalResults(), list.size());
    return resources;

}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
private ASN1OctetString scrollSimplePagedResultsControl(LDAPConnection ldapConnection, String dn, Filter filter, SearchScope scope, Control[] controls, int startIndex) throws LDAPException, InvalidSimplePageControlException {
	SearchRequest searchRequest = new SearchRequest(dn, scope, filter, "dn");

	int currentStartIndex = startIndex;
	ASN1OctetString cookie = null;
	do {
		int pageSize = Math.min(currentStartIndex, 100);
		searchRequest.setControls(new Control[]{new SimplePagedResultsControl(pageSize, cookie, true)});
		setControls(searchRequest, controls);
		SearchResult searchResult = ldapConnection.search(searchRequest);

		currentStartIndex -= searchResult.getEntryCount();
		try {
			SimplePagedResultsControl c = SimplePagedResultsControl.get(searchResult);
			if (c != null) {
				cookie = c.getCookie();
			}
		} catch (LDAPException ex) {
			log.error("Error while accessing cookie", ex);
			throw new InvalidSimplePageControlException(ex.getResultCode(), "Error while accessing cookie");
		}
	} while ((cookie != null) && (cookie.getValueLength() > 0) && (currentStartIndex > 0));

	return cookie;
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
@Override
protected Filter itrArrayContainsExpression(ArrayContainsExpression query, Path path){
    String attributeName = fieldNameTranslator.translateFieldName(query.getArray());

    List<Filter> filters = new ArrayList<>();
    for(Value value : query.getValues()){
        filters.add(Filter.createEqualityFilter(attributeName, value.getValue().toString()));
    }

    switch(query.getOp()){
        case _all:
            return Filter.createANDFilter(filters);
        case _any:
            return Filter.createORFilter(filters);
        case _none:
            return Filter.createNOTFilter(Filter.createANDFilter(filters));
        default:
            throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
    }
}
 

import com.unboundid.ldap.sdk.Filter; //导入依赖的package包/类
@Override
protected Filter itrNaryValueRelationalExpression(NaryValueRelationalExpression query, Path path){
    String attributeName = fieldNameTranslator.translateFieldName(query.getField());
    List<Filter> filters = new ArrayList<>();
    for(Value value : query.getValues()){
        filters.add(Filter.createEqualityFilter(attributeName, value.getValue().toString()));
    }

    switch (query.getOp()){
        case _in:
            return Filter.createORFilter(filters);
        case _not_in:
            return Filter.createNOTFilter(Filter.createORFilter(filters));
        default:
            throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
    }
}