org.gluu.oxtrust.action.UpdateClientAction クラス

org.gluu.oxtrust.action.UpdateClientAction の継承関係図

org.gluu.oxtrust.action.UpdateClientAction 連携図

公開メンバ関数
String	getAvailableAuthorizedOrigin ()
void	setAvailableAuthorizedOrigin (String availableAuthorizedOrigin)
String	getAvailableClaimRedirectUri ()
void	setAvailableClaimRedirectUri (String availableClaimRedirectUri)
String	add () throws Exception
String	update () throws Exception
String	cancel ()
String	save () throws Exception
String	delete () throws Exception
void	removeLoginURI (String uri)
void	removeLogoutURI (String uri)
void	removeClientLogoutURI (String uri)
void	removeClaimRedirectURI (String uri)
void	removeContact (String contact)
void	removeDefaultAcrValue (String defaultAcrValue)
void	removeRequestUri (String requestUri)
void	removeAuthorizedOrigin (String authorizedOrigin)
void	removeScope (String inum) throws Exception
void	removeClaim (String inum) throws Exception
void	acceptSelectLoginUri ()
void	acceptSelectClaims ()
void	acceptSelectLogoutUri ()
void	acceptSelectClientLogoutUri ()
void	acceptSelectClaimRedirectUri ()
void	acceptSelectContact ()
void	acceptSelectDefaultAcrValue ()
void	acceptSelectRequestUri ()
void	acceptSelectAuthorizedOrigin ()
void	acceptSelectScopes ()
void	cancelSelectScopes ()
void	cancelSelectClaims ()
void	cancelSelectGroups ()
void	cancelSelectLoginUri ()
void	cancelSelectLogoutUri ()
void	cancelClientLogoutUri ()
void	cancelClaimRedirectUri ()
void	cancelSelectContact ()
void	cancelSelectDefaultAcrValue ()
void	cancelSelectRequestUri ()
void	cancelSelectAuthorizedOrigin ()
void	selectAddedScopes ()
void	selectAddedClaims ()
void	searchAvailableScopes ()
void	searchAvailableClaims ()
void	acceptSelectResponseTypes ()
void	acceptSelectGrantTypes ()
void	cancelSelectResponseTypes ()
void	cancelSelectGrantTypes ()
void	addResponseType (String value)
void	addGrantType (String value)
void	removeResponseType (String value)
void	removeGrantType (String value)
void	searchAvailableResponseTypes ()
void	searchAvailableGrantTypes ()
List< String >	getClaimRedirectURIList ()
void	setClaimRedirectURIList (List< String > claimRedirectURIList)
String	getInum ()
void	setInum (String inum)
OxAuthClient	getClient ()
boolean	isUpdate ()
String	getAvailableLoginUri ()
void	setAvailableLoginUri (String availableLoginUri)
String	getAvailableLogoutUri ()
void	setAvailableLogoutUri (String availableLogoutUri)
String	getAvailableContact ()
void	setAvailableContact (String availableContact)
String	getAvailableDefaultAcrValue ()
void	setAvailableDefaultAcrValue (String availableDefaultAcrValue)
String	getAvailableRequestUri ()
String	availableAuthorizedOrigin ()
void	setAvailableRequestUri (String availableRequestUri)
List< OxAuthScope >	getAvailableScopes ()
List< GluuAttribute >	getAvailableClaims ()
List< GluuGroup >	getAvailableGroups ()
List< SelectableEntity< ResponseType > >	getAvailableResponseTypes ()
List< SelectableEntity< GrantType > >	getAvailableGrantTypes ()
List< String >	getLoginUris ()
List< String >	getLogoutUris ()
List< DisplayNameEntry >	getScopes ()
List< DisplayNameEntry >	getClaims ()
List< ResponseType >	getResponseTypes ()
List< GrantType >	getGrantTypes ()
List< String >	getContacts ()
List< String >	getDefaultAcrValues ()
List< String >	getRequestUris ()
List< String >	getAuthorizedOrigins ()
String	getSearchAvailableScopePattern ()
void	setSearchAvailableScopePattern (String searchAvailableScopePattern)
String	getSearchAvailableClaimPattern ()
void	setSearchAvailableClaimPattern (String searchAvailableClaimPattern)
String	getAvailableClientlogoutUri ()
void	setAvailableClientlogoutUri (String availableClientlogoutUri)
List< String >	getClientlogoutUris ()
void	setClientlogoutUris (List< String > clientlogoutUris)
boolean	checkClientSecretRequired ()
void	generatePassword () throws EncryptionException
void	setSecret (String pwd) throws EncryptionException

非公開メンバ関数
List< String >	getNonEmptyStringList (List< String > currentList)
List< String >	getNonEmptyStringList (String[] currentList)
void	trimUriProperties ()
void	removeFromList (List< String > uriList, String uri)
void	addScope (OxAuthScope scope)
void	addClaim (GluuAttribute claim)
boolean	isAcceptable (String availableLoginUri)
boolean	hasSameHostname (String url1) throws MalformedURLException
boolean	sectorExist ()
void	updateLoginURIs ()
void	updateLogoutURIs ()
void	updateClientLogoutURIs ()
void	updateContacts ()
void	updateDefaultAcrValues ()
void	updateRequestUris ()
void	updateAuthorizedOrigins ()
void	updateClaimredirectUri ()
void	updateScopes ()
void	updateClaims ()
void	updateResponseTypes ()
void	updateGrantTypes ()
List< DisplayNameEntry >	getInitialScopeDisplayNameEntiries () throws Exception
List< DisplayNameEntry >	getInitialClaimDisplayNameEntries () throws Exception
List< ResponseType >	getInitialResponseTypes ()
List< GrantType >	getInitialGrantTypes ()
void	selectAddedResponseTypes ()
void	selectAddedGrantTypes ()
boolean	checkWhiteListRedirectUris (String redirectUri)
boolean	checkBlackListRedirectUris (String redirectUri)
void	validateContacts ()

非公開変数類
Logger	log
ClientService	clientService
ScopeService	scopeService
AttributeService	attributeService
LookupService	lookupService
FacesMessages	facesMessages
ConversationService	conversationService
EncryptionService	encryptionService
AppConfiguration	appConfiguration
OxTrustAuditService	oxTrustAuditService
Identity	identity
PasswordGenerator	passwordGenerator
String	inum
boolean	update
Date	previousClientExpirationDate
OxAuthClient	client
List< String >	loginUris
List< String >	logoutUris
List< String >	clientlogoutUris
List< String >	claimRedirectURIList
List< DisplayNameEntry >	scopes
List< DisplayNameEntry >	claims
List< ResponseType >	responseTypes
List< GrantType >	grantTypes
List< String >	contacts
List< String >	defaultAcrValues
List< String >	requestUris
List< String >	authorizedOrigins
String	searchAvailableScopePattern
String	oldSearchAvailableScopePattern
String	searchAvailableClaimPattern
String	oldSearchAvailableClaimPattern
String	availableLoginUri = "https://"
String	availableLogoutUri = "https://"
String	availableClientlogoutUri = "https://"
String	availableContact = ""
String	availableDefaultAcrValue = ""
String	availableRequestUri = "https://"
String	availableAuthorizedOrigin = "https://"
String	availableClaimRedirectUri = "https://"
List< OxAuthScope >	availableScopes
List< GluuAttribute >	availableClaims
List< GluuGroup >	availableGroups
List< SelectableEntity< ResponseType > >	availableResponseTypes
List< SelectableEntity< GrantType > >	availableGrantTypes

静的非公開変数類
static final long	serialVersionUID = -5756470620039988876L

詳解

Action class for viewing and updating clients.

著者

Reda Zerrad Date: 06.11.2012

