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

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

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

公開メンバ関数
String	add () throws Exception
String	update () throws Exception
String	cancel ()
String	save () throws Exception
String	delete () throws Exception
void	addClaim (GluuAttribute claim)
void	removeClaim (String inum) throws Exception
String	getSearchAvailableClaimPattern ()
void	setSearchAvailableClaimPattern (String searchAvailableClaimPattern)
List< GluuAttribute >	getAvailableClaims ()
void	searchAvailableClaims ()
void	removeDuplicates ()
void	selectAddedClaims ()
void	acceptSelectClaims ()
void	cancelSelectClaims ()
String	getInum ()
void	setInum (String inum)
OxAuthScope	getScope ()
void	setScope (OxAuthScope scope)
List< DisplayNameEntry >	getClaims ()
void	setClaims (List< DisplayNameEntry > claims)
void	acceptSelectDynamicScripts ()
void	cancelSelectDynamicScripts ()
void	addDynamicScript (CustomScript addDynamicScript)
void	removeDynamicScript (CustomScript removeDynamicScript)
void	searchAvailableDynamicScripts ()
List< SelectableEntity< CustomScript > >	getAvailableDynamicScripts ()
List< CustomScript >	getDynamicScripts ()
boolean	isUpdate ()

非公開メンバ関数
void	updateClaims ()
List< DisplayNameEntry >	getClaimDisplayNameEntiries () throws Exception
List< CustomScript >	getInitialDynamicScripts ()
void	updateDynamicScripts ()
void	selectAddedDynamicScripts ()
Set< String >	getAddedDynamicScriptInums ()

非公開変数類
Logger	log
FacesMessages	facesMessages
ConversationService	conversationService
String	inum
boolean	update
OxAuthScope	scope
List< DisplayNameEntry >	claims
String	searchAvailableClaimPattern
String	oldSearchAvailableClaimPattern
List< GluuAttribute >	availableClaims
ScopeService	scopeService
LookupService	lookupService
AttributeService	attributeService
CustomScriptService	customScriptService
Identity	identity
OxTrustAuditService	oxTrustAuditService
List< CustomScript >	dynamicScripts
List< SelectableEntity< CustomScript > >	availableDynamicScripts

静的非公開変数類
static final long	serialVersionUID = 8198574569820157032L
static final String []	CUSTOM_SCRIPT_RETURN_ATTRIBUTES

詳解

Action class for viewing and updating scopes.

著者

Reda Zerrad Date: 06.18.2012

関数詳解

acceptSelectClaims()

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

inline

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

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

                for (DisplayNameEntry claim : claims) {
                        addedClaimsInums.add(claim.getInum());
                }

                for (GluuAttribute attribute : this.availableClaims) {
                        if (attribute.isSelected() && !addedClaimsInums.contains(attribute.getInum())) {
                                addClaim(attribute);
                        }
                }

        }

acceptSelectDynamicScripts()

void org.gluu.oxtrust.action.UpdateScopeAction.acceptSelectDynamicScripts ( )

inline

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

                Set<String> addedDynamicScriptInums = getAddedDynamicScriptInums();

                for (SelectableEntity<CustomScript> availableDynamicScript : this.availableDynamicScripts) {
                        CustomScript dynamicScript = availableDynamicScript.getEntity();
                        if (availableDynamicScript.isSelected() && !addedDynamicScriptInums.contains(dynamicScript.getInum())) {
                                addDynamicScript(dynamicScript);
                        }

                        if (!availableDynamicScript.isSelected() && addedDynamicScriptInums.contains(dynamicScript.getInum())) {
                                removeDynamicScript(dynamicScript);
                        }
                }
        }

add()

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

inline

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

                this.update = false;
                this.scope = new OxAuthScope();

                try {
                        if (this.scope.getOxAuthClaims() != null && this.scope.getOxAuthClaims().size() > 0) {
                                this.claims = getClaimDisplayNameEntiries();
                        } else {
                                this.claims = new ArrayList<DisplayNameEntry>();
                        }

                } catch (BasePersistenceException ex) {
                        log.error("Failed to load scopes", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new scope");

                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                this.dynamicScripts = getInitialDynamicScripts();

                return OxTrustConstants.RESULT_SUCCESS;
        }

addClaim()

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

inline

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

addDynamicScript()

void org.gluu.oxtrust.action.UpdateScopeAction.addDynamicScript ( CustomScript  addDynamicScript )

inline

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

                this.dynamicScripts.add(addDynamicScript);
        }

