org.xdi.oxauth.service.ClientService クラス

org.xdi.oxauth.service.ClientService 連携図

公開メンバ関数
void	persist (Client client)
void	merge (Client client)
boolean	authenticate (String clientId, String password)
Set< Client >	getClient (Collection< String > clientIds, boolean silent)
Client	getClient (String clientId)
Client	getClient (String clientId, String registrationAccessToken)
Set< Client >	getClientsByDns (Collection< String > dnList)
Set< Client >	getClientsByDns (Collection< String > dnList, boolean silently)
Client	getClientByDn (String dn)
org.gluu.persist.model.base.CustomAttribute	getCustomAttribute (Client client, String attributeName)
void	setCustomAttribute (Client client, String attributeName, String attributeValue)
List< Client >	getAllClients (String[] returnAttributes)
List< Client >	getAllClients (String[] returnAttributes, int size)
List< Client >	getClientsWithExpirationDate (BatchOperation< Client > batchOperation, String[] returnAttributes, int sizeLimit, int chunkSize)
String	buildClientDn (String p_clientId)
void	remove (Client client)
void	updatAccessTime (Client client, boolean isUpdateLogonTime)
Object	getAttribute (Client client, String clientAttribute) throws InvalidClaimException
String	decryptSecret (String encryptedClientSecret) throws EncryptionException
String	encryptSecret (String clientSecret) throws EncryptionException

静的公開変数類
static final String []	CLIENT_OBJECT_CLASSES = new String[] { "oxAuthClient" }

非公開メンバ関数
void	putInCache (Client client)
Client	fromCache (String dn)
void	removeFromCache (Client client)

静的非公開メンバ関数
static String	getClientIdCacheKey (String clientId)
static String	getClientDnCacheKey (String dn)

非公開変数類
Logger	log
PersistenceEntryManager	ldapEntryManager
CacheService	cacheService
ScopeService	scopeService
ClientFilterService	clientFilterService
EncryptionService	encryptionService
AppConfiguration	appConfiguration
StaticConfiguration	staticConfiguration

静的非公開変数類
static final String	CACHE_CLIENT_NAME = "ClientCache"
static final String	CACHE_CLIENT_FILTER_NAME = "ClientFilterCache"

詳解

Provides operations with clients.

著者

Javier Rojas Blum

Yuriy Movchan Date: 04/15/2014

バージョン

October 22, 2016

関数詳解

authenticate()

boolean org.xdi.oxauth.service.ClientService.authenticate ( String  clientId, String  password  )

inline

Authenticate client.

引数

clientId	Client inum.
password	Client password.

戻り値

true if success, otherwise false.

                                                                  {
        log.debug("Authenticating Client with LDAP: clientId = {}", clientId);
        boolean authenticated = false;

        try {
            Client client = getClient(clientId);
            String decryptedClientSecret = decryptSecret(client.getClientSecret());
            authenticated = client != null && decryptedClientSecret != null
                    && decryptedClientSecret.equals(password);
        } catch (StringEncrypter.EncryptionException e) {
            log.error(e.getMessage(), e);
        }

        return authenticated;
    }

buildClientDn()

String org.xdi.oxauth.service.ClientService.buildClientDn ( String  p_clientId )

inline

                                                   {
        final StringBuilder dn = new StringBuilder();
        dn.append(String.format("inum=%s,", p_clientId));
        dn.append(staticConfiguration.getBaseDn().getClients()); // ou=clients,o=@!1111,o=gluu
        return dn.toString();
    }

decryptSecret()

String org.xdi.oxauth.service.ClientService.decryptSecret ( String  encryptedClientSecret ) throws EncryptionException

inline

                                                                                             {
                return encryptionService.decrypt(encryptedClientSecret);
        }

encryptSecret()

String org.xdi.oxauth.service.ClientService.encryptSecret ( String  clientSecret ) throws EncryptionException

inline

                                                                                    {
                return encryptionService.encrypt(clientSecret);
        }

fromCache()

Client org.xdi.oxauth.service.ClientService.fromCache ( String  dn )