Yuriy Movchan Date: 04/07/2014

Javier Rojas Blum

バージョン

June 21, 2018

関数詳解

acceptSelectAuthorizedOrigin()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectAuthorizedOrigin ( )

inline

                                                   {
                if (StringHelper.isEmpty(this.availableAuthorizedOrigin)) {
                        return;
                }

                if (!this.authorizedOrigins.contains(this.availableAuthorizedOrigin)) {
                        this.authorizedOrigins.add(this.availableAuthorizedOrigin);
                }

                this.availableAuthorizedOrigin = "https://";
        }

acceptSelectClaimRedirectUri()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectClaimRedirectUri ( )

inline

                                                   {
                if (StringHelper.isEmpty(this.availableClaimRedirectUri)) {
                        return;
                }

                if (!this.claimRedirectURIList.contains(this.availableClaimRedirectUri)) {
                        this.claimRedirectURIList.add(this.availableClaimRedirectUri);
                }

                this.availableClaimRedirectUri = "https://";
        }

acceptSelectClaims()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectClaims ( )

inline

                                         {
                if (this.availableClaims == null) {
                        return;
                }

                Set<String> addedClaimInums = new HashSet<String>();
                for (DisplayNameEntry claim : claims) {
                        addedClaimInums.add(claim.getInum());
                }

                for (GluuAttribute aClaim : this.availableClaims) {
                        if (aClaim.isSelected() && !addedClaimInums.contains(aClaim.getInum())) {
                                addClaim(aClaim);
                        }
                }
                this.searchAvailableClaimPattern = "";
        }

acceptSelectClientLogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectClientLogoutUri ( )

inline

                                                  {
                if (StringHelper.isEmpty(this.availableClientlogoutUri)) {
                        return;
                }

                if (!this.clientlogoutUris.contains(this.availableClientlogoutUri)) {
                        this.clientlogoutUris.add(this.availableClientlogoutUri);
                }

                this.availableClientlogoutUri = "https://";
        }

acceptSelectContact()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectContact ( )

inline

                                          {
                if (StringHelper.isEmpty(this.availableContact)) {
                        return;
                }

                if (!contacts.contains((availableContact))) {
                        contacts.add(availableContact);
                }

                this.availableContact = "";
        }

acceptSelectDefaultAcrValue()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectDefaultAcrValue ( )

inline

                                                  {
                if (StringHelper.isEmpty(this.availableDefaultAcrValue)) {
                        return;
                }

                if (!defaultAcrValues.contains((availableDefaultAcrValue))) {
                        defaultAcrValues.add(availableDefaultAcrValue);
                }

                this.availableDefaultAcrValue = "";
        }

acceptSelectGrantTypes()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectGrantTypes ( )

inline

                                             {
                List<GrantType> addedGrantTypes = getGrantTypes();

                for (SelectableEntity<GrantType> availableGrantType : this.availableGrantTypes) {
                        GrantType grantType = availableGrantType.getEntity();
                        if (availableGrantType.isSelected() && !addedGrantTypes.contains(grantType)) {
                                addGrantType(grantType.toString());
                        }

                        if (!availableGrantType.isSelected() && addedGrantTypes.contains(grantType)) {
                                removeGrantType(grantType.toString());
                        }
                }
        }

acceptSelectLoginUri()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectLoginUri ( )

inline

                                           {
                if (StringHelper.isEmpty(this.availableLoginUri)) {
                        return;
                }

                if (!this.loginUris.contains(this.availableLoginUri) && checkWhiteListRedirectUris(availableLoginUri)
                                && checkBlackListRedirectUris(availableLoginUri)) {
                        if (isAcceptable(this.availableLoginUri)) {
                                this.loginUris.add(this.availableLoginUri);
                        } else {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "A sector identifier must be defined first.",
                                                "A sector identifier must be defined first.");
                        }

                } else {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "The URL is not valid or may be Blacklisted.",
                                        "The URL is not valid or may be Blacklisted.");
                }

                this.availableLoginUri = "https://";
        }

acceptSelectLogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectLogoutUri ( )

inline

                                            {
                if (StringHelper.isEmpty(this.availableLogoutUri)) {
                        return;
                }

                if (!this.logoutUris.contains(this.availableLogoutUri) && checkWhiteListRedirectUris(availableLogoutUri)
                                && checkBlackListRedirectUris(availableLogoutUri)) {
                        this.logoutUris.add(this.availableLogoutUri);
                } else {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "The URL is not valid or may be Blacklisted.");
                }

                this.availableLogoutUri = "https://";
        }

acceptSelectRequestUri()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectRequestUri ( )

inline

                                             {
                if (StringHelper.isEmpty(this.availableRequestUri)) {
                        return;
                }

                if (!this.requestUris.contains(this.availableRequestUri)) {
                        this.requestUris.add(this.availableRequestUri);
                }

                this.availableRequestUri = "https://";
        }

acceptSelectResponseTypes()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectResponseTypes ( )

inline

                                                {
                List<ResponseType> addedResponseTypes = getResponseTypes();

                for (SelectableEntity<ResponseType> availableResponseType : this.availableResponseTypes) {
                        ResponseType responseType = availableResponseType.getEntity();
                        if (availableResponseType.isSelected() && !addedResponseTypes.contains(responseType)) {
                                addResponseType(responseType.getValue());
                        }

                        if (!availableResponseType.isSelected() && addedResponseTypes.contains(responseType)) {
                                removeResponseType(responseType.getValue());
                        }
                }
        }

acceptSelectScopes()

void org.gluu.oxtrust.action.UpdateClientAction.acceptSelectScopes ( )

inline

                                         {
                if (this.availableScopes == null) {
                        return;
                }

                Set<String> addedScopeInums = new HashSet<String>();
                for (DisplayNameEntry scope : scopes) {
                        addedScopeInums.add(scope.getInum());
                }

                for (OxAuthScope aScope : this.availableScopes) {
                        if (aScope.isSelected() && !addedScopeInums.contains(aScope.getInum())) {
                                addScope(aScope);
                        }
                }
                this.searchAvailableScopePattern = "";
                this.availableScopes = new ArrayList<OxAuthScope>();
        }

add()

String org.gluu.oxtrust.action.UpdateClientAction.add ( ) throws Exception

