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

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

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

クラス
class	FileDataToImport
class	ImportAttribute

公開メンバ関数
String	init ()
String	importPersons () throws Exception
String	validateFileToImport ()
String	cancel ()
void	destroy ()
UploadedFile	getUploadedFile ()
FileDataToImport	getFileDataToImport ()
void	removeFileDataToImport ()
void	uploadFile (FileUploadEvent event)
void	removeFileToImport ()
String	save ()
String	initializePerson ()

静的公開変数類
static final String	PERSON_PASSWORD_ATTRIBUTE = "userPassword"

限定公開メンバ関数
List< GluuCustomPerson >	convertTableToPersons (Table table, List< ImportAttribute > importAttributes) throws Exception

非公開メンバ関数
boolean	prepareAndValidateImportData (Table table, List< ImportAttribute > importAttributes) throws Exception
List< ImportAttribute >	getMandatoryImportAttributes (List< ImportAttribute > importAttributes)
List< GluuAttribute >	getMandatoryAttributes (List< GluuAttribute > attributes)
boolean	setDefaultPersonAttributes (List< GluuCustomPerson > persons, List< ImportAttribute > importAttributes) throws Exception
boolean	validatePersons (List< GluuCustomPerson > persons) throws Exception
String	getTypedValue (GluuAttribute attribute, String value)
String	getAttributesString (List< GluuAttribute > attributes)
List< ImportAttribute >	getAttributesForImport (Table table)
Map< String, GluuAttribute >	getAttributesDisplayNameMap (List< GluuAttribute > attributes)
void	initAttributes ()

非公開変数類
Logger	log
OrganizationService	organizationService
IPersonService	personService
AttributeService	attributeService
AppConfiguration	appConfiguration
ExternalUpdateUserService	externalUpdateUserService
ExcelService	excelService
FacesMessages	facesMessages
ConversationService	conversationService
transient ImportPersonConfiguration	importPersonConfiguration
CustomAttributeAction	customAttributeAction
Identity	identity
OxTrustAuditService	oxTrustAuditService
UploadedFile	uploadedFile
FileDataToImport	fileDataToImport
List< GluuAttribute >	attributes
Map< String, GluuAttribute >	attributesDisplayNameMap
byte []	fileData
boolean	isInitialized
GluuCustomPerson	person
String	inum

静的非公開変数類
static final long	serialVersionUID = -1270460481895022468L
static final String []	PERSON_IMPORT_PERSON_LOCKUP_RETURN_ATTRIBUTES = { "uid", "displayName", "mail" }

詳解

Action class for load persons from Excel file

著者

Yuriy Movchan Date: 02.14.2011

関数詳解

cancel()

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