cancel()

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

inline

                               {
                if (update) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "Scope '#{updateScopeAction.scope.displayName}' not updated");
                } else {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "New scope not added");
                }

                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

cancelSelectClaims()

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

inline

                                         {
        }

cancelSelectDynamicScripts()

void org.gluu.oxtrust.action.UpdateScopeAction.cancelSelectDynamicScripts ( )

inline

                                                 {
        }

delete()

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

inline

                                                {
                if (update) {
                        // Remove scope
                        try {
                                scopeService.removeScope(this.scope);
                                oxTrustAuditService.audit("OPENID SCOPE " +this.scope.getInum()+ " **" + this.scope.getDisplayName() + "** REMOVED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                facesMessages.add(FacesMessage.SEVERITY_INFO,
                                                "Scope '#{updateScopeAction.scope.displayName}' removed successfully");

                                conversationService.endConversation();

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

                        }
                }

                return OxTrustConstants.RESULT_FAILURE;
        }

getAddedDynamicScriptInums()

Set<String> org.gluu.oxtrust.action.UpdateScopeAction.getAddedDynamicScriptInums ( )

inlineprivate

                                                         {
                Set<String> addedDynamicScriptInums = new HashSet<String>();

                for (CustomScript dynamicScript : this.dynamicScripts) {
                        addedDynamicScriptInums.add(dynamicScript.getInum());
                }

                return addedDynamicScriptInums;
        }

getAvailableClaims()

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

inline

                                                        {
                return this.availableClaims;
        }

getAvailableDynamicScripts()

List<SelectableEntity<CustomScript> > org.gluu.oxtrust.action.UpdateScopeAction.getAvailableDynamicScripts ( )

inline

                                                                                 {
                return this.availableDynamicScripts;
        }

getClaimDisplayNameEntiries()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateScopeAction.getClaimDisplayNameEntiries ( ) throws Exception

inlineprivate

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

                return result;
        }

getClaims()

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

inline

                                                  {
                return this.claims;
        }

getDynamicScripts()

List<CustomScript> org.gluu.oxtrust.action.UpdateScopeAction.getDynamicScripts ( )

inline

                                                      {
                return dynamicScripts;
        }

getInitialDynamicScripts()

List<CustomScript> org.gluu.oxtrust.action.UpdateScopeAction.getInitialDynamicScripts ( )

inlineprivate

                                                              {
                List<CustomScript> result = new ArrayList<CustomScript>();
                if ((this.scope.getDynamicScopeScripts() == null) || (this.scope.getDynamicScopeScripts().size() == 0)) {
                        return result;
                }

                List<DisplayNameEntry> displayNameEntries = lookupService.getDisplayNameEntries(customScriptService.baseDn(),
                                this.scope.getDynamicScopeScripts());
                if (displayNameEntries != null) {
                        for (DisplayNameEntry displayNameEntry : displayNameEntries) {
                                result.add(new CustomScript(displayNameEntry.getDn(), displayNameEntry.getInum(),
                                                displayNameEntry.getDisplayName()));
                        }
                }

                return result;
        }

getInum()

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

inline

                                {
                return inum;
        }

getScope()

OxAuthScope org.gluu.oxtrust.action.UpdateScopeAction.getScope ( )

inline

                                      {
                return this.scope;
        }

getSearchAvailableClaimPattern()

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

inline

                                                       {
                return this.searchAvailableClaimPattern;
        }

isUpdate()

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

inline

                                  {
                return update;
        }

removeClaim()

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

inline

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

                String removeClaimInum = attributeService.getDnForAttribute(inum);

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

removeDuplicates()

void org.gluu.oxtrust.action.UpdateScopeAction.removeDuplicates ( )

inline

                                       {
                List<GluuAttribute> tempAvailableClaims = new ArrayList<GluuAttribute>();
                for (int i = 0; i < this.availableClaims.size(); i++) {
                        for (int j = i + 1; j < this.availableClaims.size();) {
                                if (this.availableClaims.get(i).getDisplayName()
                                                .equalsIgnoreCase(this.availableClaims.get(j).getDisplayName())) {
                                        this.availableClaims.remove(j);
                                } else {
                                        j++;
                                }
                        }
                }

                for (GluuAttribute availableClaim : this.availableClaims) {
                        if (availableClaim != null) {
                                tempAvailableClaims.add(availableClaim);
                        }
                }

                this.availableClaims = tempAvailableClaims;

        }