inline

                                             {
                if (this.client != null) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                this.update = false;
                this.client = new OxAuthClient();

                try {
                        this.loginUris = getNonEmptyStringList(client.getOxAuthRedirectURIs());
                        this.logoutUris = getNonEmptyStringList(client.getOxAuthPostLogoutRedirectURIs());
                        this.clientlogoutUris = getNonEmptyStringList(client.getLogoutUri());
                        this.scopes = getInitialScopeDisplayNameEntiries();
                        this.claims = getInitialClaimDisplayNameEntries();
                        this.responseTypes = getInitialResponseTypes();
                        this.grantTypes = getInitialGrantTypes();
                        this.contacts = getNonEmptyStringList(client.getContacts());
                        this.defaultAcrValues = getNonEmptyStringList(client.getDefaultAcrValues());
                        this.requestUris = getNonEmptyStringList(client.getRequestUris());
                        this.authorizedOrigins = getNonEmptyStringList(client.getAuthorizedOrigins());
                        this.claimRedirectURIList = getNonEmptyStringList(client.getClaimRedirectURI());
                } catch (BasePersistenceException ex) {
                        log.error("Failed to prepare lists", ex);

                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new client");
                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                return OxTrustConstants.RESULT_SUCCESS;
        }

addClaim()

void org.gluu.oxtrust.action.UpdateClientAction.addClaim ( GluuAttribute  claim )

inlineprivate

                                                   {
                DisplayNameEntry oneClaim = new DisplayNameEntry(claim.getDn(), claim.getInum(), claim.getDisplayName());
                this.claims.add(oneClaim);
        }

addGrantType()

void org.gluu.oxtrust.action.UpdateClientAction.addGrantType ( String  value )

inline

                                               {
                if (StringHelper.isEmpty(value)) {
                        return;
                }

                GrantType addGrantType = GrantType.fromString(value);
                if (addGrantType != null) {
                        this.grantTypes.add(addGrantType);
                }
        }

addResponseType()

void org.gluu.oxtrust.action.UpdateClientAction.addResponseType ( String  value )

inline

                                                  {
                if (StringHelper.isEmpty(value)) {
                        return;
                }

                ResponseType addResponseType = ResponseType.getByValue(value);
                if (addResponseType != null) {
                        this.responseTypes.add(addResponseType);
                }
        }

addScope()

void org.gluu.oxtrust.action.UpdateClientAction.addScope ( OxAuthScope  scope )

inlineprivate

                                                 {
                DisplayNameEntry oneScope = new DisplayNameEntry(scope.getDn(), scope.getInum(), scope.getDisplayName());
                this.scopes.add(oneScope);
        }

availableAuthorizedOrigin()

String org.gluu.oxtrust.action.UpdateClientAction.availableAuthorizedOrigin ( )

inline

                                                  {
                return availableAuthorizedOrigin;
        }

cancel()

String org.gluu.oxtrust.action.UpdateClientAction.cancel ( )

inline

                               {
                if (update) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "Client '#{updateClientAction.client.displayName}' not updated");
                } else {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "New client not added");
                }

                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

cancelClaimRedirectUri()

void org.gluu.oxtrust.action.UpdateClientAction.cancelClaimRedirectUri ( )

inline

                                             {
                this.availableClaimRedirectUri = "http://";
        }

cancelClientLogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.cancelClientLogoutUri ( )

inline

                                            {
                this.availableClientlogoutUri = "http://";
        }

cancelSelectAuthorizedOrigin()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectAuthorizedOrigin ( )

inline

                                                   {
        }

cancelSelectClaims()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectClaims ( )

inline

                                         {
        }

cancelSelectContact()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectContact ( )

inline

                                          {
                this.availableContact = "";
        }

cancelSelectDefaultAcrValue()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectDefaultAcrValue ( )

inline

                                                  {
        }

cancelSelectGrantTypes()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectGrantTypes ( )

inline

                                             {
        }

cancelSelectGroups()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectGroups ( )

inline

                                         {
        }

cancelSelectLoginUri()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectLoginUri ( )

inline

                                           {
                this.availableLoginUri = "http://";
        }

cancelSelectLogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectLogoutUri ( )

inline

                                            {
                this.availableLogoutUri = "http://";
        }

cancelSelectRequestUri()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectRequestUri ( )

inline

                                             {
        }

cancelSelectResponseTypes()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectResponseTypes ( )

inline

                                                {
        }

cancelSelectScopes()

void org.gluu.oxtrust.action.UpdateClientAction.cancelSelectScopes ( )

inline

                                         {
                this.searchAvailableScopePattern = "";
                this.availableScopes = new ArrayList<OxAuthScope>();
        }

checkBlackListRedirectUris()

boolean org.gluu.oxtrust.action.UpdateClientAction.checkBlackListRedirectUris ( String  redirectUri )

inlineprivate

None of the Redirect Uris must match to return true.

                                                                       {
                try {
                        boolean valid = true;
                        List<String> blackList = appConfiguration.getClientBlackList();
                        URLPatternList urlPatternList = new URLPatternList(blackList);

                        // for (String redirectUri : redirectUris) {
                        valid &= !urlPatternList.isUrlListed(redirectUri);
                        // }

                        return valid;
                } catch (Exception e) {
                        return false;
                }

        }

checkClientSecretRequired()

boolean org.gluu.oxtrust.action.UpdateClientAction.checkClientSecretRequired ( )

inline

                                                   {
                for (ResponseType responseType : this.responseTypes) {
                        if (responseType.getValue().equalsIgnoreCase("token")
                                        || responseType.getValue().equalsIgnoreCase("id_token")) {
                                return false;
                        }
                }

                for (GrantType grantType : this.grantTypes) {
                        if (grantType.getValue().equalsIgnoreCase("implicit")) {
                                return false;
                        }

                }

                return true;
        }

checkWhiteListRedirectUris()

boolean org.gluu.oxtrust.action.UpdateClientAction.checkWhiteListRedirectUris ( String  redirectUri )

inlineprivate

All the Redirect Uris must match to return true.

                                                                       {
                try {
                        boolean valid = true;
                        List<String> whiteList = appConfiguration.getClientWhiteList();
                        URLPatternList urlPatternList = new URLPatternList(whiteList);

                        // for (String redirectUri : redirectUris) {
                        valid &= urlPatternList.isUrlListed(redirectUri);
                        // }

                        return valid;
                } catch (Exception e) {
                        return false;
                }
        }

delete()

String org.gluu.oxtrust.action.UpdateClientAction.delete ( ) throws Exception

inline

                                                {
                if (update) {
                        // Remove client
                        try {
                                clientService.removeClient(this.client);
                                oxTrustAuditService.audit(
                                                "OPENID CLIENT " + this.client.getInum() + " **" + this.client.getDisplayName() + "** DELETED ",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                facesMessages.add(FacesMessage.SEVERITY_INFO,
                                                "Client '#{updateClientAction.client.displayName}' removed successfully");
                                conversationService.endConversation();

                                return OxTrustConstants.RESULT_SUCCESS;
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to remove client {}", this.inum, ex);
                        }
                }

                facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                "Failed to remove client '#{updateClientAction.client.displayName}'");

                return OxTrustConstants.RESULT_FAILURE;
        }

generatePassword()

void org.gluu.oxtrust.action.UpdateClientAction.generatePassword ( ) throws EncryptionException

inline

                                                                  {
                String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                String pwd = RandomStringUtils.random(24, characters);
                this.client.setOxAuthClientSecret(pwd);
                this.client.setEncodedClientSecret(encryptionService.encrypt(pwd));
        }

getAuthorizedOrigins()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getAuthorizedOrigins ( )

inline

                                                   {
                return authorizedOrigins;
        }

getAvailableAuthorizedOrigin()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableAuthorizedOrigin ( )

inline

                                                     {
                return availableAuthorizedOrigin;
        }

getAvailableClaimRedirectUri()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableClaimRedirectUri ( )

inline

                                                     {
                return availableClaimRedirectUri;
        }

getAvailableClaims()

List<GluuAttribute> org.gluu.oxtrust.action.UpdateClientAction.getAvailableClaims ( )

inline

                                                        {
                return this.availableClaims;
        }

getAvailableClientlogoutUri()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableClientlogoutUri ( )

inline

戻り値

the availableClientlogoutUri

                                                    {
                return availableClientlogoutUri;
        }

getAvailableContact()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableContact ( )

inline

                                            {
                return availableContact;
        }

getAvailableDefaultAcrValue()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableDefaultAcrValue ( )

inline

                                                    {
                return availableDefaultAcrValue;
        }

getAvailableGrantTypes()

List<SelectableEntity<GrantType> > org.gluu.oxtrust.action.UpdateClientAction.getAvailableGrantTypes ( )

inline

                                                                          {
                return this.availableGrantTypes;
        }

getAvailableGroups()

List<GluuGroup> org.gluu.oxtrust.action.UpdateClientAction.getAvailableGroups ( )

inline

                                                    {
                return this.availableGroups;
        }

getAvailableLoginUri()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableLoginUri ( )

