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

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

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

公開メンバ関数
String	add () throws Exception
String	update () throws Exception
String	cancel ()
String	save () throws Exception
String	delete () throws Exception
void	addMember (GluuCustomPerson person)
void	removeMember (String inum) throws Exception
String	getSearchAvailableMemberPattern ()
void	setSearchAvailableMemberPattern (String searchAvailableMemberPattern)
List< GluuCustomPerson >	getAvailableMembers ()
void	searchAvailableMembers ()
void	selectAddedMembers ()
void	acceptSelectMembers ()
void	cancelSelectMembers ()
String	getInum ()
void	setInum (String inum)
GluuGroup	getGroup ()
List< DisplayNameEntry >	getMembers ()
boolean	isUpdate ()

非公開メンバ関数
List< DisplayNameEntry >	getMemberDisplayNameEntiries () throws Exception
void	updateMembers ()
void	updatePersons (List< DisplayNameEntry > oldMembers, List< DisplayNameEntry > newMembers) throws Exception
GluuBoolean	isSLAManager (String[] organizationGroups, GluuCustomPerson person) throws Exception
String []	convertToDNsArray (List< DisplayNameEntry > members)

非公開変数類
Logger	log
OxTrustAuditService	oxTrustAuditService
String	inum
boolean	update
GluuGroup	group
List< DisplayNameEntry >	members
String	searchAvailableMemberPattern
String	oldSearchAvailableMemberPattern
List< GluuCustomPerson >	availableMembers
Identity	identity
OrganizationService	organizationService
IGroupService	groupService
LookupService	lookupService
FacesMessages	facesMessages
ConversationService	conversationService
IPersonService	personService
AppConfiguration	appConfiguration

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

詳解

Action class for view and update group form.

著者

Yuriy Movchan Date: 11.08.2010

関数詳解

acceptSelectMembers()

void org.gluu.oxtrust.action.UpdateGroupAction.acceptSelectMembers ( )

inline

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

                Set<String> addedMemberInums = new HashSet<String>();
                for (DisplayNameEntry member : members) {
                        addedMemberInums.add(member.getInum());
                }

                for (GluuCustomPerson person : this.availableMembers) {
                        if (person.isSelected() && !addedMemberInums.contains(person.getInum())) {
                                addMember(person);
                        }
                }
        }

add()

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

inline

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

                this.update = false;
                this.group = new GluuGroup();
                this.group.setOwner(identity.getUser().getDn());
                this.group.setOrganization(organizationService.getOrganization().getDn());

                try {
                        this.members = getMemberDisplayNameEntiries();
                } catch (BasePersistenceException ex) {
                        log.error("Failed to prepare lists", ex);

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

                        return OxTrustConstants.RESULT_FAILURE;
                }

                return OxTrustConstants.RESULT_SUCCESS;
        }

addMember()

void org.gluu.oxtrust.action.UpdateGroupAction.addMember ( GluuCustomPerson  person )

inline

                                                       {
                DisplayNameEntry member = new DisplayNameEntry(person.getDn(), person.getInum(), person.getDisplayName());
                this.members.add(member);
        }

cancel()

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

inline

                               {
                if (update) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "Group '#{updateGroupAction.group.displayName}' not updated");
                } else {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "New group not added");
                }

                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

cancelSelectMembers()

void org.gluu.oxtrust.action.UpdateGroupAction.cancelSelectMembers ( )

inline

                                          {
        }

convertToDNsArray()

String [] org.gluu.oxtrust.action.UpdateGroupAction.convertToDNsArray ( List< DisplayNameEntry >  members )

inlineprivate

                                                                           {
                String[] memberDns = new String[members.size()];
                int i = 0;
                for (DisplayNameEntry member : members) {
                        memberDns[i++] = member.getDn();
                }

                return memberDns;
        }

delete()

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