removeDynamicScript()

void org.gluu.oxtrust.action.UpdateScopeAction.removeDynamicScript ( CustomScript  removeDynamicScript )

inline

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

                for (Iterator<CustomScript> it = this.dynamicScripts.iterator(); it.hasNext();) {
                        CustomScript dynamicScript = (CustomScript) it.next();

                        if (StringHelper.equalsIgnoreCase(removeDynamicScript.getInum(), dynamicScript.getInum())) {
                                it.remove();
                                break;
                        }
                }
        }

save()

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

inline

                                              {
                this.scope.setDisplayName(this.scope.getDisplayName().trim());
                updateDynamicScripts();
                updateClaims();
                if (update) {
                        // Update scope
                        try {
                                scopeService.updateScope(this.scope);
                                oxTrustAuditService.audit("OPENID SCOPE " +this.scope.getInum()+" **"+ this.scope.getDisplayName() + "** UPDATED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to update scope {}", this.inum, ex);

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

                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "Scope '#{updateScopeAction.scope.displayName}' updated successfully");
                } else {
                        this.inum = scopeService.generateInumForNewScope();
                        String dn = scopeService.getDnForScope(this.inum);

                        // Save scope
                        this.scope.setDn(dn);
                        this.scope.setInum(this.inum);
                        try {
                                scopeService.addScope(this.scope);
                                oxTrustAuditService.audit("OPENID SCOPE " +this.scope.getInum()+ " **"+ this.scope.getDisplayName() + "** ADDED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                        } catch (Exception ex) {
                                log.error("Failed to add new scope {}", this.scope.getInum(), ex);

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

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

                        conversationService.endConversation();

                        this.update = true;
                }
                log.debug(" returning success updating or saving scope");
                return OxTrustConstants.RESULT_SUCCESS;
        }

searchAvailableClaims()

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

inline

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

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

searchAvailableDynamicScripts()

void org.gluu.oxtrust.action.UpdateScopeAction.searchAvailableDynamicScripts ( )

inline

                                                    {
                if (this.availableDynamicScripts != null) {
                        selectAddedDynamicScripts();
                        return;
                }

                try {
                        List<CustomScript> availableScripts = customScriptService
                                        .findCustomScripts(Arrays.asList(CustomScriptType.DYNAMIC_SCOPE), CUSTOM_SCRIPT_RETURN_ATTRIBUTES);

                        List<SelectableEntity<CustomScript>> tmpAvailableDynamicScripts = new ArrayList<SelectableEntity<CustomScript>>();
                        for (CustomScript dynamicScript : availableScripts) {
                                if (dynamicScript.isEnabled()) {
                                        tmpAvailableDynamicScripts.add(new SelectableEntity<CustomScript>(dynamicScript));
                                }
                        }

                        this.availableDynamicScripts = tmpAvailableDynamicScripts;
                        selectAddedDynamicScripts();
                } catch (BasePersistenceException ex) {
                        log.error("Failed to find available authorization policies", ex);
                }

        }

selectAddedClaims()

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

inline

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

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

                for (DisplayNameEntry claim : claims) {
                        addedClaimInums.add(claim.getInum());
                }

                for (GluuAttribute attribute : this.availableClaims) {
                        if (attribute.isSelected() && !addedClaimInums.contains(attribute.getInum())) {
                                addClaim(attribute);
                        }
                }

        }

selectAddedDynamicScripts()

void org.gluu.oxtrust.action.UpdateScopeAction.selectAddedDynamicScripts ( )

inlineprivate

                                                 {
                Set<String> addedDynamicScriptInums = getAddedDynamicScriptInums();

                for (SelectableEntity<CustomScript> availableDynamicScript : this.availableDynamicScripts) {
                        availableDynamicScript
                                        .setSelected(addedDynamicScriptInums.contains(availableDynamicScript.getEntity().getInum()));
                }
        }

setClaims()

void org.gluu.oxtrust.action.UpdateScopeAction.setClaims ( List< DisplayNameEntry >  claims )

inline

                                                             {
                this.claims = claims;
        }

setInum()

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

inline

                                         {
                this.inum = inum;
        }

setScope()

void org.gluu.oxtrust.action.UpdateScopeAction.setScope ( OxAuthScope  scope )

inline

                                                {
                this.scope = scope;
        }

setSearchAvailableClaimPattern()

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

inline

                                                                                       {
                this.searchAvailableClaimPattern = searchAvailableClaimPattern;
        }

update()

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

inline

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

                this.update = true;
                log.debug("this.update : " + this.update);
                try {

                        log.debug("inum : " + this.inum);
                        this.scope = scopeService.getScopeByInum(this.inum);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to find scope {}", inum, ex);

                }

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

                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                try {
                        if (this.scope.getOxAuthClaims() != null && this.scope.getOxAuthClaims().size() > 0) {
                                this.claims = getClaimDisplayNameEntiries();
                        } else {
                                this.claims = new ArrayList<DisplayNameEntry>();
                        }
                        this.dynamicScripts = getInitialDynamicScripts();

                } catch (BasePersistenceException ex) {
                        log.error("Failed to load claims", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to load scope");

                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                log.debug("returning Success");
                return OxTrustConstants.RESULT_SUCCESS;
        }

updateClaims()

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

inlineprivate

                                    {
                if ((org.xdi.oxauth.model.common.ScopeType.DYNAMIC == this.scope.getScopeType()) || (this.claims == null)
                                || (this.claims.size() == 0)) {
                        this.scope.setOxAuthClaims(null);
                        return;
                }

                List<String> resultClaims = new ArrayList<String>();
                this.scope.setOxAuthClaims(resultClaims);

                for (DisplayNameEntry claim : this.claims) {
                        resultClaims.add(claim.getDn());
                }

                this.scope.setOxAuthClaims(resultClaims);
        }

updateDynamicScripts()

void org.gluu.oxtrust.action.UpdateScopeAction.updateDynamicScripts ( )

inlineprivate

                                            {
                if ((this.dynamicScripts == null) || (this.dynamicScripts.size() == 0)) {
                        this.scope.setDynamicScopeScripts(null);
                        return;
                }

                List<String> resultDynamicScripts = new ArrayList<String>();
                for (CustomScript dynamicScript : this.dynamicScripts) {
                        resultDynamicScripts.add(dynamicScript.getDn());
                }

                this.scope.setDynamicScopeScripts(resultDynamicScripts);
        }

メンバ詳解

attributeService

AttributeService org.gluu.oxtrust.action.UpdateScopeAction.attributeService

private

availableClaims

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

private

availableDynamicScripts

List<SelectableEntity<CustomScript> > org.gluu.oxtrust.action.UpdateScopeAction.availableDynamicScripts

private

claims

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

private

conversationService

ConversationService org.gluu.oxtrust.action.UpdateScopeAction.conversationService

private

CUSTOM_SCRIPT_RETURN_ATTRIBUTES

final String [] org.gluu.oxtrust.action.UpdateScopeAction.CUSTOM_SCRIPT_RETURN_ATTRIBUTES

staticprivate

初期値:

= { "inum", "displayName", "description",
                        "gluuStatus" }

customScriptService

CustomScriptService org.gluu.oxtrust.action.UpdateScopeAction.customScriptService

private

dynamicScripts

List<CustomScript> org.gluu.oxtrust.action.UpdateScopeAction.dynamicScripts

private

facesMessages

FacesMessages org.gluu.oxtrust.action.UpdateScopeAction.facesMessages

private

identity

Identity org.gluu.oxtrust.action.UpdateScopeAction.identity

private

inum

String org.gluu.oxtrust.action.UpdateScopeAction.inum

private

log

Logger org.gluu.oxtrust.action.UpdateScopeAction.log

private

lookupService

LookupService org.gluu.oxtrust.action.UpdateScopeAction.lookupService

private

oldSearchAvailableClaimPattern

String org.gluu.oxtrust.action.UpdateScopeAction.oldSearchAvailableClaimPattern

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.UpdateScopeAction.oxTrustAuditService

private

scope

OxAuthScope org.gluu.oxtrust.action.UpdateScopeAction.scope

private

scopeService

ScopeService org.gluu.oxtrust.action.UpdateScopeAction.scopeService

private

searchAvailableClaimPattern

String org.gluu.oxtrust.action.UpdateScopeAction.searchAvailableClaimPattern

private

serialVersionUID

final long org.gluu.oxtrust.action.UpdateScopeAction.serialVersionUID = 8198574569820157032L

staticprivate

update

boolean org.gluu.oxtrust.action.UpdateScopeAction.update

private

---

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

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