inline

                                             {
                return availableLoginUri;
        }

getAvailableLogoutUri()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableLogoutUri ( )

inline

                                              {
                return availableLogoutUri;
        }

getAvailableRequestUri()

String org.gluu.oxtrust.action.UpdateClientAction.getAvailableRequestUri ( )

inline

                                               {
                return availableRequestUri;
        }

getAvailableResponseTypes()

List<SelectableEntity<ResponseType> > org.gluu.oxtrust.action.UpdateClientAction.getAvailableResponseTypes ( )

inline

                                                                                {
                return this.availableResponseTypes;
        }

getAvailableScopes()

List<OxAuthScope> org.gluu.oxtrust.action.UpdateClientAction.getAvailableScopes ( )

inline

                                                      {
                return this.availableScopes;
        }

getClaimRedirectURIList()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getClaimRedirectURIList ( )

inline

                                                      {
                return claimRedirectURIList;
        }

getClaims()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.getClaims ( )

inline

                                                  {
                return this.claims;
        }

getClient()

OxAuthClient org.gluu.oxtrust.action.UpdateClientAction.getClient ( )

inline

                                        {
                return client;
        }

getClientlogoutUris()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getClientlogoutUris ( )

inline

戻り値

the clientlogoutUris

                                                  {
                return clientlogoutUris;
        }

getContacts()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getContacts ( )

inline

                                          {
                return contacts;
        }

getDefaultAcrValues()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getDefaultAcrValues ( )

inline

                                                  {
                return defaultAcrValues;
        }

getGrantTypes()

List<GrantType> org.gluu.oxtrust.action.UpdateClientAction.getGrantTypes ( )

inline

                                               {
                return grantTypes;
        }

getInitialClaimDisplayNameEntries()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.getInitialClaimDisplayNameEntries ( ) throws Exception

inlineprivate

                                                                                            {
                List<DisplayNameEntry> result = new ArrayList<DisplayNameEntry>();
                if ((client.getOxAuthClaims() == null) || (client.getOxAuthClaims().size() == 0)) {
                        return result;
                }

                List<DisplayNameEntry> tmp = lookupService.getDisplayNameEntries(attributeService.getDnForAttribute(null),
                                this.client.getOxAuthClaims());
                if (tmp != null) {
                        result.addAll(tmp);
                }

                return result;
        }

getInitialGrantTypes()

List<GrantType> org.gluu.oxtrust.action.UpdateClientAction.getInitialGrantTypes ( )

inlineprivate

                                                       {
                List<GrantType> result = new ArrayList<GrantType>();

                GrantType[] currentGrantTypes = this.client.getGrantTypes();
                if (currentGrantTypes == null || currentGrantTypes.length == 0) {
                        return result;
                }

                result.addAll(Arrays.asList(currentGrantTypes));

                return result;
        }

getInitialResponseTypes()

List<ResponseType> org.gluu.oxtrust.action.UpdateClientAction.getInitialResponseTypes ( )

inlineprivate

                                                             {
                List<ResponseType> result = new ArrayList<ResponseType>();

                ResponseType[] currentResponseTypes = this.client.getResponseTypes();
                if ((currentResponseTypes == null) || (currentResponseTypes.length == 0)) {
                        return result;
                }

                result.addAll(Arrays.asList(currentResponseTypes));

                return result;
        }

getInitialScopeDisplayNameEntiries()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.getInitialScopeDisplayNameEntiries ( ) throws Exception

inlineprivate

                                                                                             {
                List<DisplayNameEntry> result = new ArrayList<DisplayNameEntry>();
                if ((client.getOxAuthScopes() == null) || (client.getOxAuthScopes().size() == 0)) {
                        return result;
                }

                List<DisplayNameEntry> tmp = lookupService.getDisplayNameEntries(scopeService.getDnForScope(null),
                                this.client.getOxAuthScopes());
                if (tmp != null) {
                        result.addAll(tmp);
                }

                return result;
        }

getInum()

String org.gluu.oxtrust.action.UpdateClientAction.getInum ( )

inline

                                {
                return inum;
        }

getLoginUris()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getLoginUris ( )

inline

                                           {
                return loginUris;
        }

getLogoutUris()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getLogoutUris ( )

inline

                                            {
                return logoutUris;
        }

getNonEmptyStringList() [1/2]

List<String> org.gluu.oxtrust.action.UpdateClientAction.getNonEmptyStringList ( List< String >  currentList )

inlineprivate

                                                                             {
                if (currentList != null && currentList.size() > 0) {
                        return new ArrayList<String>(currentList);
                } else {
                        return new ArrayList<String>();
                }
        }

getNonEmptyStringList() [2/2]

List<String> org.gluu.oxtrust.action.UpdateClientAction.getNonEmptyStringList ( String []  currentList )

inlineprivate

                                                                         {
                if (currentList != null && currentList.length > 0) {
                        return new ArrayList<String>(Arrays.asList(currentList));
                } else {
                        return new ArrayList<String>();
                }
        }

getRequestUris()

List<String> org.gluu.oxtrust.action.UpdateClientAction.getRequestUris ( )

inline

                                             {
                return requestUris;
        }

getResponseTypes()

List<ResponseType> org.gluu.oxtrust.action.UpdateClientAction.getResponseTypes ( )

inline

                                                     {
                return responseTypes;
        }

getScopes()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.getScopes ( )

inline

                                                  {
                return this.scopes;
        }

getSearchAvailableClaimPattern()

String org.gluu.oxtrust.action.UpdateClientAction.getSearchAvailableClaimPattern ( )

inline

                                                       {
                return searchAvailableClaimPattern;
        }

getSearchAvailableScopePattern()

String org.gluu.oxtrust.action.UpdateClientAction.getSearchAvailableScopePattern ( )

inline

                                                       {
                return this.searchAvailableScopePattern;
        }

hasSameHostname()

boolean org.gluu.oxtrust.action.UpdateClientAction.hasSameHostname ( String  url1 ) throws MalformedURLException

inlineprivate

                                                                                  {
                boolean result = true;
                URL uri1 = new URL(url1);
                for (String url : this.loginUris) {
                        URL uri = new URL(url);
                        if (!(uri1.getHost().equalsIgnoreCase(uri.getHost()))) {
                                result = false;
                                break;
                        }
                }
                return result;
        }

isAcceptable()

boolean org.gluu.oxtrust.action.UpdateClientAction.isAcceptable ( String  availableLoginUri )

inlineprivate

                                                               {
                boolean result = false;
                try {
                        if (this.loginUris.size() < 1) {
                                result = true;
                        } else if (this.loginUris.size() >= 1 && hasSameHostname(this.availableLoginUri)) {
                                result = true;
                        } else if (this.loginUris.size() >= 1 && !hasSameHostname(this.availableLoginUri) && sectorExist()) {
                                result = true;
                        }
                } catch (MalformedURLException e) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "One of the url is no malformed",
                                        "One of the url is no malformed");
                        log.error(e.getMessage());
                }
                return result;
        }

isUpdate()

boolean org.gluu.oxtrust.action.UpdateClientAction.isUpdate ( )

inline

                                  {
                return update;
        }

removeAuthorizedOrigin()

void org.gluu.oxtrust.action.UpdateClientAction.removeAuthorizedOrigin ( String  authorizedOrigin )

