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

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

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

公開メンバ関数
GluuCustomFidoDevice	getFidoDevice ()
void	setFidoDevice (GluuCustomFidoDevice fidoDevice)
List< GluuDeviceDataBean >	getDeviceDataMap ()
void	setDeviceDataMap (List< GluuDeviceDataBean > deviceDataMap)
DeviceData	getDeviceDetail ()
void	setDeviceDetail (DeviceData deviceDetail)
List< String >	getExternalAuthCustomAttributes ()
void	setExternalAuthCustomAttributes (List< String > externalAuthCustomAttributes)
GluuStatus	getGluuStatus ()
void	setGluuStatus (GluuStatus gluuStatus)
String	add ()
String	update ()
String	cancel ()
String	save () throws Exception
String	delete ()
String	getGroupName (String dn)
String	getInum ()
void	setInum (String inum)
GluuCustomPerson	getPerson ()
boolean	isUpdate ()
GluuStatus []	getActiveInactiveStatuses ()
void	validateConfirmPassword (FacesContext context, UIComponent comp, Object value)
void	removeDevice (GluuDeviceDataBean deleteDeviceData)
void	fetchFidoRecord (String id)
boolean	userNameIsUniqAtCreationTime (String uid)
boolean	userNameIsUniqAtEditionTime (String uid)
boolean	userEmailIsUniqAtCreationTime (String email)
boolean	userEmailIsUniqAtEditionTime (String email)

非公開メンバ関数
void	updateCustomObjectClasses ()
void	initAttributes (boolean add)
DeviceData	getDeviceata (String data)

非公開変数類
Logger	log
String	inum
boolean	update
GluuCustomPerson	person
FacesMessages	facesMessages
ConversationService	conversationService
OrganizationService	organizationService
GroupService	groupService
AttributeService	attributeService
IPersonService	personService
CustomAttributeAction	customAttributeAction
AppConfiguration	appConfiguration
ExternalUpdateUserService	externalUpdateUserService
MemberService	memberService
PersistenceEntryManager	ldapEntryManager
FidoDeviceService	fidoDeviceService
Identity	identity
OxTrustAuditService	oxTrustAuditService
GluuStatus	gluuStatus
String	password
String	confirmPassword
List< GluuDeviceDataBean >	deviceDataMap
GluuCustomFidoDevice	fidoDevice
List< String >	externalAuthCustomAttributes
DeviceData	deviceDetail

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

詳解

Action class for updating person's attributes

著者

Yuriy Movchan Date: 10.23.2010

関数詳解

add()

String org.gluu.oxtrust.action.UpdatePersonAction.add ( )

inline

Initializes attributes for adding new person

戻り値

String describing success of the operation

例外

Exception

                            {
                if (!organizationService.isAllowPersonModification()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new person");
                        conversationService.endConversation();

                        return OxTrustConstants.RESULT_FAILURE;
                }

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

                this.update = false;
                this.person = new GluuCustomPerson();

                initAttributes(true);

                return OxTrustConstants.RESULT_SUCCESS;
        }

cancel()

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

inline

                               {
                if (update) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "Person '#{updatePersonAction.person.displayName}' not updated");
                } else {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "New person not added");
                }

                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

delete()

String org.gluu.oxtrust.action.UpdatePersonAction.delete ( )

inline

Delete selected person from ldap

戻り値

String describing success of the operation

例外