inline

                               {
                boolean cancel = this.uploadedFile != null;
                destroy();

                if (cancel) {
                        return OxTrustConstants.RESULT_CLEAR;
                }

                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

convertTableToPersons()

List<GluuCustomPerson> org.gluu.oxtrust.action.PersonImportAction.convertTableToPersons ( Table  table, List< ImportAttribute >  importAttributes  ) throws Exception

inlineprotected

                                         {
                // Prepare for conversion to list of GluuCustomPerson and check data
                // type
                Map<String, List<AttributeData>> entriesAttributes = new HashMap<String, List<AttributeData>>();
                int rows = table.getCountRows();
                boolean validTable = true;
                for (int i = 1; i <= rows; i++) {
                        List<AttributeData> attributeDataList = new ArrayList<AttributeData>();
                        for (ImportAttribute importAttribute : importAttributes) {
                                if (importAttribute.getCol() == -1) {
                                        continue;
                                }

                                GluuAttribute attribute = importAttribute.getAttribute();
                                String cellValue = table.getCellValue(importAttribute.getCol(), i);
                                if (StringHelper.isEmpty(cellValue)) {
                                        if (attribute.isRequred()) {
                                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Import failed. Empty '%s' not allowed",
                                                                attribute.getDisplayName());
                                                validTable = false;
                                        }
                                        continue;
                                }

                                String ldapValue = getTypedValue(attribute, cellValue);
                                if (StringHelper.isEmpty(ldapValue)) {
                                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                                        "Invalid value '%s' in column '%s' at row %s were specified", cellValue,
                                                        attribute.getDisplayName(), i + 1);
                                        validTable = false;
                                        continue;
                                }

                                AttributeData attributeData = new AttributeData(attribute.getName(), ldapValue);
                                attributeDataList.add(attributeData);
                        }
                        entriesAttributes.put(Integer.toString(i), attributeDataList);
                }

                if (!validTable) {
                        return null;
                }

                // Convert to GluuCustomPerson and set right DN
                List<GluuCustomPerson> persons = personService.createEntities(entriesAttributes);
                log.info("Found {} persons in input Excel file", persons.size());

                for (GluuCustomPerson person : persons) {
                        for (String key : entriesAttributes.keySet()) {
                                boolean flag = false;
                                for (AttributeData AttributeData : entriesAttributes.get(key)) {
                                        if (AttributeData.getName().equalsIgnoreCase("uid")) {
                                                if (person.getUid().equalsIgnoreCase(AttributeData.getValue())) {
                                                        for (AttributeData AttributeData1 : entriesAttributes.get(key)) {
                                                                if (AttributeData1.getName().equalsIgnoreCase("userPassword")) {
                                                                        person.setUserPassword(AttributeData1.getValue());
                                                                        flag = true;
                                                                        break;
                                                                } else if (AttributeData1.getName().equalsIgnoreCase("gluuStatus")) {

                                                                        person.setStatus(GluuStatus.getByValue(AttributeData1.getValue()));
                                                                        flag = true;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        } else {
                                                if (flag)
                                                        break;
                                        }
                                }
                                if (flag)
                                        break;
                        }

                }

                return persons;
        }

destroy()

void org.gluu.oxtrust.action.PersonImportAction.destroy ( )

inline

                              {
                removeFileDataToImport();
                removeFileToImport();
        }

getAttributesDisplayNameMap()

Map<String, GluuAttribute> org.gluu.oxtrust.action.PersonImportAction.getAttributesDisplayNameMap ( List< GluuAttribute >  attributes )

inlineprivate

                                                                                                       {
                Map<String, GluuAttribute> result = new HashMap<String, GluuAttribute>();
                for (GluuAttribute attribute : attributes) {
                        result.put(attribute.getDisplayName().toLowerCase(), attribute);
                }

                return result;
        }

getAttributesForImport()

List<ImportAttribute> org.gluu.oxtrust.action.PersonImportAction.getAttributesForImport ( Table  table )

inlineprivate

                                                                          {
                List<ImportAttribute> importAttributes = new ArrayList<ImportAttribute>();
                if ((table == null) || (table.getCountCols() < 1) || (table.getCountRows() < 1)) {
                        return importAttributes;
                }

                int cols = table.getCountCols();
                List<String> addedAttributes = new ArrayList<String>(this.attributes.size());
                for (int i = 0; i <= cols; i++) {
                        String cellValue = table.getCellValue(i, 0);
                        if (StringHelper.isEmpty(cellValue)) {
                                continue;
                        }

                        String attributeName = cellValue.toLowerCase();
                        GluuAttribute attribute = attributesDisplayNameMap.get(attributeName);
                        if (attribute != null) {
                                addedAttributes.add(attributeName);
                                ImportAttribute importAttribute = new ImportAttribute(i, attribute);
                                importAttributes.add(importAttribute);
                        }
                }

                for (GluuAttribute attribute : this.attributes) {
                        if (!addedAttributes.contains(attribute.getName())) {
                                ImportAttribute importAttribute = new ImportAttribute(-1, attribute);
                                importAttributes.add(importAttribute);
                        }
                }

                return importAttributes;
        }

getAttributesString()

String org.gluu.oxtrust.action.PersonImportAction.getAttributesString ( List< GluuAttribute >  attributes )

inlineprivate

                                                                           {
                StringBuilder sb = new StringBuilder();

                for (Iterator<GluuAttribute> iterator = attributes.iterator(); iterator.hasNext();) {
                        GluuAttribute attribute = iterator.next();
                        sb.append('\'').append(attribute.getDisplayName()).append('\'');
                        if (!attribute.isRequred()) {
                                sb.append(" (non mandatory)");
                        }
                        if (iterator.hasNext()) {
                                sb.append(", ");
                        }

                }

                return sb.toString();
        }

getFileDataToImport()

FileDataToImport org.gluu.oxtrust.action.PersonImportAction.getFileDataToImport ( )

inline

                                                      {
                return this.fileDataToImport;
        }

getMandatoryAttributes()

List<GluuAttribute> org.gluu.oxtrust.action.PersonImportAction.getMandatoryAttributes ( List< GluuAttribute >  attributes )

inlineprivate

                                                                                           {
                List<GluuAttribute> result = new ArrayList<GluuAttribute>();
                for (GluuAttribute attribute : attributes) {
                        if (attribute.isRequred()) {
                                result.add(attribute);
                        }
                }

                return result;
        }

getMandatoryImportAttributes()

List<ImportAttribute> org.gluu.oxtrust.action.PersonImportAction.getMandatoryImportAttributes ( List< ImportAttribute >  importAttributes )

inlineprivate

                                                                                                           {
                List<ImportAttribute> result = new ArrayList<ImportAttribute>();
                for (ImportAttribute importAttribute : importAttributes) {
                        if ((importAttribute.getCol() != -1) && importAttribute.getAttribute().isRequred()) {
                                result.add(importAttribute);
                        }
                }

                return result;
        }

getTypedValue()

String org.gluu.oxtrust.action.PersonImportAction.getTypedValue ( GluuAttribute  attribute, String  value  )

inlineprivate

                                                                            {
                if (AttributeDataType.STRING.equals(attribute.getDataType())) {
                        return value;
                } else if (AttributeDataType.BOOLEAN.equals(attribute.getDataType())) {
                        GluuBoolean gluuBoolean = GluuBoolean.getByValue(value);
                        if (gluuBoolean != null) {
                                return GluuBoolean.getByValue(value).toString();
                        }
                }

                return null;
        }

getUploadedFile()

UploadedFile org.gluu.oxtrust.action.PersonImportAction.getUploadedFile ( )

inline

                                              {
                return uploadedFile;
        }

importPersons()

String org.gluu.oxtrust.action.PersonImportAction.importPersons ( ) throws Exception

inline

                                                       {
                if (!fileDataToImport.isReady()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "File to import is invalid");
                        return OxTrustConstants.RESULT_FAILURE;
                }

                log.info("Attempting to add {} persons", fileDataToImport.getPersons().size());
                try {
                        for (GluuCustomPerson person : fileDataToImport.getPersons()) {

                                this.person = person;
                                String result = initializePerson();
                                if (result.equals(OxTrustConstants.RESULT_SUCCESS)) {
                                        result = save();
                                }
                                if (result.equals(OxTrustConstants.RESULT_SUCCESS)) {
                                        log.debug("Added new person: {}", person.getUid());
                                } else {
                                        log.debug("Failed to add new person: {}", person.getUid());
                                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new person: '%s'", person.getUid());
                                }
                        }
                } catch (EntryPersistenceException ex) {
                        log.error("Failed to add new person", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to import users");

                        return OxTrustConstants.RESULT_FAILURE;
                }

                log.info("All {} persons added successfully", fileDataToImport.getPersons().size());
                oxTrustAuditService.audit(fileDataToImport.getPersons().size()+ " USERS IMPORTED ",
                                identity.getUser(),
                                (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest());
                facesMessages.add(FacesMessage.SEVERITY_INFO, "Users successfully imported");

                removeFileToImport();

                return OxTrustConstants.RESULT_SUCCESS;
        }

init()

String org.gluu.oxtrust.action.PersonImportAction.init ( )

inline

                             {
                if (this.isInitialized) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                this.attributes = importPersonConfiguration.getAttributes();
                this.attributesDisplayNameMap = getAttributesDisplayNameMap(this.attributes);

                this.fileDataToImport = new FileDataToImport();

                this.isInitialized = true;

                return OxTrustConstants.RESULT_SUCCESS;
        }

initAttributes()

void org.gluu.oxtrust.action.PersonImportAction.initAttributes ( )

inlineprivate

                                      {
                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());
                }
        }

initializePerson()

String org.gluu.oxtrust.action.PersonImportAction.initializePerson ( )

inline

                                         {
                if (!organizationService.isAllowPersonModification()) {
                        return OxTrustConstants.RESULT_FAILURE;
                }

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

                initAttributes();

                return OxTrustConstants.RESULT_SUCCESS;
        }

prepareAndValidateImportData()

boolean org.gluu.oxtrust.action.PersonImportAction.prepareAndValidateImportData ( Table  table, List< ImportAttribute >  importAttributes  ) throws Exception

inlineprivate

                                                                                                                           {
                String attributesString = getAttributesString(this.attributes);
                if ((table == null) || (importAttributes == null)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Import failed. Missing columns: %s", attributesString);
                        return false;
                }

                List<GluuAttribute> mandatoryAttributes = getMandatoryAttributes(this.attributes);
                List<ImportAttribute> mandatoryImportAttributes = getMandatoryImportAttributes(importAttributes);
                if (mandatoryAttributes.size() != mandatoryImportAttributes.size()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Import failed. Required columns: %s", attributesString);
                        return false;
                }

                if (table.getCountRows() < 1) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Import failed. No data found");
                        return false;
                }

                // Convert Excel table to GluuCustomPersons
                List<GluuCustomPerson> persons = convertTableToPersons(table, importAttributes);
                if (persons == null) {
                        return false;
                }

                // Check if person already exist
                if (!validatePersons(persons)) {
                        return false;
                }

                // Fill persons with default values
                if (!setDefaultPersonAttributes(persons, importAttributes)) {
                        return false;
                }

                // Store persons
                log.info("Prepared {} persons for creation", persons.size());
                this.fileDataToImport.setPersons(persons);

                return true;
        }

