Java ObjectUtils.isNull方法代码示例

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public boolean isSuperUserAuthorized() {
    String docId = this.getDocId();
    if (StringUtils.isBlank(docId) || ObjectUtils.isNull(docTypeName)) {
        return false;
    }

    DocumentType documentType = KewApiServiceLocator.getDocumentTypeService().getDocumentTypeByName(docTypeName);
    String docTypeId = null;
    if (documentType != null) {
        docTypeId = documentType.getId();
    }
    String principalId =  GlobalVariables.getUserSession().getPrincipalId();
    if ( KewApiServiceLocator.getDocumentTypeService().isSuperUserForDocumentTypeId(principalId, docTypeId) ) {
        return true;
    }
    List<RouteNodeInstance> routeNodeInstances= KewApiServiceLocator.getWorkflowDocumentService().getRouteNodeInstances(
            docId);
    String documentStatus =  KewApiServiceLocator.getWorkflowDocumentService().getDocumentStatus(docId).getCode();
    return ((KewApiServiceLocator.getDocumentTypeService().canSuperUserApproveSingleActionRequest(
                principalId, this.getDocTypeName(), routeNodeInstances, documentStatus)) ||
            (KewApiServiceLocator.getDocumentTypeService().canSuperUserApproveDocument(
                principalId, this.getDocTypeName(), routeNodeInstances, documentStatus)) ||
            (KewApiServiceLocator.getDocumentTypeService().canSuperUserDisapproveDocument (
                principalId, this.getDocTypeName(), routeNodeInstances, documentStatus))) ;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public String getActionRequestedValue(){
    if (ObjectUtils.isNull(actionRequestCds)) {
        actionRequestCds = CodeTranslator.arLabels;
    } else {
        actionRequestCds.clear();
        actionRequestCds.putAll(CodeTranslator.arLabels);
    }
    if(getActionRequested() != null && !getActionRequested().trim().equals("")){
        return (String) actionRequestCds.get(getActionRequested());
    }
    return null;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
@Override
@Deprecated
public void validateBusinessObject(Object businessObject, boolean validateRequired) {
    if (ObjectUtils.isNull(businessObject)) {
        return;
    }
    try {
        // validate the primitive attributes of the bo
        validatePrimitivesFromDescriptors(businessObject.getClass().getName(), businessObject,
                PropertyUtils.getPropertyDescriptors(businessObject.getClass()), "", validateRequired);
    } catch (RuntimeException e) {
        LOG.error(String.format("Exception while validating %s", businessObject.getClass().getName()), e);
        throw e;
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public Object getPropertyByPath(Object object, String path) {
    if (object instanceof Collection) return getPropertyOfCollectionByPath((Collection)object, path);

    final String[] splitPath = headAndTailPath(path);
    final String head = splitPath[0];
    final String tail = splitPath[1];
    
    if (object instanceof PersistableBusinessObject && tail != null) {
        if (getBusinessObjectMetaDataService().getBusinessObjectRelationship((BusinessObject) object, head) != null) {
            ((PersistableBusinessObject)object).refreshReferenceObject(head);

        }
    }
    final Object headValue = ObjectUtils.getPropertyValue(object, head);
    if (!ObjectUtils.isNull(headValue)) {
        if (tail == null) {
            return headValue;
        } else {
            // we've still got path left...
            if (headValue instanceof Collection) {
                // oh dear, a collection; we've got to loop through this
                Collection values = makeNewCollectionOfSameType((Collection)headValue);
                for (Object currentElement : (Collection)headValue) {
                    flatAdd(values, getPropertyByPath(currentElement, tail));
                }
                return values;
            } else {
                return getPropertyByPath(headValue, tail);
            }
        }
    }
    return null;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 * This overridden method checks whether the user is an admin user according to {@link PessimisticLockService#isPessimisticLockAdminUser(Person)} and if the user is not an admin user the user field is set to Read Only and the lookup field
 *
 * @see org.kuali.rice.krad.lookup.AbstractLookupableHelperServiceImpl#getRows()
 */
@Override
public List<Row> getRows() {
    Person currentUser = GlobalVariables.getUserSession().getPerson();
    if (KRADServiceLocatorWeb.getPessimisticLockService().isPessimisticLockAdminUser(currentUser)) {
        return super.getRows();
    } else {
        if ( (ObjectUtils.isNull(localRows)) || localRows.isEmpty() ) {
            List<Field> fieldList = new ArrayList<Field>();
            int numColumns = -1;
            // hide a field and forcibly set a field
            for (Iterator<Row> iterator = super.getRows().iterator(); iterator.hasNext();) {
                Row row = (Row) iterator.next();
                if (numColumns == -1) {
                	numColumns = row.getFields().size();
                }
                for (Iterator<Field> iterator2 = row.getFields().iterator(); iterator2.hasNext();) {
                    Field field = (Field) iterator2.next();
                    if (!(KRADPropertyConstants.OWNED_BY_USER + "." + KIMPropertyConstants.Person.PRINCIPAL_NAME).equals(field.getPropertyName()) &&
                    		!Field.BLANK_SPACE.equals(field.getFieldType())) {
                        fieldList.add(field);
                    }
                }
            }
            // Since the removed field is the first one in the list, use FieldUtils to re-wrap the remaining fields accordingly.
            localRows = FieldUtils.wrapFields(fieldList, numColumns);
        }
        return localRows;
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 * Used to create a NaturalLanguageTemplate in the database for testing.
 *
 * @param namespace of the KRMS Type which may be created
 * @param langCode  The two character code of applicable language
 * @param nlObjectName  Seed value to create unique Template and Usage records
 * @param template The text of the template for the Template record
 * @param nlUsage NaturalLanguateUsageId for the Template record
 *
 * @return {@link NaturalLanguageTemplate} for the created Template
 */
protected NaturalLanguageTemplate createTestNaturalLanguageTemplate(String namespace, String langCode,
        String nlObjectName, String template, String nlUsage, boolean createIdFromLangCodeAndNlObjectName) {
    KrmsTypeDefinition  krmsType = createKrmsTypeDefinition(null, namespace, nlObjectName, null);

    // create NaturalLanguageUsage if it does not exist
    if (ObjectUtils.isNull(ruleManagementService.getNaturalLanguageUsage(nlUsage))) {
        NaturalLanguageUsage.Builder naturalLanguageUsageBuilder =  NaturalLanguageUsage.Builder.create(nlObjectName,namespace );
        naturalLanguageUsageBuilder.setId(nlUsage);
        naturalLanguageUsageBuilder.setDescription("Description-" + nlObjectName);
        naturalLanguageUsageBuilder.setActive(true);
        NaturalLanguageUsage naturalLangumageUsage =  ruleManagementService.createNaturalLanguageUsage(naturalLanguageUsageBuilder.build());
    }

    // create  NaturalLanguageTemplate attributes if they don't exist
    createTestKrmsAttribute(langCode + "_" + nlObjectName + "Attribute1",  nlObjectName + "TemplateAttributeName1", namespace);
    createTestKrmsAttribute(langCode + "_" + nlObjectName + "Attribute2",  nlObjectName + "TemplateAttributeName2", namespace);
    Map<String, String> nlAttributes = new HashMap<String, String>();
    nlAttributes.put( nlObjectName + "TemplateAttributeName1","value1");
    nlAttributes.put( nlObjectName + "TemplateAttributeName2","value2");

    // create NaturalLanguageTemplate
    String naturalLanguageUsageId = nlUsage;
    String typeId = krmsType.getId();
    NaturalLanguageTemplate.Builder naturalLanguageTemplateBuilder = NaturalLanguageTemplate.Builder.create(
            langCode, naturalLanguageUsageId, template, typeId);
    naturalLanguageTemplateBuilder.setActive(true);
    if (createIdFromLangCodeAndNlObjectName) {
        naturalLanguageTemplateBuilder.setId(langCode + "-" + nlObjectName);
    }
    naturalLanguageTemplateBuilder.setAttributes(nlAttributes);

    return ruleManagementService.createNaturalLanguageTemplate(naturalLanguageTemplateBuilder.build());
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 *  createTestKrmsAttribute create KrmsAttribute in the database
 *
 * @param id
 * @param name
 * @param namespace
 *
 * @return {@link KrmsAttributeDefinition}
 */
protected KrmsAttributeDefinition createTestKrmsAttribute(String id, String name, String namespace) {
    // if the AttributeDefinition does not exist, create it

    if (ObjectUtils.isNull(krmsAttributeDefinitionService.getAttributeDefinitionById(id))) {
        KrmsAttributeDefinition.Builder krmsAttributeDefinitionBuilder = KrmsAttributeDefinition.Builder.create(id, name, namespace);
        KrmsAttributeDefinition  krmsAttributeDefinition = krmsAttributeDefinitionService.createAttributeDefinition(krmsAttributeDefinitionBuilder.build());
    }

    return krmsAttributeDefinitionService.getAttributeDefinitionById(id);
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 * Setup workflow doc in the document.
 */
@Override
public void populate(HttpServletRequest request) {
    super.populate(request);

    WorkflowDocument workflowDocument = null;

    if (hasDocumentId()) {
        // populate workflowDocument in documentHeader, if needed
    	// KULRICE-4444 Obtain Document Header using the Workflow Service to minimize overhead
        try {
            workflowDocument = UserSessionUtils.getWorkflowDocument(GlobalVariables.getUserSession(), getDocument().getDocumentNumber());
            if ( workflowDocument == null)
     	 	{
                // gets the workflow document from doc service, doc service will also set the workflow document in the
                // user's session
                Person person = GlobalVariables.getUserSession().getPerson();
                if (ObjectUtils.isNull(person)) {
                    person = KimApiServiceLocator.getPersonService().getPersonByPrincipalName(KRADConstants.SYSTEM_USER);
                }
     	 		workflowDocument = KRADServiceLocatorWeb.getWorkflowDocumentService().loadWorkflowDocument(getDocument().getDocumentNumber(), person);
     	 	 	UserSessionUtils.addWorkflowDocument(GlobalVariables.getUserSession(), workflowDocument);
     	 	 	if (workflowDocument == null)
     	 	 	{
     	 	 		throw new WorkflowException("Unable to retrieve workflow document # " + getDocument().getDocumentNumber() + " from workflow document service createWorkflowDocument");
     	 	 	}
     	 	 	else
     	 	 	{
     	 	 	LOG.debug("Retrieved workflow Document ID: " + workflowDocument.getDocumentId());
     	 	 	}
     	 	}

            getDocument().getDocumentHeader().setWorkflowDocument(workflowDocument);
        } catch (WorkflowException e) {
            LOG.warn("Error while instantiating workflowDoc", e);
            throw new RuntimeException("error populating documentHeader.workflowDocument", e);
        }
    } 
    if (workflowDocument != null) {
     //Populate Document Header attributes
     populateHeaderFields(workflowDocument);
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public static RemotableAttributeField convertFieldToAttributeField(Field field) {
    RemotableAttributeField.Builder builder = RemotableAttributeField.Builder.create(field.getPropertyName());

    List<RemotableAbstractWidget.Builder> widgets = new ArrayList<RemotableAbstractWidget.Builder>();
    builder.setDataType(DataType.valueOf(field.getFieldDataType().toUpperCase()));
    builder.setShortLabel(field.getFieldLabel());
    builder.setLongLabel(field.getMainFieldLabel());
    builder.setHelpSummary(field.getFieldHelpSummary());
    //builder.setConstraintText(field.)
    //builder.setHelpDescription();
    builder.setForceUpperCase(field.isUpperCase());
    //builder.setMinLength()
    if (field.getMaxLength() > 0) {
        builder.setMaxLength(new Integer(field.getMaxLength()));
    } else {
        builder.setMaxLength(new Integer(100));
    }
    //builder.setMinValue();
    //builder.setMaxValue();
    //builder.setRegexConstraint(field.);
    //builder.setRegexContraintMsg();
    builder.setRequired(field.isFieldRequired());
    builder.setDefaultValues(Collections.singletonList(field.getDefaultValue()));
    builder.setControl(FieldUtils.constructControl(field, field.getFieldValidValues()));
    if (field.getHasLookupable()) {
        builder.setAttributeLookupSettings(RemotableAttributeLookupSettings.Builder.create());
        RemotableQuickFinder.Builder quickfinder =
                RemotableQuickFinder.Builder.create(field.getBaseLookupUrl(), field.getQuickFinderClassNameImpl());
        quickfinder.setFieldConversions(toMap(field.getFieldConversions()));
        quickfinder.setLookupParameters(toMap(field.getLookupParameters()));
        widgets.add(quickfinder);
    }
    RemotableAttributeLookupSettings.Builder lookupSettings = null;
    if (builder.getDataType().equals(DataType.DATETIME)
            || builder.getDataType().equals(DataType.DATE)) {
        if (field.isRanged()) {
            lookupSettings = RemotableAttributeLookupSettings.Builder.create();
            lookupSettings.setRanged(field.isRanged());
            if (field.isDatePicker()) {
                lookupSettings.setLowerDatePicker(Boolean.TRUE);
                lookupSettings.setUpperDatePicker(Boolean.TRUE);
            }
            if (ObjectUtils.isNull(field.getRangeFieldInclusive())) {
                lookupSettings.setUpperBoundInclusive(true);
                lookupSettings.setLowerBoundInclusive(true);
            }
        }
    }

    if (!field.isColumnVisible()) {
        if (ObjectUtils.isNull(lookupSettings)) {
            lookupSettings = RemotableAttributeLookupSettings.Builder.create();
        }
        lookupSettings.setInResults(field.isColumnVisible());
    }

    if (ObjectUtils.isNotNull(lookupSettings)) {
        builder.setAttributeLookupSettings(lookupSettings);
    }

    if (field.getFieldType().equals(Field.CURRENCY)) {
        builder.setDataType(DataType.CURRENCY);
        builder.setMaxLength(field.getFormattedMaxLength());
    }
    if (field.isDatePicker()) {
        widgets.add(RemotableDatepicker.Builder.create());
    }
    if (field.isExpandedTextArea()) {
        widgets.add(RemotableTextExpand.Builder.create());
    }
    builder.setWidgets(widgets);

    return builder.build();
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
@Override
public boolean isNull(Object object){
     return ObjectUtils.isNull(object);
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 *
 * @see org.kuali.rice.kim.service.UiDocumentService#loadEntityToPersonDoc(IdentityManagementPersonDocument, String)
 */
@Override
   public void loadEntityToPersonDoc(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId) {
	Principal principal = this.getIdentityService().getPrincipal(principalId);
       Entity kimEntity = null;

       if(ObjectUtils.isNotNull(principal)) {
           // If the principal is not null it was found in the identity management service
           kimEntity = this.getIdentityService().getEntity(principal.getEntityId());
       }

       if(ObjectUtils.isNull(principal) || ObjectUtils.isNull(kimEntity)) {
           // If the principal or entity is null look up the entity in the
           // archive service, and then get the principal from it
           IdentityArchiveService identityArchive = getIdentityArchiveService();
           EntityDefault entityInfo = identityArchive.getEntityDefaultFromArchiveByPrincipalId(principalId);
           principal = entityInfo.getPrincipals().get(0);
           Entity.Builder eb  = Entity.Builder.create();
           eb.setId(entityInfo.getEntityId());
           kimEntity = eb.build();

       }
       if(kimEntity == null) {
           throw new RuntimeException("Entity does not exist for principal id: " + principalId);
       }
       if(principal==null) {
       	throw new RuntimeException("Principal does not exist for principal id:"+principalId);
       }

       identityManagementPersonDocument.setPrincipalId(principal.getPrincipalId());
       identityManagementPersonDocument.setPrincipalName(principal.getPrincipalName());
       //identityManagementPersonDocument.setPassword(principal.getPassword());
       identityManagementPersonDocument.setActive(principal.isActive());
	identityManagementPersonDocument.setEntityId(kimEntity.getId());
	if ( ObjectUtils.isNotNull( kimEntity.getPrivacyPreferences() ) ) {
		identityManagementPersonDocument.setPrivacy(loadPrivacyReferences(kimEntity.getPrivacyPreferences()));
	}
	//identityManagementPersonDocument.setActive(kimEntity.isActive());
	identityManagementPersonDocument.setAffiliations(loadAffiliations(kimEntity.getAffiliations(),kimEntity.getEmploymentInformation()));
	identityManagementPersonDocument.setNames(loadNames( identityManagementPersonDocument, principalId, kimEntity.getNames(), identityManagementPersonDocument.getPrivacy().isSuppressName() ));
	EntityTypeContactInfo entityType = null;
	for (EntityTypeContactInfo type : kimEntity.getEntityTypeContactInfos()) {
		if (KimConstants.EntityTypes.PERSON.equals(type.getEntityTypeCode())) {
			entityType = EntityTypeContactInfo.Builder.create(type).build();
		}
	}

	if(entityType!=null){
		identityManagementPersonDocument.setEmails(loadEmails(identityManagementPersonDocument, principalId, entityType.getEmailAddresses(), identityManagementPersonDocument.getPrivacy().isSuppressEmail()));
		identityManagementPersonDocument.setPhones(loadPhones(identityManagementPersonDocument, principalId, entityType.getPhoneNumbers(), identityManagementPersonDocument.getPrivacy().isSuppressPhone()));
		identityManagementPersonDocument.setAddrs(loadAddresses(identityManagementPersonDocument, principalId, entityType.getAddresses(), identityManagementPersonDocument.getPrivacy().isSuppressAddress()));
	}

	List<Group> groups = getGroupService().getGroups(getGroupService().getDirectGroupIdsByPrincipalId(
               identityManagementPersonDocument.getPrincipalId()));
	loadGroupToPersonDoc(identityManagementPersonDocument, groups);
	loadRoleToPersonDoc(identityManagementPersonDocument);
	loadDelegationsToPersonDoc(identityManagementPersonDocument);
}