inline

                                                                    {
                if (StringUtils.isEmpty(authorizedOrigin)) {
                        return;
                }

                for (Iterator<String> iterator = authorizedOrigins.iterator(); iterator.hasNext();) {
                        String tmpAuthorizationOrigin = iterator.next();
                        if (authorizedOrigin.equals(tmpAuthorizationOrigin)) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeClaim()

void org.gluu.oxtrust.action.UpdateClientAction.removeClaim ( String  inum ) throws Exception

inline

                                                              {
                if (StringHelper.isEmpty(inum)) {
                        return;
                }

                String removeClaimDn = attributeService.getDnForAttribute(inum);

                for (Iterator<DisplayNameEntry> iterator = this.claims.iterator(); iterator.hasNext();) {
                        DisplayNameEntry oneClaim = iterator.next();
                        if (removeClaimDn.equals(oneClaim.getDn())) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeClaimRedirectURI()

void org.gluu.oxtrust.action.UpdateClientAction.removeClaimRedirectURI ( String  uri )

inline

                                                       {
                removeFromList(this.claimRedirectURIList, uri);
        }

removeClientLogoutURI()

void org.gluu.oxtrust.action.UpdateClientAction.removeClientLogoutURI ( String  uri )

inline

                                                      {
                removeFromList(this.clientlogoutUris, uri);
        }

removeContact()

void org.gluu.oxtrust.action.UpdateClientAction.removeContact ( String  contact )

inline

                                                  {
                if (StringUtils.isEmpty(contact)) {
                        return;
                }

                for (Iterator<String> iterator = contacts.iterator(); iterator.hasNext();) {
                        String tmpContact = iterator.next();
                        if (contact.equals(tmpContact)) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeDefaultAcrValue()

void org.gluu.oxtrust.action.UpdateClientAction.removeDefaultAcrValue ( String  defaultAcrValue )

inline

                                                                  {
                if (StringUtils.isEmpty(defaultAcrValue)) {
                        return;
                }

                for (Iterator<String> iterator = defaultAcrValues.iterator(); iterator.hasNext();) {
                        String tmpDefaultAcrValue = iterator.next();
                        if (defaultAcrValue.equals(tmpDefaultAcrValue)) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeFromList()

void org.gluu.oxtrust.action.UpdateClientAction.removeFromList ( List< String >  uriList, String  uri  )

inlineprivate

                                                                      {
                if (StringUtils.isEmpty(uri)) {
                        return;
                }

                for (Iterator<String> iterator = uriList.iterator(); iterator.hasNext();) {
                        String tmpUri = iterator.next();
                        if (uri.equals(tmpUri)) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeGrantType()

void org.gluu.oxtrust.action.UpdateClientAction.removeGrantType ( String  value )

inline

                                                  {
                if (StringHelper.isEmpty(value)) {
                        return;
                }

                GrantType removeGrantType = GrantType.fromString(value);
                if (removeGrantType != null) {
                        this.grantTypes.remove(removeGrantType);
                }
        }

removeLoginURI()

void org.gluu.oxtrust.action.UpdateClientAction.removeLoginURI ( String  uri )

inline

                                               {
                removeFromList(this.loginUris, uri);
        }

removeLogoutURI()

void org.gluu.oxtrust.action.UpdateClientAction.removeLogoutURI ( String  uri )

inline

                                                {
                removeFromList(this.logoutUris, uri);
        }

removeRequestUri()

void org.gluu.oxtrust.action.UpdateClientAction.removeRequestUri ( String  requestUri )

inline

                                                        {
                if (StringUtils.isEmpty(requestUri)) {
                        return;
                }

                for (Iterator<String> iterator = requestUris.iterator(); iterator.hasNext();) {
                        String tmpRequestUri = iterator.next();
                        if (requestUri.equals(tmpRequestUri)) {
                                iterator.remove();
                                break;
                        }
                }
        }

removeResponseType()

void org.gluu.oxtrust.action.UpdateClientAction.removeResponseType ( String  value )

inline

                                                     {
                if (StringHelper.isEmpty(value)) {
                        return;
                }

                ResponseType removeResponseType = ResponseType.getByValue(value);
                if (removeResponseType != null) {
                        this.responseTypes.remove(removeResponseType);
                }
        }

removeScope()

void org.gluu.oxtrust.action.UpdateClientAction.removeScope ( String  inum ) throws Exception

inline

                                                              {
                if (StringHelper.isEmpty(inum)) {
                        return;
                }

                String removeScopeInum = scopeService.getDnForScope(inum);

                for (Iterator<DisplayNameEntry> iterator = this.scopes.iterator(); iterator.hasNext();) {
                        DisplayNameEntry oneScope = iterator.next();
                        if (removeScopeInum.equals(oneScope.getDn())) {
                                iterator.remove();
                                break;
                        }
                }
        }

save()

String org.gluu.oxtrust.action.UpdateClientAction.save ( ) throws Exception

inline

                                              {
                LocalDate localDate = LocalDate.now();
                LocalDate tomorrow = localDate.plusDays(1);
                Date today = Date.from(tomorrow.atStartOfDay(ZoneId.systemDefault()).toInstant());
                if (this.client.getClientSecretExpiresAt() == null && !update) {
                        this.client.setClientSecretExpiresAt(today);
                }
                if (previousClientExpirationDate != null && this.client.getClientSecretExpiresAt().before(today)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "This client has expired. Update the expiration date in order to save changes");
                        return OxTrustConstants.RESULT_FAILURE;
                }

                updateLoginURIs();
                updateLogoutURIs();
                updateClientLogoutURIs();
                updateScopes();
                updateClaims();
                updateResponseTypes();
                updateGrantTypes();
                updateContacts();
                updateDefaultAcrValues();
                updateRequestUris();
                updateAuthorizedOrigins();
                updateClaimredirectUri();

                // Trim all URI properties
                trimUriProperties();

                this.client.setEncodedClientSecret(encryptionService.encrypt(this.client.getOxAuthClientSecret()));

                if (update) {
                        // Update client
                        try {
                                clientService.updateClient(this.client);
                                oxTrustAuditService.audit(
                                                "OPENID CLIENT " + this.client.getInum() + " **" + this.client.getDisplayName() + "** UPDATED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                        } catch (BasePersistenceException ex) {

                                log.error("Failed to update client {}", this.inum, ex);

                                facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                                "Failed to update client '#{updateClientAction.client.displayName}'");
                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "Client '#{updateClientAction.client.displayName}' updated successfully");
                } else {
                        this.inum = clientService.generateInumForNewClient();
                        String dn = clientService.getDnForClient(this.inum);

                        if (StringHelper.isEmpty(this.client.getEncodedClientSecret())) {
                                generatePassword();
                        }

                        // Save client
                        this.client.setDn(dn);
                        this.client.setInum(this.inum);
                        try {
                                clientService.addClient(this.client);
                                oxTrustAuditService.audit(
                                                "OPENID CLIENT " + this.client.getInum() + " **" + this.client.getDisplayName() + "** ADDED ",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to add new client {}", this.inum, ex);

                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new client");
                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "New client '#{updateClientAction.client.displayName}' added successfully");

                        conversationService.endConversation();

                        this.update = true;
                }

                return OxTrustConstants.RESULT_SUCCESS;
        }

searchAvailableClaims()

void org.gluu.oxtrust.action.UpdateClientAction.searchAvailableClaims ( )

inline

                                            {
                if (Util.equals(this.oldSearchAvailableClaimPattern, this.searchAvailableClaimPattern)) {
                        return;
                }

                try {
                        this.availableClaims = attributeService.searchAttributes(this.searchAvailableClaimPattern,
                                        OxTrustConstants.searchClientsSizeLimit);
                        this.oldSearchAvailableClaimPattern = this.searchAvailableClaimPattern;
                        selectAddedClaims();
                } catch (Exception ex) {
                        log.error("Failed to find attributes", ex);
                }
        }

searchAvailableGrantTypes()

void org.gluu.oxtrust.action.UpdateClientAction.searchAvailableGrantTypes ( )

inline

                                                {
                if (this.availableGrantTypes != null) {
                        selectAddedGrantTypes();
                        return;
                }

                List<SelectableEntity<GrantType>> tmpAvailableGrantTypes = new ArrayList<SelectableEntity<GrantType>>();

                tmpAvailableGrantTypes.add(new SelectableEntity<GrantType>(GrantType.AUTHORIZATION_CODE));
                tmpAvailableGrantTypes.add(new SelectableEntity<GrantType>(GrantType.IMPLICIT));
                tmpAvailableGrantTypes.add(new SelectableEntity<GrantType>(GrantType.REFRESH_TOKEN));
                tmpAvailableGrantTypes.add(new SelectableEntity<GrantType>(GrantType.CLIENT_CREDENTIALS));
                tmpAvailableGrantTypes.add(new SelectableEntity<GrantType>(GrantType.RESOURCE_OWNER_PASSWORD_CREDENTIALS));
                // tmpAvailableGrantTypes.add(new
                // SelectableEntity<GrantType>(GrantType.OXAUTH_UMA_TICKET));

                this.availableGrantTypes = tmpAvailableGrantTypes;
                selectAddedGrantTypes();
        }

searchAvailableResponseTypes()

void org.gluu.oxtrust.action.UpdateClientAction.searchAvailableResponseTypes ( )

inline

                                                   {
                if (this.availableResponseTypes != null) {
                        selectAddedResponseTypes();
                        return;
                }

                List<SelectableEntity<ResponseType>> tmpAvailableResponseTypes = new ArrayList<SelectableEntity<ResponseType>>();

                for (ResponseType responseType : ResponseType.values()) {
                        tmpAvailableResponseTypes.add(new SelectableEntity<ResponseType>(responseType));
                }

                this.availableResponseTypes = tmpAvailableResponseTypes;
                selectAddedResponseTypes();
        }

searchAvailableScopes()

void org.gluu.oxtrust.action.UpdateClientAction.searchAvailableScopes ( )

inline

                                            {
                if (Util.equals(this.oldSearchAvailableScopePattern, this.searchAvailableScopePattern)) {
                        return;
                }

                try {

                        this.availableScopes = scopeService.searchScopes(this.searchAvailableScopePattern,
                                        OxTrustConstants.searchClientsSizeLimit);
                        this.oldSearchAvailableScopePattern = this.searchAvailableScopePattern;
                        selectAddedScopes();
                } catch (Exception ex) {
                        log.error("Failed to find attributes", ex);
                }
        }

sectorExist()

boolean org.gluu.oxtrust.action.UpdateClientAction.sectorExist ( )

inlineprivate

                                      {
                boolean result = false;
                String sectorUri = this.client.getSectorIdentifierUri();
                try {
                        if (sectorUri != null && !sectorUri.isEmpty()) {
                                JSONArray json = new JSONArray(IOUtils.toString(new URL(sectorUri), Charset.forName("UTF-8")));
                                if (json != null) {
                                        result = true;
                                }
                        }
                } catch (MalformedURLException e) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "The url of the sector assigned to this client is malformed",
                                        "The url of the sector assigned to this client is malformed");
                        log.error(e.getMessage());
                } catch (IOException e) {
                        log.error(e.getMessage());
                } catch (JSONException e) {
                        log.error(e.getMessage());
                }
                return result;
        }

selectAddedClaims()

void org.gluu.oxtrust.action.UpdateClientAction.selectAddedClaims ( )

inline

                                        {
                if (this.availableClaims == null) {
                        return;
                }

                Set<String> addedClaimInums = new HashSet<String>();
                for (DisplayNameEntry claim : this.claims) {
                        addedClaimInums.add(claim.getInum());
                }

                for (GluuAttribute aClaim : this.availableClaims) {
                        aClaim.setSelected(addedClaimInums.contains(aClaim.getInum()));
                }
        }

selectAddedGrantTypes()

void org.gluu.oxtrust.action.UpdateClientAction.selectAddedGrantTypes ( )

inlineprivate

                                             {
                List<GrantType> addedGrantTypes = getGrantTypes();

                for (SelectableEntity<GrantType> availableGrantType : this.availableGrantTypes) {
                        availableGrantType.setSelected(addedGrantTypes.contains(availableGrantType.getEntity()));
                }
        }

selectAddedResponseTypes()

void org.gluu.oxtrust.action.UpdateClientAction.selectAddedResponseTypes ( )

inlineprivate

                                                {
                List<ResponseType> addedResponseTypes = getResponseTypes();

                for (SelectableEntity<ResponseType> availableResponseType : this.availableResponseTypes) {
                        availableResponseType.setSelected(addedResponseTypes.contains(availableResponseType.getEntity()));
                }
        }

selectAddedScopes()

void org.gluu.oxtrust.action.UpdateClientAction.selectAddedScopes ( )

inline

                                        {
                if (this.availableScopes == null) {
                        return;
                }

                Set<String> addedScopeInums = new HashSet<String>();
                for (DisplayNameEntry scope : this.scopes) {
                        addedScopeInums.add(scope.getInum());
                }

                for (OxAuthScope aScope : this.availableScopes) {
                        aScope.setSelected(addedScopeInums.contains(aScope.getInum()));
                }
        }

setAvailableAuthorizedOrigin()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableAuthorizedOrigin ( String  availableAuthorizedOrigin )

inline

                                                                                   {
                this.availableAuthorizedOrigin = availableAuthorizedOrigin;
        }

setAvailableClaimRedirectUri()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableClaimRedirectUri ( String  availableClaimRedirectUri )

inline

                                                                                   {
                this.availableClaimRedirectUri = availableClaimRedirectUri;
        }

setAvailableClientlogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableClientlogoutUri ( String  availableClientlogoutUri )

inline

引数

availableClientlogoutUri

the availableClientlogoutUri to set

                                                                                 {
                this.availableClientlogoutUri = availableClientlogoutUri;
        }

setAvailableContact()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableContact ( String  availableContact )

inline

                                                                 {
                this.availableContact = availableContact;
        }

setAvailableDefaultAcrValue()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableDefaultAcrValue ( String  availableDefaultAcrValue )

inline

                                                                                 {
                this.availableDefaultAcrValue = availableDefaultAcrValue;
        }

setAvailableLoginUri()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableLoginUri ( String  availableLoginUri )

inline

                                                                   {
                this.availableLoginUri = availableLoginUri;
        }

setAvailableLogoutUri()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableLogoutUri ( String  availableLogoutUri )

inline

                                                                     {
                this.availableLogoutUri = availableLogoutUri;
        }

setAvailableRequestUri()

void org.gluu.oxtrust.action.UpdateClientAction.setAvailableRequestUri ( String  availableRequestUri )

inline

                                                                       {
                this.availableRequestUri = availableRequestUri;
        }

setClaimRedirectURIList()

void org.gluu.oxtrust.action.UpdateClientAction.setClaimRedirectURIList ( List< String >  claimRedirectURIList )

inline

                                                                               {
                this.claimRedirectURIList = claimRedirectURIList;
        }

setClientlogoutUris()

void org.gluu.oxtrust.action.UpdateClientAction.setClientlogoutUris ( List< String >  clientlogoutUris )

inline

引数

clientlogoutUris

the clientlogoutUris to set

                                                                       {
                this.clientlogoutUris = clientlogoutUris;
        }

setInum()

void org.gluu.oxtrust.action.UpdateClientAction.setInum ( String  inum )

inline

                                         {
                this.inum = inum;
        }

setSearchAvailableClaimPattern()

void org.gluu.oxtrust.action.UpdateClientAction.setSearchAvailableClaimPattern ( String  searchAvailableClaimPattern )

inline

                                                                                       {
                this.searchAvailableClaimPattern = searchAvailableClaimPattern;
        }

setSearchAvailableScopePattern()

void org.gluu.oxtrust.action.UpdateClientAction.setSearchAvailableScopePattern ( String  searchAvailableScopePattern )

inline

                                                                                       {
                this.searchAvailableScopePattern = searchAvailableScopePattern;
        }

setSecret()

void org.gluu.oxtrust.action.UpdateClientAction.setSecret ( String  pwd ) throws EncryptionException

inline

                                                                     {
                this.client.setOxAuthClientSecret(pwd);
                this.client.setEncodedClientSecret(encryptionService.encrypt(pwd));
        }

trimUriProperties()

void org.gluu.oxtrust.action.UpdateClientAction.trimUriProperties ( )

inlineprivate

                                         {
                this.client.setClientUri(StringHelper.trimAll(this.client.getClientUri()));
                this.client.setJwksUri(StringHelper.trimAll(this.client.getJwksUri()));
                this.client.setLogoUri(StringHelper.trimAll(this.client.getLogoUri()));
                this.client.setPolicyUri(StringHelper.trimAll(this.client.getPolicyUri()));
                this.client.setSectorIdentifierUri(StringHelper.trimAll(this.client.getSectorIdentifierUri()));
                this.client.setTosUri(StringHelper.trimAll(this.client.getTosUri()));
                this.client.setInitiateLoginUri(StringHelper.trimAll(this.client.getInitiateLoginUri()));
        }

update()

String org.gluu.oxtrust.action.UpdateClientAction.update ( ) throws Exception

inline

                                                {
                if (this.client != null) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                this.update = true;
                log.debug("this.update : " + this.update);
                try {
                        log.debug("inum : " + inum);
                        this.client = clientService.getClientByInum(inum);
                        previousClientExpirationDate = this.client.getClientSecretExpiresAt();
                } catch (BasePersistenceException ex) {
                        log.error("Failed to find client {}", inum, ex);
                }

                if (this.client == null) {
                        log.error("Failed to load client {}", inum);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to find client");

                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                try {
                        this.loginUris = getNonEmptyStringList(client.getOxAuthRedirectURIs());
                        this.logoutUris = getNonEmptyStringList(client.getOxAuthPostLogoutRedirectURIs());
                        this.clientlogoutUris = getNonEmptyStringList(client.getLogoutUri());
                        this.scopes = getInitialScopeDisplayNameEntiries();
                        this.claims = getInitialClaimDisplayNameEntries();
                        this.responseTypes = getInitialResponseTypes();
                        this.grantTypes = getInitialGrantTypes();
                        this.contacts = getNonEmptyStringList(client.getContacts());
                        this.defaultAcrValues = getNonEmptyStringList(client.getDefaultAcrValues());
                        this.requestUris = getNonEmptyStringList(client.getRequestUris());
                        this.authorizedOrigins = getNonEmptyStringList(client.getAuthorizedOrigins());
                        this.claimRedirectURIList = getNonEmptyStringList(client.getClaimRedirectURI());
                } catch (BasePersistenceException ex) {
                        log.error("Failed to prepare lists", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to load client");

                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                return OxTrustConstants.RESULT_SUCCESS;
        }

updateAuthorizedOrigins()

void org.gluu.oxtrust.action.UpdateClientAction.updateAuthorizedOrigins ( )

inlineprivate

                                               {
                if (authorizedOrigins == null || authorizedOrigins.size() == 0) {
                        client.setAuthorizedOrigins(null);
                        return;
                }

                List<String> tmpAuthorizedOrigins = new ArrayList<String>();
                for (String authorizedOrigin : authorizedOrigins) {
                        tmpAuthorizedOrigins.add(StringHelper.trimAll(authorizedOrigin));
                }

                client.setAuthorizedOrigins(tmpAuthorizedOrigins.toArray(new String[tmpAuthorizedOrigins.size()]));
        }

updateClaimredirectUri()

void org.gluu.oxtrust.action.UpdateClientAction.updateClaimredirectUri ( )

inlineprivate

                                              {
                if (claimRedirectURIList == null || claimRedirectURIList.size() == 0) {
                        client.setClaimRedirectURI(null);
                        return;
                }

                List<String> tmpClaimRedirectURI = new ArrayList<String>();
                for (String claimRedirectURI : claimRedirectURIList) {
                        tmpClaimRedirectURI.add(StringHelper.trimAll(claimRedirectURI));
                }

                client.setClaimRedirectURI(tmpClaimRedirectURI.toArray(new String[tmpClaimRedirectURI.size()]));
        }

updateClaims()

void org.gluu.oxtrust.action.UpdateClientAction.updateClaims ( )

inlineprivate

                                    {
                if (this.claims == null || this.claims.size() == 0) {
                        this.client.setOxAuthClaims(null);
                        return;
                }

                List<String> tmpClaims = new ArrayList<String>();
                for (DisplayNameEntry claim : this.claims) {
                        tmpClaims.add(claim.getDn());
                }

                this.client.setOxAuthClaims(tmpClaims);
        }

updateClientLogoutURIs()

void org.gluu.oxtrust.action.UpdateClientAction.updateClientLogoutURIs ( )

inlineprivate

                                              {
                if (this.clientlogoutUris == null || this.clientlogoutUris.size() == 0) {
                        this.client.setLogoutUri(null);
                        return;
                }

                List<String> tmpUris = new ArrayList<String>();
                for (String uri : this.clientlogoutUris) {
                        tmpUris.add(StringHelper.trimAll(uri));
                }

                this.client.setLogoutUri(tmpUris);

        }

updateContacts()

void org.gluu.oxtrust.action.UpdateClientAction.updateContacts ( )

inlineprivate

                                      {
                validateContacts();
                if (contacts == null || contacts.size() == 0) {
                        client.setContacts(null);
                        return;
                }

                List<String> tmpContacts = new ArrayList<String>();
                for (String contact : contacts) {
                        tmpContacts.add(contact);
                }

                client.setContacts(tmpContacts);
        }

updateDefaultAcrValues()

void org.gluu.oxtrust.action.UpdateClientAction.updateDefaultAcrValues ( )

inlineprivate

                                              {
                if (defaultAcrValues == null || defaultAcrValues.size() == 0) {
                        client.setDefaultAcrValues(null);
                        return;
                }

                List<String> tmpDefaultAcrValues = new ArrayList<String>();
                for (String defaultAcrValue : defaultAcrValues) {
                        tmpDefaultAcrValues.add(defaultAcrValue);
                }

                client.setDefaultAcrValues(tmpDefaultAcrValues.toArray(new String[tmpDefaultAcrValues.size()]));
        }

updateGrantTypes()

void org.gluu.oxtrust.action.UpdateClientAction.updateGrantTypes ( )

inlineprivate

                                        {
                List<GrantType> currentGrantTypes = this.grantTypes;

                if (currentGrantTypes == null || currentGrantTypes.size() == 0) {
                        this.client.setGrantTypes(null);
                        return;
                }

                this.client.setGrantTypes(currentGrantTypes.toArray(new GrantType[currentGrantTypes.size()]));
        }

updateLoginURIs()

void org.gluu.oxtrust.action.UpdateClientAction.updateLoginURIs ( )

inlineprivate

                                       {
                if (this.loginUris == null || this.loginUris.size() == 0) {
                        this.client.setOxAuthRedirectURIs(null);
                        return;
                }

                List<String> tmpUris = new ArrayList<String>();
                for (String uri : this.loginUris) {
                        tmpUris.add(StringHelper.trimAll(uri));
                }

                this.client.setOxAuthRedirectURIs(tmpUris);
        }

updateLogoutURIs()

void org.gluu.oxtrust.action.UpdateClientAction.updateLogoutURIs ( )

inlineprivate

                                        {
                if (this.logoutUris == null || this.logoutUris.size() == 0) {
                        this.client.setOxAuthPostLogoutRedirectURIs(null);
                        return;
                }

                List<String> tmpUris = new ArrayList<String>();
                for (String uri : this.logoutUris) {
                        tmpUris.add(StringHelper.trimAll(uri));
                }

                this.client.setOxAuthPostLogoutRedirectURIs(tmpUris);

        }

updateRequestUris()

void org.gluu.oxtrust.action.UpdateClientAction.updateRequestUris ( )

inlineprivate

                                         {
                if (requestUris == null || requestUris.size() == 0) {
                        client.setRequestUris(null);
                        return;
                }

                List<String> tmpRequestUris = new ArrayList<String>();
                for (String requestUri : requestUris) {
                        tmpRequestUris.add(StringHelper.trimAll(requestUri));
                }

                client.setRequestUris(tmpRequestUris.toArray(new String[tmpRequestUris.size()]));
        }

updateResponseTypes()

void org.gluu.oxtrust.action.UpdateClientAction.updateResponseTypes ( )

inlineprivate

                                           {
                List<ResponseType> currentResponseTypes = this.responseTypes;

                if (currentResponseTypes == null || currentResponseTypes.size() == 0) {
                        this.client.setResponseTypes(null);
                        return;
                }

                this.client.setResponseTypes(currentResponseTypes.toArray(new ResponseType[currentResponseTypes.size()]));
        }

updateScopes()

void org.gluu.oxtrust.action.UpdateClientAction.updateScopes ( )

inlineprivate

                                    {
                if (this.scopes == null || this.scopes.size() == 0) {
                        this.client.setOxAuthScopes(null);
                        return;
                }

                List<String> tmpScopes = new ArrayList<String>();
                for (DisplayNameEntry scope : this.scopes) {
                        tmpScopes.add(scope.getDn());
                }

                this.client.setOxAuthScopes(tmpScopes);
        }

validateContacts()

void org.gluu.oxtrust.action.UpdateClientAction.validateContacts ( )

inlineprivate

                                        {
                String regex = "^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$";
                Pattern pattern = Pattern.compile(regex);
                List<String> tmpContactsList = new ArrayList<String>();
                boolean shouldShowWarning = false;
                for (String contact : contacts) {
                        if (pattern.matcher(contact).matches()) {
                                tmpContactsList.add(contact);
                        } else {
                                shouldShowWarning = true;
                        }
                }
                contacts.clear();
                contacts.addAll(tmpContactsList);
                if (shouldShowWarning) {
                        facesMessages.add(FacesMessage.SEVERITY_WARN, "Invalid contacts have been removed from contacts list");
                }
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.UpdateClientAction.appConfiguration

private

attributeService

AttributeService org.gluu.oxtrust.action.UpdateClientAction.attributeService

private

authorizedOrigins

List<String> org.gluu.oxtrust.action.UpdateClientAction.authorizedOrigins

private

availableAuthorizedOrigin

String org.gluu.oxtrust.action.UpdateClientAction.availableAuthorizedOrigin = "https://"

private

availableClaimRedirectUri

String org.gluu.oxtrust.action.UpdateClientAction.availableClaimRedirectUri = "https://"

private

availableClaims

List<GluuAttribute> org.gluu.oxtrust.action.UpdateClientAction.availableClaims

private

availableClientlogoutUri

String org.gluu.oxtrust.action.UpdateClientAction.availableClientlogoutUri = "https://"

private

availableContact

String org.gluu.oxtrust.action.UpdateClientAction.availableContact = ""

private

availableDefaultAcrValue

String org.gluu.oxtrust.action.UpdateClientAction.availableDefaultAcrValue = ""

private

availableGrantTypes

List<SelectableEntity<GrantType> > org.gluu.oxtrust.action.UpdateClientAction.availableGrantTypes

private

availableGroups

List<GluuGroup> org.gluu.oxtrust.action.UpdateClientAction.availableGroups

private

availableLoginUri

String org.gluu.oxtrust.action.UpdateClientAction.availableLoginUri = "https://"

private

availableLogoutUri

String org.gluu.oxtrust.action.UpdateClientAction.availableLogoutUri = "https://"

private

availableRequestUri

String org.gluu.oxtrust.action.UpdateClientAction.availableRequestUri = "https://"

private

availableResponseTypes

List<SelectableEntity<ResponseType> > org.gluu.oxtrust.action.UpdateClientAction.availableResponseTypes

private

availableScopes

List<OxAuthScope> org.gluu.oxtrust.action.UpdateClientAction.availableScopes

private

claimRedirectURIList

List<String> org.gluu.oxtrust.action.UpdateClientAction.claimRedirectURIList

private

claims

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.claims

private

client

OxAuthClient org.gluu.oxtrust.action.UpdateClientAction.client

private

clientlogoutUris

List<String> org.gluu.oxtrust.action.UpdateClientAction.clientlogoutUris

private

clientService

ClientService org.gluu.oxtrust.action.UpdateClientAction.clientService

private

contacts

List<String> org.gluu.oxtrust.action.UpdateClientAction.contacts

private

conversationService

ConversationService org.gluu.oxtrust.action.UpdateClientAction.conversationService

private

defaultAcrValues

List<String> org.gluu.oxtrust.action.UpdateClientAction.defaultAcrValues

private

encryptionService

EncryptionService org.gluu.oxtrust.action.UpdateClientAction.encryptionService

private

facesMessages

FacesMessages org.gluu.oxtrust.action.UpdateClientAction.facesMessages

private

grantTypes

List<GrantType> org.gluu.oxtrust.action.UpdateClientAction.grantTypes

private

identity

Identity org.gluu.oxtrust.action.UpdateClientAction.identity

private

inum

String org.gluu.oxtrust.action.UpdateClientAction.inum

private

log

Logger org.gluu.oxtrust.action.UpdateClientAction.log

private

loginUris

List<String> org.gluu.oxtrust.action.UpdateClientAction.loginUris

private

logoutUris

List<String> org.gluu.oxtrust.action.UpdateClientAction.logoutUris

private

lookupService

LookupService org.gluu.oxtrust.action.UpdateClientAction.lookupService

private

oldSearchAvailableClaimPattern

String org.gluu.oxtrust.action.UpdateClientAction.oldSearchAvailableClaimPattern

private

oldSearchAvailableScopePattern

String org.gluu.oxtrust.action.UpdateClientAction.oldSearchAvailableScopePattern

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.UpdateClientAction.oxTrustAuditService

private

passwordGenerator

PasswordGenerator org.gluu.oxtrust.action.UpdateClientAction.passwordGenerator

private

previousClientExpirationDate

Date org.gluu.oxtrust.action.UpdateClientAction.previousClientExpirationDate

private

requestUris

List<String> org.gluu.oxtrust.action.UpdateClientAction.requestUris

private

responseTypes

List<ResponseType> org.gluu.oxtrust.action.UpdateClientAction.responseTypes

private

scopes

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateClientAction.scopes

private

scopeService

ScopeService org.gluu.oxtrust.action.UpdateClientAction.scopeService

private

searchAvailableClaimPattern

String org.gluu.oxtrust.action.UpdateClientAction.searchAvailableClaimPattern

private

searchAvailableScopePattern

String org.gluu.oxtrust.action.UpdateClientAction.searchAvailableScopePattern

private

serialVersionUID

final long org.gluu.oxtrust.action.UpdateClientAction.serialVersionUID = -5756470620039988876L

staticprivate

update

boolean org.gluu.oxtrust.action.UpdateClientAction.update

private

---

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

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/action/UpdateClientAction.java