inlineprivate

                                        {
        try {
            String key = getClientDnCacheKey(dn);
            return (Client) cacheService.get(CACHE_CLIENT_NAME, key);
        } catch (Exception e) {
            log.error("Failed to fetch client from cache, dn: " + dn, e);
            return null;
        }
    }

getAllClients() [1/2]

List<Client> org.xdi.oxauth.service.ClientService.getAllClients ( String []  returnAttributes )

inline

                                                                 {
        String baseDn = staticConfiguration.getBaseDn().getClients();

        List<Client> result = ldapEntryManager.findEntries(baseDn, Client.class, null, returnAttributes);

        return result;
    }

getAllClients() [2/2]

List<Client> org.xdi.oxauth.service.ClientService.getAllClients ( String []  returnAttributes, int  size  )

inline

                                                                           {
        String baseDn = staticConfiguration.getBaseDn().getClients();

        List<Client> result = ldapEntryManager.findEntries(baseDn, Client.class, null, returnAttributes, size);

        return result;
    }

getAttribute()

Object org.xdi.oxauth.service.ClientService.getAttribute ( Client  client, String  clientAttribute  ) throws InvalidClaimException

inline

                                                                                                   {
        Object attribute = null;

        if (clientAttribute != null) {
            if (clientAttribute.equals("displayName")) {
                attribute = client.getClientName();
            } else if (clientAttribute.equals("inum")) {
                attribute = client.getClientId();
            } else if (clientAttribute.equals("oxAuthAppType")) {
                attribute = client.getApplicationType();
            } else if (clientAttribute.equals("oxAuthIdTokenSignedResponseAlg")) {
                attribute = client.getIdTokenSignedResponseAlg();
            } else if (clientAttribute.equals("oxAuthRedirectURI") && client.getRedirectUris() != null) {
                JSONArray array = new JSONArray();
                for (String redirectUri : client.getRedirectUris()) {
                    array.put(redirectUri);
                }
                attribute = array;
            } else if (clientAttribute.equals("oxAuthScope") && client.getScopes() != null) {
                JSONArray array = new JSONArray();
                for (String scopeDN : client.getScopes()) {
                    Scope s = scopeService.getScopeByDn(scopeDN);
                    if (s != null) {
                        String scopeName = s.getDisplayName();
                        array.put(scopeName);
                    }
                }
                attribute = array;
            } else {
                for (CustomAttribute customAttribute : client.getCustomAttributes()) {
                    if (customAttribute.getName().equals(clientAttribute)) {
                        List<String> values = customAttribute.getValues();
                        if (values != null) {
                            if (values.size() == 1) {
                                attribute = values.get(0);
                            } else {
                                JSONArray array = new JSONArray();
                                for (String v : values) {
                                    array.put(v);
                                }
                                attribute = array;
                            }
                        }

                        break;
                    }
                }
            }
        }

        return attribute;
    }

getClient() [1/3]

Set<Client> org.xdi.oxauth.service.ClientService.getClient ( Collection< String >  clientIds, boolean  silent  )

inline

                                                                               {
        Set<Client> set = Sets.newHashSet();

        if (clientIds == null) {
            return set;
        }

        for (String clientId : clientIds) {
            try {
                Client client = getClient(clientId);
                if (client != null) {
                    set.add(client);
                }
            } catch (RuntimeException e) {
                if (!silent) {
                    throw e;
                }
            }
        }
        return set;
    }

getClient() [2/3]

Client org.xdi.oxauth.service.ClientService.getClient ( String  clientId )

inline

                                             {
        if (clientId != null && !clientId.isEmpty()) {
            Client result = getClientByDn(buildClientDn(clientId));
            log.debug("Found {} entries for client id = {}", result != null ? 1 : 0, clientId);

            return result;
        }
        return null;
    }

getClient() [3/3]

Client org.xdi.oxauth.service.ClientService.getClient ( String  clientId, String  registrationAccessToken  )