inline

                                                {
                if (update) {
                        // Remove group
                        try {
                                groupService.removeGroup(this.group);
                                oxTrustAuditService.audit("GROUP " + this.group.getInum() + " **"+this.group.getDisplayName()+ "** REMOVED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                facesMessages.add(FacesMessage.SEVERITY_INFO, "Group '#{updateGroupAction.group.displayName}' removed successfully");
                                conversationService.endConversation();

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

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

                return OxTrustConstants.RESULT_FAILURE;
        }

getAvailableMembers()

List<GluuCustomPerson> org.gluu.oxtrust.action.UpdateGroupAction.getAvailableMembers ( )

inline

                                                            {
                return this.availableMembers;
        }

getGroup()

GluuGroup org.gluu.oxtrust.action.UpdateGroupAction.getGroup ( )

inline

                                    {
                return group;
        }

getInum()

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

inline

                                {
                return inum;
        }

getMemberDisplayNameEntiries()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateGroupAction.getMemberDisplayNameEntiries ( ) throws Exception

inlineprivate

                                                                                       {
                List<DisplayNameEntry> result = new ArrayList<DisplayNameEntry>();
                List<DisplayNameEntry> tmp = lookupService.getDisplayNameEntries(personService.getDnForPerson(null), this.group.getMembers());
                if (tmp != null) {
                        result.addAll(tmp);
                }

                return result;
        }

getMembers()

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateGroupAction.getMembers ( )

inline

                                                   {
                return members;
        }

getSearchAvailableMemberPattern()

String org.gluu.oxtrust.action.UpdateGroupAction.getSearchAvailableMemberPattern ( )

inline

                                                        {
                return this.searchAvailableMemberPattern;
        }

isSLAManager()

GluuBoolean org.gluu.oxtrust.action.UpdateGroupAction.isSLAManager ( String []  organizationGroups, GluuCustomPerson  person  ) throws Exception

inlineprivate

                                                                                                                {
                return GluuBoolean.getByValue(String.valueOf(groupService.isMemberOrOwner(organizationGroups, person.getDn())));
        }

isUpdate()

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

inline

                                  {
                return update;
        }

removeMember()

void org.gluu.oxtrust.action.UpdateGroupAction.removeMember ( String  inum ) throws Exception

inline

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

                String removeMemberInum = personService.getDnForPerson(inum);

                for (Iterator<DisplayNameEntry> iterator = this.members.iterator(); iterator.hasNext();) {
                        DisplayNameEntry member = iterator.next();
                        if (removeMemberInum.equals(member.getDn())) {
                                iterator.remove();
                                break;
                        }
                }
        }

save()

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

inline

                                              {
                List<DisplayNameEntry> oldMembers = null;
                try {
                        oldMembers = getMemberDisplayNameEntiries();
                } catch (BasePersistenceException ex) {
                        log.error("Failed to load person display names", ex);

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

                updateMembers();
                if (update) {
                        // Update group
                        try {
                                groupService.updateGroup(this.group);
                                oxTrustAuditService.audit("GROUP " + this.group.getInum() + " **"+this.group.getDisplayName()+ "** UPDATED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                updatePersons(oldMembers, this.members);
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to update group {}", this.inum, ex);
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to update group '#{updateGroupAction.group.displayName}'");

                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        facesMessages.add(FacesMessage.SEVERITY_INFO, "Group '#{updateGroupAction.group.displayName}' updated successfully");
                } else {
                        this.inum = groupService.generateInumForNewGroup();
                        String dn = groupService.getDnForGroup(this.inum);

                        // Save group
                        this.group.setDn(dn);
                        this.group.setInum(this.inum);
                        try {
                                groupService.addGroup(this.group);
                                oxTrustAuditService.audit("GROUP " + this.group.getInum() + " "+this.group.getDisplayName()+ " ADDED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                updatePersons(oldMembers, this.members);
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to add new group {}", this.group.getInum(), ex);
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new group");

                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        facesMessages.add(FacesMessage.SEVERITY_INFO, "New group '#{updateGroupAction.group.displayName}' added successfully");
                        conversationService.endConversation();

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

searchAvailableMembers()

void org.gluu.oxtrust.action.UpdateGroupAction.searchAvailableMembers ( )

inline

                                             {
                if (Util.equals(this.oldSearchAvailableMemberPattern, this.searchAvailableMemberPattern)) {
                        return;
                }

                try {
                        this.availableMembers = personService.searchPersons(this.searchAvailableMemberPattern, OxTrustConstants.searchGroupSizeLimit);
                        this.oldSearchAvailableMemberPattern = this.searchAvailableMemberPattern;
                        selectAddedMembers();
                } catch (Exception ex) {
                        log.error("Failed to find persons", ex);
                }
        }

selectAddedMembers()

void org.gluu.oxtrust.action.UpdateGroupAction.selectAddedMembers ( )

inline

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

                Set<String> addedMemberInums = new HashSet<String>();
                for (DisplayNameEntry member : members) {
                        addedMemberInums.add(member.getInum());
                }

                for (GluuCustomPerson person : this.availableMembers) {
                        person.setSelected(addedMemberInums.contains(person.getInum()));
                }
        }

setInum()

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

inline

                                         {
                this.inum = inum;
        }

setSearchAvailableMemberPattern()

void org.gluu.oxtrust.action.UpdateGroupAction.setSearchAvailableMemberPattern ( String  searchAvailableMemberPattern )

inline

                                                                                         {
                this.searchAvailableMemberPattern = searchAvailableMemberPattern;
        }

update()

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

inline

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

                this.update = true;
                log.debug("this.update : " + this.update);
                try {
                        log.debug("inum : " + inum);
                        this.group = groupService.getGroupByInum(inum);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to find group {}", inum, ex);
                }

                if (this.group == null) {
                        log.error("Failed to load group {}", inum);

                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to find group");
                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

                try {
                        this.members = getMemberDisplayNameEntiries();
                } catch (BasePersistenceException ex) {
                        log.error("Failed to prepare lists", ex);

                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to load group");
                        conversationService.endConversation();

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

updateMembers()

void org.gluu.oxtrust.action.UpdateGroupAction.updateMembers ( )

inlineprivate

                                     {
                if (this.members == null || this.members.size() == 0) {
                        this.group.setMembers(null);
                        return;
                }

                List<String> tmpMembers = new ArrayList<String>();
                for (DisplayNameEntry member : this.members) {
                        tmpMembers.add(member.getDn());
                }

                this.group.setMembers(tmpMembers);
        }

updatePersons()

void org.gluu.oxtrust.action.UpdateGroupAction.updatePersons ( List< DisplayNameEntry >  oldMembers, List< DisplayNameEntry >  newMembers  ) throws Exception

inlineprivate

                                                                                                                          {
                log.debug("Old members: {}", oldMembers);
                log.debug("New members: {}", newMembers);

                String groupDn = this.group.getDn();

                GluuOrganization organization = organizationService.getOrganization();
                String organizationGroups[] = { organization.getManagerGroup() };

                // Convert members to array of DNs
                String[] oldMemberDns = convertToDNsArray(oldMembers);
                String[] newMemberDns = convertToDNsArray(newMembers);

                Arrays.sort(oldMemberDns);
                Arrays.sort(newMemberDns);

                boolean[] retainOldMembers = new boolean[oldMemberDns.length];
                Arrays.fill(retainOldMembers, false);

                List<String> addedMembers = new ArrayList<String>();
                List<String> removedMembers = new ArrayList<String>();
                List<String> existingMembers = new ArrayList<String>();

                // Add new values
                for (String value : newMemberDns) {
                        int idx = Arrays.binarySearch(oldMemberDns, value);
                        if (idx >= 0) {
                                // Old members array contains member. Retain member
                                retainOldMembers[idx] = true;
                        } else {
                                // This is new member
                                addedMembers.add(value);
                        }
                }

                // Remove members which we don't have in new members
                for (int i = 0; i < oldMemberDns.length; i++) {
                        if (retainOldMembers[i]) {
                                existingMembers.add(oldMemberDns[i]);
                        } else {
                                removedMembers.add(oldMemberDns[i]);
                        }
                }

                for (String dn : addedMembers) {
                        GluuCustomPerson person = personService.getPersonByDn(dn);
                        log.debug("Adding group {} to person {} memberOf", groupDn, person.getDisplayName());

                        if (appConfiguration.isUpdateApplianceStatus()) {
                                GluuBoolean slaManager = isSLAManager(organizationGroups, person);
                                person.setSLAManager(slaManager);
                        }

                        List<String> personMemberOf = new ArrayList<String>(person.getMemberOf());
                        personMemberOf.add(groupDn);
                        person.setMemberOf(personMemberOf);

                        personService.updatePerson(person);
                }

                for (String dn : removedMembers) {
                        GluuCustomPerson person = personService.getPersonByDn(dn);
                        log.debug("Removing group {} from person {} memberOf", groupDn, person.getDisplayName());

                        if (appConfiguration.isUpdateApplianceStatus()) {
                                GluuBoolean slaManager = isSLAManager(organizationGroups, person);
                                person.setSLAManager(slaManager);
                        }

                        List<String> personMemberOf = new ArrayList<String>(person.getMemberOf());
                        personMemberOf.remove(groupDn);
                        person.setMemberOf(personMemberOf);

                        personService.updatePerson(person);
                }

                if (appConfiguration.isUpdateApplianceStatus()) {
                        // Update existing members if needed
                        for (String dn : existingMembers) {
                                GluuCustomPerson person = personService.getPersonByDn(dn);
                                log.debug("Updating group {} to person {} memberOf", groupDn, person.getDisplayName());

                                GluuBoolean slaManager = isSLAManager(organizationGroups, person);
                                if (slaManager.equals(person.getSLAManager())) {
                                        continue;
                                }
        
                                person.setSLAManager(slaManager);
                                personService.updatePerson(person);
                        }
                }
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.UpdateGroupAction.appConfiguration

private

availableMembers

List<GluuCustomPerson> org.gluu.oxtrust.action.UpdateGroupAction.availableMembers

private

conversationService

ConversationService org.gluu.oxtrust.action.UpdateGroupAction.conversationService

private

facesMessages

FacesMessages org.gluu.oxtrust.action.UpdateGroupAction.facesMessages

private

group

GluuGroup org.gluu.oxtrust.action.UpdateGroupAction.group

private

groupService

IGroupService org.gluu.oxtrust.action.UpdateGroupAction.groupService

private

identity

Identity org.gluu.oxtrust.action.UpdateGroupAction.identity

private

inum

String org.gluu.oxtrust.action.UpdateGroupAction.inum

private

log

Logger org.gluu.oxtrust.action.UpdateGroupAction.log

private

lookupService

LookupService org.gluu.oxtrust.action.UpdateGroupAction.lookupService

private

members

List<DisplayNameEntry> org.gluu.oxtrust.action.UpdateGroupAction.members

private

oldSearchAvailableMemberPattern

String org.gluu.oxtrust.action.UpdateGroupAction.oldSearchAvailableMemberPattern

private

organizationService

OrganizationService org.gluu.oxtrust.action.UpdateGroupAction.organizationService

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.UpdateGroupAction.oxTrustAuditService

private

personService

IPersonService org.gluu.oxtrust.action.UpdateGroupAction.personService

private

searchAvailableMemberPattern

String org.gluu.oxtrust.action.UpdateGroupAction.searchAvailableMemberPattern

private

serialVersionUID

final long org.gluu.oxtrust.action.UpdateGroupAction.serialVersionUID = 572441515451149801L

staticprivate

update

boolean org.gluu.oxtrust.action.UpdateGroupAction.update

private

---

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

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