removeFileDataToImport()

void org.gluu.oxtrust.action.PersonImportAction.removeFileDataToImport ( )

inline

                                             {
                this.fileDataToImport.reset();
        }

removeFileToImport()

void org.gluu.oxtrust.action.PersonImportAction.removeFileToImport ( )

inline

                                         {
                if (uploadedFile != null) {
                        try {
                                uploadedFile.delete();
                        } catch (IOException ex) {
                                log.error("Failed to remove temporary file", ex);
                        }

                        this.uploadedFile = null;
                }
                removeFileDataToImport();
        }

save()

String org.gluu.oxtrust.action.PersonImportAction.save ( )

inline

                             {
                if (!organizationService.isAllowPersonModification()) {
                        return OxTrustConstants.RESULT_FAILURE;
                }

                personService.addCustomObjectClass(this.person);

                if (personService.getPersonByUid(this.person.getUid()) != null) {
                        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);

                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 {
                        boolean runScript = externalUpdateUserService.isEnabled();
                        if (runScript) {
                                externalUpdateUserService.executeExternalAddUserMethods(this.person);
                        }

                        personService.addPerson(this.person);

                        if (runScript) {
                                externalUpdateUserService.executeExternalPostAddUserMethods(this.person);
                        }
                } catch (Exception ex) {
                        log.error("Failed to add new person {}", this.person.getInum(), ex);

                        return OxTrustConstants.RESULT_FAILURE;
                }
                return OxTrustConstants.RESULT_SUCCESS;
        }