inline

                                                                             {
        String baseDN = staticConfiguration.getBaseDn().getClients();

        Filter filterInum = Filter.createEqualityFilter("inum", clientId);
        Filter registrationAccessTokenInum = Filter.createEqualityFilter("oxAuthRegistrationAccessToken", registrationAccessToken);
        Filter filter = Filter.createANDFilter(filterInum, registrationAccessTokenInum);

        List<Client> clients = ldapEntryManager.findEntries(baseDN, Client.class, filter, null, 1);
        if (clients != null && clients.size() > 0) {
            return clients.get(0);
        }

        return null;
    }

getClientByDn()

Client org.xdi.oxauth.service.ClientService.getClientByDn ( String  dn )

inline

Returns client by DN.

引数

dn	dn of client

戻り値

Client

                                           {
        Client client = fromCache(dn);
        if (client == null) {
            try {
                client = ldapEntryManager.find(Client.class, dn);
                putInCache(client);
            } catch (Exception ex) {
                log.debug(ex.getMessage());
            }
        } else {
            log.trace("Get client from cache by Dn '{}'", dn);
        }

        return client;
    }

getClientDnCacheKey()

static String org.xdi.oxauth.service.ClientService.getClientDnCacheKey ( String  dn )

inlinestaticprivate

                                                         {
        return "client_dn_" + StringHelper.toLowerCase(dn);
    }

getClientIdCacheKey()

static String org.xdi.oxauth.service.ClientService.getClientIdCacheKey ( String  clientId )

inlinestaticprivate

                                                               {
        return "client_id_" + StringHelper.toLowerCase(clientId);
    }

getClientsByDns() [1/2]

Set<Client> org.xdi.oxauth.service.ClientService.getClientsByDns ( Collection< String >  dnList )

inline

                                                                  {
        return getClientsByDns(dnList, true);
    }

getClientsByDns() [2/2]

Set<Client> org.xdi.oxauth.service.ClientService.getClientsByDns ( Collection< String >  dnList, boolean  silently  )

inline

                                                                                    {
        Preconditions.checkNotNull(dnList);

        final Set<Client> result = Sets.newHashSet();
        for (String clientDn : dnList) {
            try {
                result.add(getClientByDn(clientDn));
            } catch (RuntimeException e) {
                if (!silently) {
                    throw e;
                }
            }
        }
        return result;
    }

getClientsWithExpirationDate()

List<Client> org.xdi.oxauth.service.ClientService.getClientsWithExpirationDate ( BatchOperation< Client >  batchOperation, String []  returnAttributes, int  sizeLimit, int  chunkSize  )

inline

                                                                                                                                                     {
        String baseDN = staticConfiguration.getBaseDn().getClients();
        Filter filter = Filter.createPresenceFilter("oxAuthClientSecretExpiresAt");
        return ldapEntryManager.findEntries(baseDN, Client.class, filter, SearchScope.SUB, returnAttributes, batchOperation, 0, sizeLimit, chunkSize);
    }

getCustomAttribute()

org.gluu.persist.model.base.CustomAttribute org.xdi.oxauth.service.ClientService.getCustomAttribute ( Client  client, String  attributeName  )

inline

                                                                                                               {
        for (org.gluu.persist.model.base.CustomAttribute customAttribute : client.getCustomAttributes()) {
            if (StringHelper.equalsIgnoreCase(attributeName, customAttribute.getName())) {
                return customAttribute;
            }
        }

        return null;
    }

merge()

void org.xdi.oxauth.service.ClientService.merge ( Client  client )

inline

                                     {
        ldapEntryManager.merge(client);
        removeFromCache(client);
    }

persist()

void org.xdi.oxauth.service.ClientService.persist ( Client  client )

inline

                                       {
        ldapEntryManager.persist(client);
    }

putInCache()

void org.xdi.oxauth.service.ClientService.putInCache ( Client  client )

inlineprivate

                                           {
        if (client == null) {
                return;
        }

        try {
            cacheService.put(CACHE_CLIENT_FILTER_NAME, getClientIdCacheKey(client.getClientId()), client, Constants.SKIP_CACHE_PUT_FOR_NATIVE_PERSISTENCE);
            cacheService.put(CACHE_CLIENT_NAME, getClientDnCacheKey(client.getDn()), client, Constants.SKIP_CACHE_PUT_FOR_NATIVE_PERSISTENCE);
        } catch (Exception e) {
            log.error("Failed to put client in cache, client:" + client, e);
        }
    }

