Java Filter.createEqualityFilter方法代码示例

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包/类
@Override
protected Filter itrValueComparisonExpression(ValueComparisonExpression query, Path path){
    String attributeName = fieldNameTranslator.translateFieldName(query.getField());
    String rValue = query.getRvalue().getValue().toString();

    switch(query.getOp()){
        case _eq:
            return Filter.createEqualityFilter(attributeName, rValue);
        case _neq:
            return Filter.createNOTFilter(Filter.createEqualityFilter(attributeName, rValue));
        case _gte:
            return Filter.createGreaterOrEqualFilter(attributeName, rValue);
        case _lte:
            return Filter.createLessOrEqualFilter(attributeName, rValue);
        case _gt: //aka. !lte
            return Filter.createNOTFilter(Filter.createLessOrEqualFilter(attributeName, rValue));
        case _lt: //aka. !gte
            return Filter.createNOTFilter(Filter.createGreaterOrEqualFilter(attributeName, rValue));
        default:
            throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
    }
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
@Override
public List<GluuCustomPerson> searchPersons(String pattern, int sizeLimit, List<GluuCustomPerson> excludedPersons) throws Exception {
	String[] targetArray = new String[] { pattern };
	Filter uidFilter = Filter.createSubstringFilter(OxTrustConstants.uid, null, targetArray, null);
	Filter mailFilter = Filter.createSubstringFilter(OxTrustConstants.mail, null, targetArray, null);
	Filter nameFilter = Filter.createSubstringFilter(OxTrustConstants.displayName, null, targetArray, null);
	Filter inameFilter = Filter.createSubstringFilter(OxTrustConstants.iname, null, targetArray, null);

	Filter orFilter = Filter.createORFilter(uidFilter, mailFilter, nameFilter, inameFilter);

	Filter searchFilter = orFilter;

	if (excludedPersons != null && excludedPersons.size() > 0) {
		List<Filter> excludeFilters = new ArrayList<Filter>();
		for (GluuCustomPerson excludedPerson : excludedPersons) {
			Filter eqFilter = Filter.createEqualityFilter(OxTrustConstants.uid, excludedPerson.getUid());
			excludeFilters.add(eqFilter);
		}
		Filter orExcludeFilter = null;
		if (excludedPersons.size() == 1) {
			orExcludeFilter = excludeFilters.get(0);
		} else {
			orExcludeFilter = Filter.createORFilter(excludeFilters);
		}
		Filter notFilter = Filter.createNOTFilter(orExcludeFilter);
		searchFilter = Filter.createANDFilter(orFilter, notFilter);
	}

	List<GluuCustomPerson> result = ldapEntryManager.findEntries(getDnForPerson(null), GluuCustomPerson.class, searchFilter, 0, sizeLimit);

	return result;

}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
/**
 * @return
 * @throws LDAPException
 */
private List<GluuAttribute> getAllActiveAtributesImpl(GluuUserRole gluuUserRole) {
	Filter filter = Filter.createEqualityFilter("gluuStatus", "active");
	List<GluuAttribute> attributeList = ldapEntryManager.findEntries(getDnForAttribute(null), GluuAttribute.class, filter);
	String customOrigin = getCustomOrigin();
	String[] objectClassTypes = applicationConfiguration.getPersonObjectClassTypes();
	log.debug("objectClassTypes={0}", Arrays.toString(objectClassTypes));
	List<GluuAttribute> returnAttributeList = new ArrayList<GluuAttribute>();
	for (GluuAttribute attribute : attributeList) {
		if (StringHelper.equalsIgnoreCase(attribute.getOrigin(), applicationConfiguration.getPersonCustomObjectClass()) &&
			(GluuUserRole.ADMIN == gluuUserRole)) {
			attribute.setCustom(true);
			returnAttributeList.add(attribute);
			continue;
		}

		for (String objectClassType : objectClassTypes) {
			if (attribute.getOrigin().equals(objectClassType)
					&& ((attribute.allowViewBy(gluuUserRole) || attribute.allowEditBy(gluuUserRole)))) {
				attribute.setCustom(customOrigin.equals(attribute.getOrigin()));
				returnAttributeList.add(attribute);
				break;
			}
		}
	}

	return returnAttributeList;
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
private List<GluuInumMap> loadInumServerEntries(CacheRefreshConfiguration cacheRefreshConfiguration, LdapServerConnection inumDbServerConnection) {
	LdapEntryManager inumDbldapEntryManager = inumDbServerConnection.getLdapEntryManager();
	String inumbaseDn = inumDbServerConnection.getBaseDns()[0];

	Filter filterObjectClass = Filter.createEqualityFilter(OxTrustConstants.objectClass, OxTrustConstants.objectClassInumMap);
	Filter filterStatus = Filter.createNOTFilter(Filter.createEqualityFilter(OxTrustConstants.gluuStatus, GluuStatus.INACTIVE.getValue()));
	Filter filter = Filter.createANDFilter(filterObjectClass, filterStatus);

	return inumDbldapEntryManager.findEntries(inumbaseDn, GluuInumMap.class, filter, null, cacheRefreshConfiguration.getLdapSearchSizeLimit());
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
/**
 * Looks the uid in ldap and return the DN
 */
protected String lookupDnByUid(String uid, String baseDN) throws SearchException {
	Filter filter = Filter.createEqualityFilter(LdapOperationsServiceImpl.uid, uid);
	SearchResult searchResult = search(baseDN, filter, 1, 1);
	if ((searchResult != null) && searchResult.getEntryCount() > 0) {
		return searchResult.getSearchEntries().get(0).getDN();
	}

	return null;
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
private SearchRequest createSearchRequest(String searchDN) {
	List<String> attributes = new ArrayList<String>();
	attributes.add("cn");
	addAttribute(attributes, givenNameAttribute);
	addAttribute(attributes, surNameAttribute);
	addAttribute(attributes, localeAttribute);
	addAttribute(attributes, organizationAttribute);
	addAttribute(attributes, divisionAttribute);
	addAttribute(attributes, rolesAttribute);
	SearchRequest request = new SearchRequest(searchDN, SearchScope.SUB, Filter.createEqualityFilter(
			"objectclass", "person"), attributes.toArray(new String[attributes.size()]));
	return request;
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
@Test
public void testInMemBind() throws Exception {
	String user = "cn=test,dc=staticsecurity,dc=geomajas,dc=org";
	LDAPConnection connection = new LDAPConnection("localhost", PORT);

	BindResult auth = connection.bind(user, "cred");
	System.out.println("auth " + auth);
	System.out.println("  rc " + auth.getResultCode());
	System.out.println("  cu " + auth.getResultCode().isConnectionUsable());
	System.out.println("  dn " + auth.getMatchedDN());
	System.out.println("  dm " + auth.getDiagnosticMessage());

	SearchRequest request = new SearchRequest(user,
			SearchScope.ONE, Filter.createEqualityFilter("objectclass", "person"),
			"cn", "groupMembership", "givenName", "sn", "ou");
	SearchResult search = connection.search(request);
	System.out.println(search);
	System.out.println("count " + search.getEntryCount());
	System.out.println("count " + search.getSearchEntries());
	for (SearchResultEntry se : search.getSearchEntries()) {
		System.out.println("-- cn " + se.getAttributeValue("cn"));
		System.out.println("   givenName " + se.getAttributeValue("givenName"));
		System.out.println("   sn " + se.getAttributeValue("sn"));
		System.out.println("   ou " + se.getAttributeValue("ou"));
		System.out.println("   groupMembership ");
		if (null != se.getAttributeValues("groupMembership")) {
			for (String val : se.getAttributeValues("groupMembership")) {
				System.out.println("      " + val);
			}
		}
	}
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
private Filter getLoginFilter(String username) {
	return Filter.createEqualityFilter(loginAttribute, username);
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
private List<GluuSimplePerson> loadTargetServerEntries(CacheRefreshConfiguration cacheRefreshConfiguration, LdapEntryManager targetLdapEntryManager) {
	Filter filter = Filter.createEqualityFilter(OxTrustConstants.objectClass, OxTrustConstants.objectClassPerson);

	return targetLdapEntryManager.findEntries(personService.getDnForPerson(null), GluuSimplePerson.class, filter,
			TARGET_PERSON_RETURN_ATTRIBUTES, cacheRefreshConfiguration.getLdapSearchSizeLimit());
}
 

import com.unboundid.ldap.sdk.Filter; //导入方法依赖的package包/类
public SearchInstance searchOpen(
    String name,
    int pageSize,
    int limit,
    Map<String, Object> vars
) throws Exception {

    log.debug(
        "searchOpen Entry name='{}', pageSize={}, limit={}",
        name,
        pageSize,
        limit
    );

    Map<String, Object> encodedvars = new HashMap<>(vars);
    for (String key : new HashSet<>(encodedvars.keySet())) {
        encodedvars.put(key + "_encoded", Filter.encodeValue(Util.toString(encodedvars.get(key))));
    }

    final String PREFIX_SEARCH = "search";
    MapProperties searchProps = Util.expandMap(
        new MapProperties(
            props.get(PREFIX_SEARCH, "default"),
            props.get(PREFIX_SEARCH, name)
        ),
        "seq",
        encodedvars
    );

    log.debug("Creating SearchRequest");
    SearchRequest searchRequest = new SearchRequest("", SearchScope.SUB, Filter.createEqualityFilter("objectClass", "invalid"));
    Util.setObjectByProperties(searchRequest, searchProps.get("search-request"), "set");
    log.debug("SearchRequest: {}", searchRequest);

    String override = searchProps.getString(
        "",
        "dc-resolve",
        "override"
    );

    SearchInstance instance = new SearchInstance();
    instance.connectionPoolEntry = getConnectionPoolEntry(
        searchProps.getMandatoryString("pool"),
        (
            searchProps.getBoolean(true, "dc-resolve", "enable") ?
            ("".equals(override) ? searchRequest.getBaseDN() : override) :
            null
        ),
        vars
    );
    instance.searchRequest = searchRequest;
    instance.doPaging = instance.connectionPoolEntry.supportPaging && searchProps.getBoolean(Boolean.TRUE, "paging");
    instance.pageSize = pageSize != 0 ? pageSize : searchProps.getInt(100, "pageSize");
    instance.limitLeft = limit != 0 ? limit : searchProps.getInt(Integer.MAX_VALUE, "limit");
    instance.attrMap = getAttrMap(searchProps.getString("", "attrmap"), vars);

    log.debug("SearchOpen Return {}", instance);

    return instance;
}