setDefaultPersonAttributes()

boolean org.gluu.oxtrust.action.PersonImportAction.setDefaultPersonAttributes ( List< GluuCustomPerson >  persons, List< ImportAttribute >  importAttributes  ) throws Exception

inlineprivate

                                         {
                boolean isGeneratePassword = false;
                for (ImportAttribute importAttribute : importAttributes) {
                        if (importAttribute.getAttribute().getName().equalsIgnoreCase(PERSON_PASSWORD_ATTRIBUTE)
                                        && !importAttribute.getAttribute().isRequred()) {
                                isGeneratePassword = true;
                                break;
                        }
                }

                for (GluuCustomPerson person : persons) {
                        if (StringHelper.isEmpty(person.getCommonName())) {
                                person.setCommonName(person.getGivenName() + " " + person.getSurname());
                        } else {
                                person.setCommonName(person.getCommonName() + " " + person.getGivenName() + " " + person.getSurname());
                        }
                        person.setDisplayName(person.getCommonName());

                        String iname = personService.generateInameForNewPerson(person.getUid());
                        person.setIname(iname);

                        if (isGeneratePassword && StringHelper.isEmpty(person.getUserPassword())) {
                                person.setUserPassword(RandomStringUtils.randomAlphanumeric(16));
                        }

                }

                return true;
        }

uploadFile()

void org.gluu.oxtrust.action.PersonImportAction.uploadFile ( FileUploadEvent  event )

inline

                                                      {
                removeFileToImport();

                this.uploadedFile = event.getUploadedFile();
                this.fileData = this.uploadedFile.getData();
        }

validateFileToImport()

String org.gluu.oxtrust.action.PersonImportAction.validateFileToImport ( )

inline

                                             {
                try {
                        removeFileDataToImport();

                        if (uploadedFile == null) {
                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        Table table;
                        InputStream is = new ByteArrayInputStream(this.fileData);
                        try {
                                table = excelService.read(is);
                        } finally {
                                IOUtils.closeQuietly(is);
                        }

                        this.fileDataToImport.setTable(table);

                        if (table != null) {
                                this.fileDataToImport.setFileName(FilenameUtils.getName(uploadedFile.getName()));
                                this.fileDataToImport.setImportAttributes(getAttributesForImport(table));
                                this.fileDataToImport.setReady(true);
                        }

                        if (this.fileDataToImport.isReady()) {
                                boolean valid = prepareAndValidateImportData(this.fileDataToImport.getTable(),
                                                this.fileDataToImport.getImportAttributes());
                                this.fileDataToImport.setReady(valid);

                                if (!valid) {
                                        removeFileDataToImport();
                                }
                        }
                        return OxTrustConstants.RESULT_SUCCESS;
                }catch (Exception e) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Invalid file content");
                        
                        log.error(e.getMessage());
                        return OxTrustConstants.RESULT_FAILURE;
                }
                
        }