remove()

void org.xdi.oxauth.service.ClientService.remove ( Client  client )

inline

                                      {
        if (client != null) {
            removeFromCache(client);

            String clientDn = client.getDn();
            ldapEntryManager.removeRecursively(clientDn);
        }
    }

removeFromCache()

void org.xdi.oxauth.service.ClientService.removeFromCache ( Client  client )

inlineprivate

                                                {
        try {
            String clientId = client.getClientId();
            String clientDn = client.getDn();

            cacheService.remove(CACHE_CLIENT_FILTER_NAME, getClientIdCacheKey(clientId));
            cacheService.remove(CACHE_CLIENT_NAME, getClientDnCacheKey(clientDn));
        } catch (Exception e) {
            log.error("Failed to remove client from cache.", e);
        }
    }

setCustomAttribute()

void org.xdi.oxauth.service.ClientService.setCustomAttribute ( Client  client, String  attributeName, String  attributeValue  )

inline

                                                                                               {
        org.gluu.persist.model.base.CustomAttribute customAttribute = getCustomAttribute(client, attributeName);

        if (customAttribute == null) {
            customAttribute = new org.gluu.persist.model.base.CustomAttribute(attributeName);
            client.getCustomAttributes().add(customAttribute);
        }

        customAttribute.setValue(attributeValue);
    }

updatAccessTime()

void org.xdi.oxauth.service.ClientService.updatAccessTime ( Client  client, boolean  isUpdateLogonTime  )

inline

                                                                          {
                if (!appConfiguration.getUpdateClientAccessTime()) {
                        return;
                }

                String clientDn = client.getDn();

        CustomEntry customEntry = new CustomEntry();
        customEntry.setDn(clientDn);
                customEntry.setCustomObjectClasses(CLIENT_OBJECT_CLASSES);

        Date now = new GregorianCalendar(TimeZone.getTimeZone("UTC")).getTime();
        String nowDateString = ldapEntryManager.encodeTime(now);

        CustomAttribute customAttributeLastAccessTime = new CustomAttribute("oxLastAccessTime", nowDateString);
        customEntry.getCustomAttributes().add(customAttributeLastAccessTime);

        if (isUpdateLogonTime) {
            CustomAttribute customAttributeLastLogonTime = new CustomAttribute("oxLastLogonTime", nowDateString);
            customEntry.getCustomAttributes().add(customAttributeLastLogonTime);
        }

        try {
            ldapEntryManager.merge(customEntry);
        } catch (EntryPersistenceException epe) {
            log.error("Failed to update oxLastAccessTime and oxLastLogonTime of client '{}'", clientDn);
        }

        removeFromCache(client);
    }

メンバ詳解

appConfiguration

AppConfiguration org.xdi.oxauth.service.ClientService.appConfiguration

private

CACHE_CLIENT_FILTER_NAME

final String org.xdi.oxauth.service.ClientService.CACHE_CLIENT_FILTER_NAME = "ClientFilterCache"

staticprivate

CACHE_CLIENT_NAME

final String org.xdi.oxauth.service.ClientService.CACHE_CLIENT_NAME = "ClientCache"

staticprivate

cacheService

CacheService org.xdi.oxauth.service.ClientService.cacheService

private

CLIENT_OBJECT_CLASSES

final String [] org.xdi.oxauth.service.ClientService.CLIENT_OBJECT_CLASSES = new String[] { "oxAuthClient" }

static

clientFilterService

ClientFilterService org.xdi.oxauth.service.ClientService.clientFilterService

private

encryptionService

EncryptionService org.xdi.oxauth.service.ClientService.encryptionService

private

ldapEntryManager

PersistenceEntryManager org.xdi.oxauth.service.ClientService.ldapEntryManager

private

log

Logger org.xdi.oxauth.service.ClientService.log

private

scopeService

ScopeService org.xdi.oxauth.service.ClientService.scopeService

private

staticConfiguration

StaticConfiguration org.xdi.oxauth.service.ClientService.staticConfiguration

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/main/java/org/xdi/oxauth/service/ClientService.java