Java SearchResultEntry类代码示例

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的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.SearchResultEntry; //导入依赖的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.SearchResultEntry; //导入依赖的package包/类
private SearchResultEntry getEntryByMail(String mail) {
  try {
    for (String ou : allOUs()) {
      String dn = ldapUserBaseDN.replace("{}", ou);
      SearchRequest ldapRequest = new SearchRequest(dn, SearchScope.SUB, "(mail=" + mail + ")");
      SearchResult ldapResult = ldapConnection.search(ldapRequest);

      if (ldapResult.getEntryCount() > 0) {
        return ldapResult.getSearchEntries().get(0);
      }
    }

    return null;
  } catch (LDAPException e) {
    return null;
  }
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
private SearchResultEntry getEntryById(String id) {
  try {
    for (String ou : allOUs()) {
      String dn = ldapUserBaseDN.replace("{}", ou);
      SearchRequest ldapRequest = new SearchRequest(dn, SearchScope.SUB, "(uid=" + id + ")");
      SearchResult ldapResult = ldapConnection.search(ldapRequest);

      if (ldapResult.getEntryCount() > 0) {
        return ldapResult.getSearchEntries().get(0);
      }
    }
    return null;
  } catch (LDAPException e) {
    return null;
  }
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
public UserLdapDetails get(SearchResultEntry entry) {
  String company = "";
  try {
    company = getCompanyByDn(entry.getParentDNString());
  } catch (LDAPException e) {
    logger.warn("Failed to extract company from entry");
  }

  return new UserLdapDetails(
    entry.getAttributeValue("givenName"),
    entry.getAttributeValue("sn"),
    entry.getAttributeValue("mail"),
    entry.getAttributeValue("telephoneNumber"),
    entry.getAttributeValue("l"),
    entry.getAttributeValue("title"),
    company
  );
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
private List<LoadBalancingAlgorithmStatus> getLoadBalancingAlgorithmStatuses()
        throws LDAPException
{
  List<LoadBalancingAlgorithmStatus> lbaStatuses = new ArrayList<>();
  SearchResult result =
          findMonitorEntries("ds-load-balancing-algorithm-monitor-entry", "*");
  for (SearchResultEntry entry : result.getSearchEntries())
  {
    lbaStatuses.add(new LoadBalancingAlgorithmStatus(
            entry.getAttributeValue("algorithm-name"),
            parseAvailabilityString(entry.getAttributeValue("health-check-state")),
            entry.getAttributeValueAsInteger("num-available-servers"),
            entry.getAttributeValueAsInteger("num-degraded-servers"),
            entry.getAttributeValueAsInteger("num-unavailable-servers")));
  }
  return lbaStatuses;
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
@Before
public void setup() throws Exception {
  LdapLookupConfig config = new LdapLookupConfig("ou=users,dc=example,dc=com",
      "uid", ImmutableSet.of("admin"), "ou=roles,dc=example,dc=com");
  ldapAuthenticator = new LdapAuthenticator(ldapConnectionFactory, config);

  List<SearchResultEntry> dnResults =
      Arrays.asList(new SearchResultEntry(PEOPLE_DN, new Attribute[]{}));
  List<SearchResultEntry> roleResults =
      Arrays.asList(new SearchResultEntry("cn=admin,ou=roles", new Attribute[]{}));

  when(ldapConnectionFactory.getLDAPConnection()).thenReturn(ldapConnection);

  when(ldapConnection.search(argThat(new IsDnSearch()))).thenReturn(dnSearchResult);
  when(dnSearchResult.getEntryCount()).thenReturn(1);
  when(dnSearchResult.getSearchEntries()).thenReturn(dnResults);

  when(ldapConnection.search(argThat(new IsRoleSearch()))).thenReturn(roleSearchResult);
  when(roleSearchResult.getEntryCount()).thenReturn(1);
  when(roleSearchResult.getSearchEntries()).thenReturn(roleResults);
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
private void setAccountRoles(LDAPConnection ldapConnection, SearchResultEntry accountSearchResult, Account account) {
    String accountDN = accountSearchResult.getDN();

    String groupMemberPattern = this.groupMemberPattern.replace("${dn}", escapeLDAPSearchFilter(accountDN));
    groupMemberPattern = groupMemberPattern.replace("${username}", escapeLDAPSearchFilter(account.getUsername()));

    // Fill in attributes into groupMemberPattern
    for (Attribute attribute : accountSearchResult.getAttributes()) {
        groupMemberPattern = groupMemberPattern.replace("${" + attribute.getName() + "}", escapeLDAPSearchFilter(attribute.getValue()));
    }

    SearchResult groupsSearchResult = doSearch(ldapConnection, groupBase, true, groupMemberPattern, Arrays.asList("cn"));
    if (groupsSearchResult != null && groupsSearchResult.getEntryCount() > 0) {
        for (int i = 0; i < groupsSearchResult.getEntryCount(); i++) {
            SearchResultEntry groupEntry = groupsSearchResult.getSearchEntries().get(i);
            String roleName = groupEntry.getAttribute("cn").getValue();

            account.getAuthorizations().addRole(roleName);
        }
    }
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
private Set<AuthorName> searchAlternateNames(String uid, AuthorName primaryName) {

		Set<AuthorName> alternateNames = new HashSet<AuthorName>();
		String filter = "(&(objectClass=weillCornellEduSORRecord)(weillCornellEduCWID=" + uid + "))";
		List<SearchResultEntry> results = searchWithBaseDN(filter, "ou=sors,dc=weill,dc=cornell,dc=edu");
		for (SearchResultEntry entry : results) {
			AuthorName authorName = new AuthorName(
					entry.getAttributeValue("givenName"),
					entry.getAttributeValue("weillCornellEduMiddleName"),
					entry.getAttributeValue("sn").replace("- M.D.", "")); //Added fix for some surnames having degree in their surnames - M.D.
			if (!primaryName.equals(authorName)) {
				alternateNames.add(authorName);
			}
		}
		return alternateNames;
	}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
@Override
public Set<String> getUserRoles(String username) throws Exception {
    LOGGER.debug("getRoles("+username+")");

    Objects.requireNonNull(username);

    Set<String> roles = new HashSet<>();

    String filter = "(uid=" + username + ")";

    SearchRequest searchRequest = new SearchRequest(searchBase, SearchScope.SUB, filter);
    SearchResult searchResult = connectionPool.search(searchRequest);
    List<SearchResultEntry> searchResultEntries = searchResult.getSearchEntries();

    if(searchResultEntries.isEmpty()) {
        LOGGER.warn("No result found roles for user: " + username);
        return new HashSet<String>();
    } else if (searchResultEntries.size() > 1) {
        LOGGER.error("Multiples users found and only one was expected for user: " + username);
        return new HashSet<String>();
    } else {
        for(SearchResultEntry searchResultEntry : searchResultEntries) {
            String[] groups = searchResultEntry.getAttributeValues("memberOf");
            if(null != groups) {
                for(String group : groups) {
                    for (RDN rdn : new DN(group).getRDNs()) {
                        if (rdn.hasAttribute("cn")) {
                            roles.addAll(Arrays.asList(rdn.getAttributeValues()));
                            break;
                        }
                    }
                }
            }
        }
    }

    return roles;
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
@Override
public SearchResultEntry lookup(String dn, String... attributes) throws ConnectionException {
	if (StringHelper.equalsIgnoreCase(dn, "o=gluu")) {
		(new Exception()).printStackTrace();
	}

	try {
		if (attributes == null) {
			return getConnectionPool().getEntry(dn);
		} else {
			return getConnectionPool().getEntry(dn, attributes);
		}
	} catch (Exception ex) {
		throw new ConnectionException("Failed to lookup entry", ex);
	}
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
public int compare(T entry1, T entry2, String attributeName) {
	Object value1 = ((SearchResultEntry) entry1).getAttribute(attributeName);
	Object value2 = ((SearchResultEntry) entry2).getAttribute(attributeName);

	if ((value1 == null) && (value2 == null)) {
		return 0;
	}
	if ((value1 == null) && (value2 != null)) {
		return -1;
	} else if ((value1 != null) && (value2 == null)) {
		return 1;
	}

	if (value1 instanceof Date) {
		return ((Date) value1).compareTo((Date) value2);
	} else if (value1 instanceof Integer) {
		return ((Integer) value1).compareTo((Integer) value2);
	} else if (value1 instanceof String && value2 instanceof String) {
		if (caseSensetive) {
			return ((String) value1).compareTo((String) value2);
		} else {
			return ((String) value1).toLowerCase().compareTo(((String) value2).toLowerCase());
		}
	}
          return 0;
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的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.SearchResultEntry; //导入依赖的package包/类
private void removeSubtreeThroughIteration(String dn) {
   	SearchResult searchResult = null;
   	try {
   		searchResult = this.ldapOperationService.search(dn, toLdapFilter(Filter.createPresenceFilter("objectClass")), 0, 0, null, "dn");
		if (!ResultCode.SUCCESS.equals(searchResult.getResultCode())) {
			throw new EntryPersistenceException(String.format("Failed to find sub-entries of entry '%s' for removal", dn));
		}
	} catch (SearchException ex) {
           throw new EntryPersistenceException(String.format("Failed to find sub-entries of entry '%s' for removal", dn), ex);
	}

   	List<String> removeEntriesDn = new ArrayList<String>(searchResult.getEntryCount());
   	for (SearchResultEntry searchResultEntry : searchResult.getSearchEntries()) {
   		removeEntriesDn.add(searchResultEntry.getDN());
   	}
   	
   	Collections.sort(removeEntriesDn, LINE_LENGHT_COMPARATOR);

   	for (String removeEntryDn : removeEntriesDn) {
   		remove(removeEntryDn);
   	}
}
 

import com.unboundid.ldap.sdk.SearchResultEntry; //导入依赖的package包/类
@Override
protected List<AttributeData> find(String dn, String ... ldapReturnAttributes) {
	// Load entry

	try {
		SearchResultEntry entry = this.ldapOperationService.lookup(dn, ldapReturnAttributes);
		List<AttributeData> result = getAttributeDataList(entry);
		if (result != null) {
			return result;
		}
	} catch (Exception ex) {
		throw new EntryPersistenceException(String.format("Failed to find entry: %s", dn), ex);
	}

	throw new EntryPersistenceException(String.format("Failed to find entry: %s", dn));
}