Exception

                               {
                if (!organizationService.isAllowPersonModification()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Failed to remove person '#{updatePersonAction.person.displayName}'");
                        return OxTrustConstants.RESULT_FAILURE;
                }

                if (update) {
                        // Remove person
                        try {
                                boolean runScript = externalUpdateUserService.isEnabled();
                                if (runScript) {
                                        externalUpdateUserService.executeExternalDeleteUserMethods(this.person);
                                }
                                memberService.removePerson(this.person);
                                oxTrustAuditService.audit("USER " + this.person.getInum() + " **"+this.person.getDisplayName()+ "** REMOVED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                if (runScript) {
                                        externalUpdateUserService.executeExternalPostDeleteUserMethods(this.person);
                                }

                                facesMessages.add(FacesMessage.SEVERITY_INFO,
                                                "Person '#{updatePersonAction.person.displayName}' removed successfully");
                                conversationService.endConversation();

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

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

                return OxTrustConstants.RESULT_FAILURE;
        }

fetchFidoRecord()

void org.gluu.oxtrust.action.UpdatePersonAction.fetchFidoRecord ( String  id )

inline

                                               {
                this.fidoDevice = fidoDeviceService.getGluuCustomFidoDeviceById(this.person.getInum(), id);
                if (this.fidoDevice.getDeviceData() != null) {
                        this.deviceDetail = getDeviceata(this.fidoDevice.getDeviceData());
                } else {
                        this.deviceDetail = null;
                }

        }

getActiveInactiveStatuses()

GluuStatus [] org.gluu.oxtrust.action.UpdatePersonAction.getActiveInactiveStatuses ( )

inline

                                                        {
                return new GluuStatus[] { GluuStatus.ACTIVE, GluuStatus.INACTIVE };
        }

getDeviceata()

DeviceData org.gluu.oxtrust.action.UpdatePersonAction.getDeviceata ( String  data )

inlineprivate

                                                     {
                ObjectMapper mapper = new ObjectMapper();

                // JSON from file to Object
                DeviceData obj = null;
                try {
                        obj = mapper.readValue(data, DeviceData.class);
                } catch (JsonParseException e) {
                        // TODO Auto-generated catch block
                        log.error("Failed to convert device string to object JsonParseException", e);
                } catch (JsonMappingException e) {
                        // TODO Auto-generated catch block
                        log.error("Failed to convert device string to object JsonMappingException", e);
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        log.error("Failed to convert device string to object IOException", e);
                }
                return obj;
        }

getDeviceDataMap()

List<GluuDeviceDataBean> org.gluu.oxtrust.action.UpdatePersonAction.getDeviceDataMap ( )

inline

                                                           {
                return deviceDataMap;
        }

getDeviceDetail()

DeviceData org.gluu.oxtrust.action.UpdatePersonAction.getDeviceDetail ( )

inline

                                            {
                return deviceDetail;
        }

getExternalAuthCustomAttributes()

List<String> org.gluu.oxtrust.action.UpdatePersonAction.getExternalAuthCustomAttributes ( )

inline

                                                              {
                return externalAuthCustomAttributes;
        }

getFidoDevice()

GluuCustomFidoDevice org.gluu.oxtrust.action.UpdatePersonAction.getFidoDevice ( )

inline

                                                    {
                return fidoDevice;
        }

getGluuStatus()

GluuStatus org.gluu.oxtrust.action.UpdatePersonAction.getGluuStatus ( )

inline

                                          {
                return gluuStatus;
        }

getGroupName()

String org.gluu.oxtrust.action.UpdatePersonAction.getGroupName ( String  dn )

inline

                                              {
                if (dn != null) {
                        GluuGroup group = groupService.getGroupByDn(dn);
                        if (group != null) {
                                String groupName = group.getDisplayName();
                                if (groupName != null && !groupName.isEmpty()) {
                                        return groupName;
                                }
                        }
                }
                return "invalid group name";

        }

getInum()

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

inline

Returns person's inum

戻り値

inum

                                {
                return inum;
        }

getPerson()

GluuCustomPerson org.gluu.oxtrust.action.UpdatePersonAction.getPerson ( )

inline

Returns person

戻り値

GluuCustomPerson

                                            {
                return person;
        }

initAttributes()

void org.gluu.oxtrust.action.UpdatePersonAction.initAttributes ( boolean  add )

inlineprivate

                                                 {
                if (add && externalUpdateUserService.isEnabled()) {
                        externalUpdateUserService.executeExternalNewUserMethods(this.person);
                }

                List<GluuAttribute> attributes = attributeService.getAllPersonAttributes(UserRole.ADMIN);
                List<String> origins = attributeService.getAllAttributeOrigins(attributes);

                List<GluuCustomAttribute> customAttributes = this.person.getCustomAttributes();
                boolean newPerson = (customAttributes == null) || customAttributes.isEmpty();
                if (newPerson) {
                        customAttributes = new ArrayList<GluuCustomAttribute>();
                        this.person.setCustomAttributes(customAttributes);
                }

                customAttributeAction.initCustomAttributes(attributes, customAttributes, origins,
                                appConfiguration.getPersonObjectClassTypes(), appConfiguration.getPersonObjectClassDisplayNames());

                if (newPerson) {
                        customAttributeAction.addCustomAttributes(personService.getMandatoryAtributes());
                }
        }

isUpdate()

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

inline

Return true if person is being updated, false if adding new person

戻り値

                                  {
                return update;
        }

removeDevice()

void org.gluu.oxtrust.action.UpdatePersonAction.removeDevice ( GluuDeviceDataBean  deleteDeviceData )

inline

                                                                      {
                try {
                        List<GluuCustomFidoDevice> gluuCustomFidoDevices = fidoDeviceService
                                        .searchFidoDevices(this.person.getInum(), null);
                        if (gluuCustomFidoDevices != null) {
                                for (GluuCustomFidoDevice gluuCustomFidoDevice : gluuCustomFidoDevices) {
                                        if (gluuCustomFidoDevice.getId().equals(deleteDeviceData.getId())) {
                                                fidoDeviceService.removeGluuCustomFidoDevice(gluuCustomFidoDevice);
                                                this.deviceDataMap.remove(deleteDeviceData);
                                                return;
                                        }
                                }
                        }

                        List<String> list = new ArrayList<String>(this.person.getOxExternalUid());
                        if (list != null) {
                                for (String external : list) {
                                        if (deleteDeviceData.getId().trim().equals(external.trim())) {
                                                list.remove(external);
                                                this.person.setOxExternalUid(list);
                                                this.deviceDataMap.remove(deleteDeviceData);
                                                return;
                                        }
                                }
                        }

                        OTPDevice oxOTPDevices = this.person.getOxOTPDevices();
                        /*
                         * if (oxOTPDevices != null && !oxOTPDevices.trim().equals("")) { ObjectMapper
                         * mapper = new ObjectMapper(); OTPDevice oTPDevice =
                         * mapper.readValue(oxOTPDevices, OTPDevice.class);
                         */
                        ArrayList<Device> devices = oxOTPDevices.getDevices();

                        if (devices != null && devices.size() > 0) {
                                for (Device device : devices) {
                                        if (deleteDeviceData.getId().equals(device.getId())) {
                                                deviceDataMap.remove(deleteDeviceData);
                                                devices.remove(device);
                                                /*
                                                 * Map<String, ArrayList<Device>> map= new HashMap<String, ArrayList<Device>>();
                                                 * map.put("devices", devices); String jsonInString =
                                                 * mapper.writeValueAsString(map);
                                                 */
                                                oxOTPDevices.setDevices(devices);
                                                this.person.setOxOTPDevices(oxOTPDevices);
                                                return;
                                        }
                                }
                        }
                        // }

                        String oxMobileDevices = this.person.getOxMobileDevices();
                        if (oxMobileDevices != null && !oxMobileDevices.trim().equals("")) {
                                ObjectMapper mapper = new ObjectMapper();
                                MobileDevice mobileDevice = mapper.readValue(oxMobileDevices, MobileDevice.class);
                                ArrayList<Phone> phones = mobileDevice.getPhones();

                                if (phones != null && phones.size() > 0) {
                                        for (Phone phone : phones) {
                                                if (phone.getNumber().equals(deleteDeviceData.getId())) {
                                                        deviceDataMap.remove(deleteDeviceData);
                                                        phones.remove(phone);
                                                        Map<String, ArrayList<Phone>> map = new HashMap<String, ArrayList<Phone>>();
                                                        map.put("phones", phones);
                                                        String jsonInString = mapper.writeValueAsString(map);
                                                        this.person.setOxMobileDevices(jsonInString);
                                                        return;
                                                }
                                        }
                                }
                        }

                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        log.error("Failed to remove device ", e);
                }
        }

save()

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

inline

Saves person to ldap

戻り値

String describing success of the operation

                                              {
                if (!organizationService.isAllowPersonModification()) {
                        return OxTrustConstants.RESULT_FAILURE;
                }
                if (!update) {
                        if (!userNameIsUniqAtCreationTime(this.person.getUid())) {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "#{msg['UpdatePersonAction.faileAddUserUidExist']} %s",
                                                this.person.getUid());
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                        if (!userEmailIsUniqAtCreationTime(this.person.getAttribute("mail"))) {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                                "#{msg['UpdatePersonAction.faileUpdateUserMailidExist']} %s", this.person.getAttribute("mail"));
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                } else {
                        if (!userNameIsUniqAtEditionTime(this.person.getUid())) {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "#{msg['UpdatePersonAction.faileAddUserUidExist']} %s",
                                                this.person.getUid());
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                        if (!userEmailIsUniqAtEditionTime(this.person.getAttribute("mail"))) {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                                "#{msg['UpdatePersonAction.faileUpdateUserMailidExist']} %s", this.person.getAttribute("mail"));
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                }

                updateCustomObjectClasses();

                List<GluuCustomAttribute> removedAttributes = customAttributeAction.detectRemovedAttributes();
                customAttributeAction.updateOriginCustomAttributes();

                List<GluuCustomAttribute> customAttributes = customAttributeAction.getCustomAttributes();
                for (GluuCustomAttribute customAttribute : customAttributes) {
                        if (customAttribute.getName().equalsIgnoreCase("gluuStatus")) {
                                customAttribute.setValue(gluuStatus.getValue());
                        }

                }
                this.person.setCustomAttributes(customAttributeAction.getCustomAttributes());
                this.person.getCustomAttributes().addAll(removedAttributes);

                // Sync email, in reverse ("oxTrustEmail" <- "mail")
                this.person = ServiceUtil.syncEmailReverse(this.person, true);

                boolean runScript = externalUpdateUserService.isEnabled();
                if (update) {
                        try {
                                if (runScript) {
                                        externalUpdateUserService.executeExternalUpdateUserMethods(this.person);
                                }
                                personService.updatePerson(this.person);
                                oxTrustAuditService.audit("USER " + this.person.getInum() + " **"+this.person.getDisplayName()+"** UPDATED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                if (runScript) {
                                        externalUpdateUserService.executeExternalPostUpdateUserMethods(this.person);
                                }
                        } catch (Exception ex) {
                                log.error("Failed to update person {}", inum, ex);
                                facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                                "Failed to update person '#{updatePersonAction.person.displayName}'");

                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        facesMessages.add(FacesMessage.SEVERITY_INFO,
                                        "Person '#{updatePersonAction.person.displayName}' updated successfully");
                } else {
                        if (personService.getPersonByUid(this.person.getUid()) != null) {
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Person with the uid '#{updatePersonAction.person.uid}' already exist'");
                                return OxTrustConstants.RESULT_DUPLICATE;
                        }

                        this.inum = personService.generateInumForNewPerson();
                        String iname = personService.generateInameForNewPerson(this.person.getUid());
                        String dn = personService.getDnForPerson(this.inum);

                        // Save person
                        this.person.setDn(dn);
                        this.person.setInum(this.inum);
                        this.person.setIname(iname);
                        this.person.setUserPassword(this.password);

                        List<GluuCustomAttribute> personAttributes = this.person.getCustomAttributes();
                        if (!personAttributes.contains(new GluuCustomAttribute("cn", ""))) {
                                List<GluuCustomAttribute> changedAttributes = new ArrayList<GluuCustomAttribute>();
                                changedAttributes.addAll(personAttributes);
                                changedAttributes.add(
                                                new GluuCustomAttribute("cn", this.person.getGivenName() + " " + this.person.getDisplayName()));
                                this.person.setCustomAttributes(changedAttributes);
                        } else {
                                this.person.setCommonName(this.person.getCommonName() + " " + this.person.getGivenName());
                        }

                        try {
                                if (runScript) {
                                        externalUpdateUserService.executeExternalAddUserMethods(this.person);
                                }
                                personService.addPerson(this.person);
                                oxTrustAuditService.audit("USER " + this.person.getInum() + " **"+this.person.getDisplayName()+ "** ADDED",
                                                identity.getUser(),
                                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                                if (runScript) {
                                        externalUpdateUserService.executeExternalPostAddUserMethods(this.person);
                                }
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to add new person {}", this.person.getInum(), ex);
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new person'");

                                return OxTrustConstants.RESULT_FAILURE;
                        }

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

                        this.update = true;
                }

                return OxTrustConstants.RESULT_SUCCESS;
        }

setDeviceDataMap()

void org.gluu.oxtrust.action.UpdatePersonAction.setDeviceDataMap ( List< GluuDeviceDataBean >  deviceDataMap )

inline

                                                                             {
                this.deviceDataMap = deviceDataMap;
        }

setDeviceDetail()

void org.gluu.oxtrust.action.UpdatePersonAction.setDeviceDetail ( DeviceData  deviceDetail )

inline

                                                             {
                this.deviceDetail = deviceDetail;
        }

setExternalAuthCustomAttributes()

void org.gluu.oxtrust.action.UpdatePersonAction.setExternalAuthCustomAttributes ( List< String >  externalAuthCustomAttributes )

inline

                                                                                               {
                this.externalAuthCustomAttributes = externalAuthCustomAttributes;
        }

setFidoDevice()

void org.gluu.oxtrust.action.UpdatePersonAction.setFidoDevice ( GluuCustomFidoDevice  fidoDevice )

inline

                                                                   {
                this.fidoDevice = fidoDevice;
        }

setGluuStatus()

void org.gluu.oxtrust.action.UpdatePersonAction.setGluuStatus ( GluuStatus  gluuStatus )

inline

                                                         {
                this.gluuStatus = gluuStatus;
        }

setInum()

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

inline

Sets person's inum

引数

inum

                                         {
                this.inum = inum;
        }

update()

String org.gluu.oxtrust.action.UpdatePersonAction.update ( )

inline

Initializes attributes for updating person

戻り値

String describing success of the operation

例外

Exception

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

                this.update = true;
                try {
                        this.person = personService.getPersonByInum(inum);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to find person {}", inum, ex);

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

                        return OxTrustConstants.RESULT_FAILURE;
                }

                initAttributes(false);
                try {
                        this.gluuStatus = this.person.getStatus();
                        List<String> oxexternal = this.person.getOxExternalUid();
                        OTPDevice oxOTPDevices = this.person.getOxOTPDevices();
                        externalAuthCustomAttributes = new ArrayList<String>();
                        String oxMobileDevices = this.person.getOxMobileDevices();
                        if (oxexternal != null && oxexternal.size() > 0) {
                                for (String oxexternalStr : oxexternal) {
                                        String[] args = oxexternalStr.split(":");
                                        externalAuthCustomAttributes.add(args[0]);
                                }
                        }

                        List<GluuCustomFidoDevice> gluuCustomFidoDevices = fidoDeviceService
                                        .searchFidoDevices(this.person.getInum(), null);
                        deviceDataMap = new ArrayList<GluuDeviceDataBean>();
                        if (gluuCustomFidoDevices != null) {
                                for (GluuCustomFidoDevice gluuCustomFidoDevice : gluuCustomFidoDevices) {
                                        GluuDeviceDataBean gluuDeviceDataBean = new GluuDeviceDataBean();
                                        gluuDeviceDataBean.setCreationDate(ldapEntryManager.decodeTime(gluuCustomFidoDevice.getCreationDate()).toGMTString());
                                        gluuDeviceDataBean.setId(gluuCustomFidoDevice.getId());
                                        String devicedata = gluuCustomFidoDevice.getDeviceData();
                                        String modality = "";
                                        String nickName = "";
                                        if (devicedata != null) {
                                                DeviceData deviceData = getDeviceata(devicedata);
                                                // nickName = deviceData.getName();
                                                nickName = gluuCustomFidoDevice.getNickname();
                                                modality = "Super-Gluu Device";
                                        } else {
                                                // nickName = "U2F";
                                                nickName = gluuCustomFidoDevice.getNickname();
                                                modality = "U2F device";
                                        }
                                        gluuDeviceDataBean.setNickName(nickName);
                                        gluuDeviceDataBean.setModality(modality);
                                        deviceDataMap.add(gluuDeviceDataBean);
                                }
                        }

                        /*
                         * if (oxOTPDevices != null && !oxOTPDevices.trim().equals("")) { ObjectMapper
                         * mapper = new ObjectMapper(); OTPDevice oTPDevice =
                         * mapper.readValue(oxOTPDevices, OTPDevice.class);
                         */
                        ArrayList<Device> devices = oxOTPDevices.getDevices();

                        if (devices != null && devices.size() > 0) {
                                for (Device device : devices) {
                                        GluuDeviceDataBean gluuDeviceDataBean = new GluuDeviceDataBean();
                                        gluuDeviceDataBean.setNickName(device.getNickName());
                                        gluuDeviceDataBean.setModality("OTP Device");
                                        gluuDeviceDataBean.setId(device.getId());
                                        Timestamp stamp = new Timestamp(Long.valueOf(device.getAddedOn()).longValue());
                                        gluuDeviceDataBean.setCreationDate(stamp.toGMTString());
                                        deviceDataMap.add(gluuDeviceDataBean);
                                }
                        }
                        // }

                        if (oxMobileDevices != null && !oxMobileDevices.trim().equals("")) {
                                ObjectMapper mapper = new ObjectMapper();
                                MobileDevice mobileDevice = mapper.readValue(oxMobileDevices, MobileDevice.class);
                                ArrayList<Phone> phones = mobileDevice.getPhones();

                                if (phones != null && phones.size() > 0) {
                                        for (Phone phone : phones) {
                                                GluuDeviceDataBean gluuDeviceDataBean = new GluuDeviceDataBean();
                                                gluuDeviceDataBean.setNickName(phone.getNickName());
                                                gluuDeviceDataBean.setModality("Mobile Device");
                                                gluuDeviceDataBean.setId(phone.getNumber());

                                                Timestamp stamp = new Timestamp(Long.valueOf(phone.getAddedOn()).longValue());
                                                gluuDeviceDataBean.setCreationDate(stamp.toGMTString());
                                                deviceDataMap.add(gluuDeviceDataBean);
                                        }
                                }
                        }
                        if (oxexternal != null && oxexternal.size() > 0) {
                                for (String oxexternalStr : oxexternal) {
                                        String[] args = oxexternalStr.split(":");
                                        GluuDeviceDataBean gluuDeviceDataBean = new GluuDeviceDataBean();
                                        gluuDeviceDataBean.setNickName(args[0]);
                                        gluuDeviceDataBean.setModality("Passport");
                                        gluuDeviceDataBean.setId("-");
                                        gluuDeviceDataBean.setCreationDate("-");
                                        deviceDataMap.add(gluuDeviceDataBean);

                                }
                        }
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return OxTrustConstants.RESULT_SUCCESS;
        }

updateCustomObjectClasses()

void org.gluu.oxtrust.action.UpdatePersonAction.updateCustomObjectClasses ( )

inlineprivate

                                                 {
                personService.addCustomObjectClass(this.person);

                // Update objectClasses
                String[] allObjectClasses = ArrayHelper.arrayMerge(appConfiguration.getPersonObjectClassTypes(),
                                this.person.getCustomObjectClasses());
                String[] resultObjectClasses = new HashSet<String>(Arrays.asList(allObjectClasses)).toArray(new String[0]);

                this.person.setCustomObjectClasses(resultObjectClasses);
        }

userEmailIsUniqAtCreationTime()

boolean org.gluu.oxtrust.action.UpdatePersonAction.userEmailIsUniqAtCreationTime ( String  email )

inline

                                                                   {
                if(email == null) {
                        return true;
                }
                boolean emailIsUniq = true;
                List<GluuCustomPerson> gluuCustomPersons = personService.getPersonsByEmail(email);
                if (gluuCustomPersons != null && gluuCustomPersons.size() > 0) {
                        for (GluuCustomPerson gluuCustomPerson : gluuCustomPersons) {
                                if (gluuCustomPerson.getAttribute("mail").equalsIgnoreCase(email)) {
                                        emailIsUniq = false;
                                        break;
                                }
                        }
                }
                return emailIsUniq;
        }

userEmailIsUniqAtEditionTime()

boolean org.gluu.oxtrust.action.UpdatePersonAction.userEmailIsUniqAtEditionTime ( String  email )

inline

                                                                  {
                boolean emailIsUniq = false;
                if(email == null) {
                        return true;
                }
                List<GluuCustomPerson> gluuCustomPersons = personService.getPersonsByEmail(email);
                if (gluuCustomPersons == null || gluuCustomPersons.isEmpty()) {
                        emailIsUniq = true;
                }
                if (gluuCustomPersons.size() == 1 && gluuCustomPersons.get(0).getAttribute("mail").equalsIgnoreCase(email)
                                && gluuCustomPersons.get(0).getInum().equalsIgnoreCase(this.person.getInum())) {
                        emailIsUniq = true;
                }

                return emailIsUniq;
        }

userNameIsUniqAtCreationTime()

boolean org.gluu.oxtrust.action.UpdatePersonAction.userNameIsUniqAtCreationTime ( String  uid )

inline

                                                                {
                boolean userNameIsUniq = true;
                if(uid == null) {
                        return userNameIsUniq;
                }
                List<GluuCustomPerson> gluuCustomPersons = personService.getPersonsByUid(uid);
                if (gluuCustomPersons != null && gluuCustomPersons.size() > 0) {
                        for (GluuCustomPerson gluuCustomPerson : gluuCustomPersons) {
                                if (gluuCustomPerson.getUid().equalsIgnoreCase(uid)) {
                                        userNameIsUniq = false;
                                        break;
                                }
                        }
                }
                return userNameIsUniq;
        }

userNameIsUniqAtEditionTime()

boolean org.gluu.oxtrust.action.UpdatePersonAction.userNameIsUniqAtEditionTime ( String  uid )

inline

                                                               {
                if(uid == null) {
                        return true;
                }
                boolean userNameIsUniq = false;
                List<GluuCustomPerson> gluuCustomPersons = personService.getPersonsByUid(uid);
                if (gluuCustomPersons == null || gluuCustomPersons.isEmpty()) {
                        userNameIsUniq = true;
                }
                if (gluuCustomPersons.size() == 1 && gluuCustomPersons.get(0).getUid().equalsIgnoreCase(uid)
                                && gluuCustomPersons.get(0).getInum().equalsIgnoreCase(this.person.getInum())) {
                        userNameIsUniq = true;
                }
                return userNameIsUniq;
        }

validateConfirmPassword()

void org.gluu.oxtrust.action.UpdatePersonAction.validateConfirmPassword ( FacesContext  context, UIComponent  comp, Object  value  )

inline

                                                                                                  {
                if (comp.getClientId().endsWith("custpasswordId")) {
                        this.password = (String) value;
                } else if (comp.getClientId().endsWith("custconfirmpasswordId")) {
                        this.confirmPassword = (String) value;
                }

                if (!StringHelper.equalsIgnoreCase(password, confirmPassword)) {
                        ((UIInput) comp).setValid(false);
                        FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                                        "Password and Confirm Password should be same!", "Password and Confirm Password should be same!");
                        context.addMessage(comp.getClientId(context), message);
                }
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.UpdatePersonAction.appConfiguration

private

attributeService

AttributeService org.gluu.oxtrust.action.UpdatePersonAction.attributeService

private

confirmPassword

String org.gluu.oxtrust.action.UpdatePersonAction.confirmPassword

private

conversationService

ConversationService org.gluu.oxtrust.action.UpdatePersonAction.conversationService

private

customAttributeAction

CustomAttributeAction org.gluu.oxtrust.action.UpdatePersonAction.customAttributeAction

private

deviceDataMap

List<GluuDeviceDataBean> org.gluu.oxtrust.action.UpdatePersonAction.deviceDataMap

private

deviceDetail

DeviceData org.gluu.oxtrust.action.UpdatePersonAction.deviceDetail

private

externalAuthCustomAttributes

List<String> org.gluu.oxtrust.action.UpdatePersonAction.externalAuthCustomAttributes

private

externalUpdateUserService

ExternalUpdateUserService org.gluu.oxtrust.action.UpdatePersonAction.externalUpdateUserService

private

facesMessages

FacesMessages org.gluu.oxtrust.action.UpdatePersonAction.facesMessages

private

fidoDevice

GluuCustomFidoDevice org.gluu.oxtrust.action.UpdatePersonAction.fidoDevice

private

fidoDeviceService

FidoDeviceService org.gluu.oxtrust.action.UpdatePersonAction.fidoDeviceService

private

gluuStatus

GluuStatus org.gluu.oxtrust.action.UpdatePersonAction.gluuStatus

private

groupService

GroupService org.gluu.oxtrust.action.UpdatePersonAction.groupService

private

identity

Identity org.gluu.oxtrust.action.UpdatePersonAction.identity

private

inum

String org.gluu.oxtrust.action.UpdatePersonAction.inum

private

ldapEntryManager

PersistenceEntryManager org.gluu.oxtrust.action.UpdatePersonAction.ldapEntryManager

private

log

Logger org.gluu.oxtrust.action.UpdatePersonAction.log

private

memberService

MemberService org.gluu.oxtrust.action.UpdatePersonAction.memberService

private

organizationService

OrganizationService org.gluu.oxtrust.action.UpdatePersonAction.organizationService

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.UpdatePersonAction.oxTrustAuditService

private

password

String org.gluu.oxtrust.action.UpdatePersonAction.password

private

person

GluuCustomPerson org.gluu.oxtrust.action.UpdatePersonAction.person

private

personService

IPersonService org.gluu.oxtrust.action.UpdatePersonAction.personService

private

serialVersionUID

final long org.gluu.oxtrust.action.UpdatePersonAction.serialVersionUID = -3242167044333943689L

staticprivate

update

boolean org.gluu.oxtrust.action.UpdatePersonAction.update

private

---

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

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