validatePersons()

boolean org.gluu.oxtrust.action.PersonImportAction.validatePersons ( List< GluuCustomPerson >  persons ) throws Exception

inlineprivate

                                                                                         {
                Set<String> uids = new HashSet<String>();
                Set<String> mails = new HashSet<String>();
                for (GluuCustomPerson person : persons) {
                        uids.add(person.getUid());
                        mails.add(person.getMail());
                }

                if (uids.size() != persons.size()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Import failed. There are persons with simular uid(s) in input file");
                        return false;
                }

                if (mails.size() != persons.size()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Import failed. There are persons with simular mail(s) in input file");
                        return false;
                }

                List<GluuCustomPerson> existPersons = personService.findPersonsByUids(new ArrayList<String>(uids),
                                PERSON_IMPORT_PERSON_LOCKUP_RETURN_ATTRIBUTES);
                if (existPersons.size() > 0) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Import failed. There are persons with existing uid(s): %s",
                                        personService.getPersonUids(existPersons));
                        return false;
                }

                List<GluuCustomPerson> existEmailPersons = personService.findPersonsByMailids(new ArrayList<String>(mails),
                                PERSON_IMPORT_PERSON_LOCKUP_RETURN_ATTRIBUTES);
                if (existEmailPersons.size() > 0) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Import failed. There are persons with existing mailid(s): %s",
                                        personService.getPersonMailids(existEmailPersons));
                        return false;
                }

                return true;
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.PersonImportAction.appConfiguration

private

attributes

List<GluuAttribute> org.gluu.oxtrust.action.PersonImportAction.attributes

private

attributesDisplayNameMap

Map<String, GluuAttribute> org.gluu.oxtrust.action.PersonImportAction.attributesDisplayNameMap

private

attributeService

AttributeService org.gluu.oxtrust.action.PersonImportAction.attributeService

private

conversationService

ConversationService org.gluu.oxtrust.action.PersonImportAction.conversationService

private

customAttributeAction

CustomAttributeAction org.gluu.oxtrust.action.PersonImportAction.customAttributeAction

private

excelService

ExcelService org.gluu.oxtrust.action.PersonImportAction.excelService

private

externalUpdateUserService

ExternalUpdateUserService org.gluu.oxtrust.action.PersonImportAction.externalUpdateUserService

private

facesMessages

FacesMessages org.gluu.oxtrust.action.PersonImportAction.facesMessages

private

fileData

byte [] org.gluu.oxtrust.action.PersonImportAction.fileData

private

fileDataToImport

FileDataToImport org.gluu.oxtrust.action.PersonImportAction.fileDataToImport

private

identity

Identity org.gluu.oxtrust.action.PersonImportAction.identity

private

importPersonConfiguration

transient ImportPersonConfiguration org.gluu.oxtrust.action.PersonImportAction.importPersonConfiguration

private

inum

String org.gluu.oxtrust.action.PersonImportAction.inum

private

isInitialized

boolean org.gluu.oxtrust.action.PersonImportAction.isInitialized

private

log

Logger org.gluu.oxtrust.action.PersonImportAction.log

private

organizationService

OrganizationService org.gluu.oxtrust.action.PersonImportAction.organizationService

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.PersonImportAction.oxTrustAuditService

private

person

GluuCustomPerson org.gluu.oxtrust.action.PersonImportAction.person

private

PERSON_IMPORT_PERSON_LOCKUP_RETURN_ATTRIBUTES

final String [] org.gluu.oxtrust.action.PersonImportAction.PERSON_IMPORT_PERSON_LOCKUP_RETURN_ATTRIBUTES = { "uid", "displayName", "mail" }

staticprivate

PERSON_PASSWORD_ATTRIBUTE

final String org.gluu.oxtrust.action.PersonImportAction.PERSON_PASSWORD_ATTRIBUTE = "userPassword"

static

personService

IPersonService org.gluu.oxtrust.action.PersonImportAction.personService

private

serialVersionUID

final long org.gluu.oxtrust.action.PersonImportAction.serialVersionUID = -1270460481895022468L

staticprivate

uploadedFile

UploadedFile org.gluu.oxtrust.action.PersonImportAction.uploadedFile

private

---

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

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