Java ObjectUtils.isNotNull方法代码示例

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public boolean isStateAllowsApproveOrDisapprove() {
    if(this.getDocument().getDocumentHeader().hasWorkflowDocument()) {
        DocumentStatus status = null;
        WorkflowDocument document = WorkflowDocumentFactory.loadDocument(GlobalVariables.getUserSession().getPrincipalId(),
            this.getDocument().getDocumentHeader().getWorkflowDocument().getDocumentId());
        if (ObjectUtils.isNotNull(document)) {
            status = document.getStatus();
        } else {
            status = this.getDocument().getDocumentHeader().getWorkflowDocument().getStatus();
        }
        return !(isStateProcessedOrDisapproved(status) ||
                 isStateInitiatedFinalCancelled(status) ||
                 StringUtils.equals(status.getCode(), DocumentStatus.SAVED.getCode()));
    } else {
        return false;
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public void checkPermission() throws AuthorizationException {
    if (ObjectUtils.isNotNull(businessObjectEntry)) {
        String componentName = businessObjectEntry.getBusinessObjectClass().getName();
        String nameSpaceCode = "KR-NS";
        String templateName = "Export Records";
        String principalId = GlobalVariables.getUserSession().getPrincipalId();
        String principalUserName = GlobalVariables.getUserSession().getPrincipalName();
        Map<String, String> permissionDetails = new HashMap<String, String>();
        permissionDetails.put("componentName", componentName);
        boolean isAuthorized = KimApiServiceLocator.getPermissionService().isAuthorizedByTemplate(principalId, nameSpaceCode,
                templateName, permissionDetails, new HashMap<String, String>());
        if (!isAuthorized) {
            throw new AuthorizationException(principalUserName, "Exporting the LookUp Results", componentName);
        }
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
public List<DelegateTypeBo> getPersonDelegations(String principalId){
	if(principalId==null) {
		return new ArrayList<DelegateTypeBo>();
       }
	List<DelegateMemberBo> delegationMembers =
       		getDataObjectService().findMatching(DelegateMemberBo.class, QueryByCriteria.Builder.fromPredicates(
       		        PredicateFactory.equal(KimConstants.PrimaryKeyConstants.MEMBER_ID, principalId),
       		        PredicateFactory.equal(KIMPropertyConstants.DelegationMember.MEMBER_TYPE_CODE, MemberType.PRINCIPAL.getCode()))).getResults();
	List<DelegateTypeBo> delegations = new ArrayList<DelegateTypeBo>();
	List<String> delegationIds = new ArrayList<String>();
	if(ObjectUtils.isNotNull(delegationMembers)){
		for(DelegateMemberBo delegationMember: delegationMembers){
			if( delegationMember.getDelegationId() != null && !delegationIds.contains(delegationMember.getDelegationId())){
				delegationIds.add(delegationMember.getDelegationId());
				delegations.add(getDataObjectService().find(DelegateTypeBo.class, delegationMember.getDelegationId()));
			}
		}
	}
	return delegations;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(List<RoleMemberBo> newRoleMembersList){
	List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
	if(ObjectUtils.isNotNull(newRoleMembersList)){
		for(RoleMemberBo roleMember: newRoleMembersList){
		    if ( roleMember.getRoleRspActions() != null ) {
		        roleRspActions.addAll(roleMember.getRoleRspActions());
		    }
		}
	}
	return roleRspActions;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List <RoleResponsibilityActionBo> populateRoleRspActions(IdentityManagementPersonDocument identityManagementPersonDocument) {
//		List<RoleImpl> origRoles = getRolesForPrincipal(identityManagementPersonDocument.getPrincipalId());

		List <RoleResponsibilityActionBo>  roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
		if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getRoles())){
			for (PersonDocumentRole role : identityManagementPersonDocument.getRoles()) {
				if(CollectionUtils.isNotEmpty(role.getRolePrncpls())){
					for (KimDocumentRoleMember roleMbr : role.getRolePrncpls()) {
						if(CollectionUtils.isNotEmpty(roleMbr.getRoleRspActions())){
							for (KimDocumentRoleResponsibilityAction roleRspAction : roleMbr.getRoleRspActions()) {
								RoleResponsibilityActionBo entRoleRspAction = new RoleResponsibilityActionBo();
								entRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
								entRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
								entRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
								entRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
								entRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
								entRoleRspAction.setRoleResponsibilityId(roleRspAction.getRoleResponsibilityId());
								List<RoleResponsibilityActionBo> actions = getRoleRspActions( roleMbr.getRoleMemberId());
								if(ObjectUtils.isNotNull(actions)){
									for(RoleResponsibilityActionBo orgRspAction : actions) {
										if (orgRspAction.getId()!=null && StringUtils.equals(orgRspAction.getId(), roleRspAction.getRoleResponsibilityActionId())) {
											entRoleRspAction.setVersionNumber(orgRspAction.getVersionNumber());
										}
									}
								}
								roleRspActions.add(entRoleRspAction);
							}
						}
					}
				}
			}
		}
		return roleRspActions;

	}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List<PersonDocumentAddress> loadAddresses(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId, List<EntityAddress> entityAddresses, boolean suppressDisplay ) {
	List<PersonDocumentAddress> docAddresses = new ArrayList<PersonDocumentAddress>();
	if(ObjectUtils.isNotNull(entityAddresses)){
		for (EntityAddress address: entityAddresses) {
			if(address.isActive()){
				PersonDocumentAddress docAddress = new PersonDocumentAddress();
				docAddress.setEntityTypeCode(address.getEntityTypeCode());
				docAddress.setAddressTypeCode(address.getAddressType().getCode());

				//We do not need to check the privacy setting here - The UI should care of it
				docAddress.setLine1(address.getLine1Unmasked());
				docAddress.setLine2(address.getLine2Unmasked());
				docAddress.setLine3(address.getLine3Unmasked());
				docAddress.setStateProvinceCode(address.getStateProvinceCodeUnmasked());
				docAddress.setPostalCode(address.getPostalCodeUnmasked());
				docAddress.setCountryCode(address.getCountryCodeUnmasked());
				docAddress.setCity(address.getCityUnmasked());

				docAddress.setActive(address.isActive());
				docAddress.setDflt(address.isDefaultValue());
				docAddress.setEntityAddressId(address.getId());
				docAddress.setEdit(true);
				docAddresses.add(docAddress);
			}
		}
	}
	return docAddresses;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 * @param dataObjectEntry if collectionItemBusinessObject is not null, then it is the DD entry for collectionItemBusinessObject.
 * Otherwise, it is the entry for primaryBusinessObject
 * @param primaryDataObject the top-level BO that is being inquiried or maintained
 * @param collectionItemBusinessObject an element of a collection under the primaryBusinessObject that we are evaluating view auths for
 * @param user the logged in user
 * @param businessObjectAuthorizer
 * @param inquiryOrMaintenanceDocumentRestrictions
 * @param propertyPrefix
 */
protected void considerBusinessObjectFieldModifyAuthorization(
		DataObjectEntry dataObjectEntry,
		Object primaryDataObject,
		BusinessObject collectionItemBusinessObject, Person user,
		BusinessObjectAuthorizer businessObjectAuthorizer,
		MaintenanceDocumentRestrictions maintenanceDocumentRestrictions,
		String propertyPrefix) {
	for (String attributeName : dataObjectEntry.getAttributeNames()) {
		AttributeDefinition attributeDefinition = dataObjectEntry
				.getAttributeDefinition(attributeName);
		if (attributeDefinition.getAttributeSecurity() != null) {
			Map<String, String> collectionItemPermissionDetails = new HashMap<String, String>();
			Map<String, String> collectionItemRoleQualifications = null;
			if (ObjectUtils.isNotNull(collectionItemBusinessObject)) {
				collectionItemPermissionDetails.putAll(getFieldPermissionDetails(collectionItemBusinessObject, attributeName));
				collectionItemPermissionDetails.putAll(businessObjectAuthorizer.
						getCollectionItemPermissionDetails(collectionItemBusinessObject));
				collectionItemRoleQualifications = new HashMap<String, String>(businessObjectAuthorizer.
						getCollectionItemRoleQualifications(collectionItemBusinessObject));
			}
			else {
				collectionItemPermissionDetails.putAll(getFieldPermissionDetails(primaryDataObject, attributeName));
			}
			if (attributeDefinition.getAttributeSecurity().isReadOnly()) {
				if (!businessObjectAuthorizer
							.isAuthorizedByTemplate(
									primaryDataObject,
									KRADConstants.KNS_NAMESPACE,
									KimConstants.PermissionTemplateNames.MODIFY_FIELD,
									user.getPrincipalId(),
									collectionItemPermissionDetails,
									collectionItemRoleQualifications)) {
					maintenanceDocumentRestrictions
							.addReadOnlyField(propertyPrefix + attributeName);
				}
			}
		}
	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
 * Aardvarks values out of a business object and puts them into an Map<String, String>, based on a List of paths
 * @param businessObject the business object to get values from
 * @param paths the paths of values to get from the qualifier
 * @param routingAttributes the RoutingAttribute associated with this qualifier's document value
 * @param qualifier the qualifier to put values into
 */
protected void addPathValuesToQualifier(Object businessObject, List<String> paths, RoutingAttributeTracker routingAttributes, Map<String, String> qualifier) {
    if (ObjectUtils.isNotNull(paths)) {
        for (String path : paths) {
            // get the values for the paths of each element of the collection
            final Object value = getPropertyByPath(businessObject, path.trim());
            if (value != null) {
                qualifier.put(routingAttributes.getCurrentRoutingAttribute().getQualificationAttributeName(), value.toString());
            }
            routingAttributes.moveToNext();
        }
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected void setupPhone(IdentityManagementPersonDocument identityManagementPersonDocument, EntityTypeContactInfoBo entityType, List<EntityPhoneBo> origPhones) {
   	if ( !identityManagementPersonDocument.getPrivacy().isSuppressPhone() || canOverrideEntityPrivacyPreferences(getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId()) ) {
		List<EntityPhoneBo> entityPhones = new ArrayList<EntityPhoneBo>();
		if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getPhones())){
			for (PersonDocumentPhone phone : identityManagementPersonDocument.getPhones()) {
				EntityPhoneBo entityPhone = new EntityPhoneBo();
				entityPhone.setPhoneTypeCode(phone.getPhoneTypeCode());
                   if (phone.getPhoneType() != null) {
                       entityPhone.setPhoneType(phone.getPhoneType());
                   } else {
                       if (StringUtils.isNotEmpty(phone.getPhoneTypeCode())) {
                           entityPhone.setPhoneType(EntityPhoneTypeBo
                                   .from(getIdentityService().getAddressType(phone.getPhoneTypeCode())));
                       }
                   }
				entityPhone.setEntityId(identityManagementPersonDocument.getEntityId());
				entityPhone.setId(phone.getEntityPhoneId());
				entityPhone.setEntityTypeCode(entityType.getEntityTypeCode());
				entityPhone.setPhoneNumber(phone.getPhoneNumber());
				entityPhone.setCountryCode(phone.getCountryCode());
				entityPhone.setExtensionNumber(phone.getExtensionNumber());
				entityPhone.setActive(phone.isActive());
				entityPhone.setDefaultValue(phone.isDflt());
				if(ObjectUtils.isNotNull(origPhones)){
					for (EntityPhoneContract origPhone : origPhones) {
						if (origPhone.getId()!=null && StringUtils.equals(origPhone.getId(), entityPhone.getId())) {
							entityPhone.setVersionNumber(origPhone.getVersionNumber());
						}
					}
				}
				entityPhone.setId(phone.getEntityPhoneId());
				entityPhones.add(entityPhone);
			}
		}
		entityType.setPhoneNumbers(entityPhones);
   	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
/**
   * Selects a {@link RoleBoLite} for passed {@link RoleMemberBo} and adds to List of {@link PersonDocumentRole} objects
   *
   * @param docRoles a list of {@link PersonDocumentRole} roles
   * @param roleIds a list of the Ids of the Roles already added
   * @param member a {@link RoleMemberBo} of a {@link RoleBoLite}
* @param roleMembers a list of {@link RoleMemberBo} membership objects for the PrincipalId
   */
  private void loadDocRoles(List <PersonDocumentRole> docRoles, List<String> roleIds,  RoleMemberBo member, List<RoleMemberBo> roleMembers) {

      // get the RoleBoLite object by it's Id from a role membership object
      RoleBoLite role =  getDataObjectService().find(RoleBoLite.class, member.getRoleId());

// create list of RoleMemberBo's for the same role
List<RoleMemberBo> matchingMembers = new ArrayList<RoleMemberBo>();
for (RoleMemberBo tempMember : roleMembers) {
	if (tempMember.getRoleId().equals(member.getRoleId())){
		matchingMembers.add(tempMember);
	}
}

      // if not already found add role to docRoles
      if (ObjectUtils.isNotNull(role) && !roleIds.contains(role.getId())) {
          PersonDocumentRole docRole = new PersonDocumentRole();
          docRole.setKimTypeId(role.getKimTypeId());
          docRole.setActive(role.isActive());
          docRole.setNamespaceCode(role.getNamespaceCode());
          docRole.setEdit(true);
          docRole.setRoleId(role.getId());
          docRole.setRoleName(role.getName());
	docRole.setRolePrncpls(populateDocRolePrncpl(role.getNamespaceCode(), matchingMembers, member.getMemberId(), getAttributeDefinitionsForRole(docRole)));
          docRoles.add(docRole);
          roleIds.add(role.getId());
      }
  }
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected void setupName(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity, List<EntityNameBo> origNames) {
   	if ( !identityManagementPersonDocument.getPrivacy().isSuppressName() ||
   			canOverrideEntityPrivacyPreferences( getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId() ) ) {
    	List<EntityNameBo> entityNames = new ArrayList<EntityNameBo>();
		if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getNames())){
			for (PersonDocumentName name : identityManagementPersonDocument.getNames()) {
			    EntityNameBo entityName = new EntityNameBo();
				entityName.setNameCode(name.getNameCode());
                   if (name.getEntityNameType() != null) {
                       entityName.setNameType(name.getEntityNameType());
                   } else {
                       if (StringUtils.isNotEmpty(name.getNameCode())) {
                           entityName.setNameType(
                                   EntityNameTypeBo.from(getIdentityService().getNameType(name.getNameCode())));
                       }
                   }
				entityName.setFirstName(name.getFirstName());
				entityName.setLastName(name.getLastName());
				entityName.setMiddleName(name.getMiddleName());
				entityName.setNamePrefix(name.getNamePrefix());
				entityName.setNameSuffix(name.getNameSuffix());
				entityName.setActive(name.isActive());
				entityName.setDefaultValue(name.isDflt());
				entityName.setId(name.getEntityNameId());
				entityName.setEntityId(identityManagementPersonDocument.getEntityId());
				if(ObjectUtils.isNotNull(origNames)){
					for (EntityNameBo origName : origNames) {
						if (origName.getId()!=null && StringUtils.equals(origName.getId(), entityName.getId())) {
							entityName.setVersionNumber(origName.getVersionNumber());
						}

					}
				}
				entityNames.add(entityName);
			}
		}
		kimEntity.setNames(entityNames);
   	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected void setupPrivacy(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity, EntityPrivacyPreferencesBo origPrivacy) {
	EntityPrivacyPreferencesBo privacyPreferences = new EntityPrivacyPreferencesBo();
	privacyPreferences.setEntityId(identityManagementPersonDocument.getEntityId());
	privacyPreferences.setSuppressAddress(identityManagementPersonDocument.getPrivacy().isSuppressAddress());
	privacyPreferences.setSuppressEmail(identityManagementPersonDocument.getPrivacy().isSuppressEmail());
	privacyPreferences.setSuppressName(identityManagementPersonDocument.getPrivacy().isSuppressName());
	privacyPreferences.setSuppressPhone(identityManagementPersonDocument.getPrivacy().isSuppressPhone());
	privacyPreferences.setSuppressPersonal(identityManagementPersonDocument.getPrivacy().isSuppressPersonal());
	if (ObjectUtils.isNotNull(origPrivacy)) {
		privacyPreferences.setVersionNumber(origPrivacy.getVersionNumber());
           privacyPreferences.setObjectId(origPrivacy.getObjectId());
	}
	kimEntity.setPrivacyPreferences(privacyPreferences);
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List<PersonDocumentName> loadNames( IdentityManagementPersonDocument personDoc, String principalId, List <EntityName> names, boolean suppressDisplay ) {
	List<PersonDocumentName> docNames = new ArrayList<PersonDocumentName>();
	if(ObjectUtils.isNotNull(names)){
		for (EntityName name: names) {
			if(name.isActive()){
				PersonDocumentName docName = new PersonDocumentName();
                   if (name.getNameType() != null) {
				    docName.setNameCode(name.getNameType().getCode());
                   }

				//We do not need to check the privacy setting here - The UI should care of it
				docName.setFirstName(name.getFirstNameUnmasked());
				docName.setLastName(name.getLastNameUnmasked());
				docName.setMiddleName(name.getMiddleNameUnmasked());
				docName.setNamePrefix(name.getNamePrefixUnmasked());
				docName.setNameSuffix(name.getNameSuffixUnmasked());

				docName.setActive(name.isActive());
				docName.setDflt(name.isDefaultValue());
				docName.setEdit(true);
				docName.setEntityNameId(name.getId());
				docNames.add(docName);
			}
		}
	}
	return docNames;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List<PersonDocumentPhone> loadPhones(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId, List<EntityPhone> entityPhones, boolean suppressDisplay ) {
	List<PersonDocumentPhone> docPhones = new ArrayList<PersonDocumentPhone>();
	if(ObjectUtils.isNotNull(entityPhones)){
		for (EntityPhone phone: entityPhones) {
			if(phone.isActive()){
				PersonDocumentPhone docPhone = new PersonDocumentPhone();
                   if (phone.getPhoneType() != null) {
				    docPhone.setPhoneTypeCode(phone.getPhoneType().getCode());
                   }
				//docPhone.setPhoneType(((KimEntityPhoneImpl)phone).getPhoneType());
				docPhone.setEntityTypeCode(phone.getEntityTypeCode());
				//We do not need to check the privacy setting here - The UI should care of it
				docPhone.setPhoneNumber(phone.getPhoneNumberUnmasked());
				docPhone.setCountryCode(phone.getCountryCodeUnmasked());
				docPhone.setExtensionNumber(phone.getExtensionNumberUnmasked());

				docPhone.setActive(phone.isActive());
				docPhone.setDflt(phone.isDefaultValue());
				docPhone.setEntityPhoneId(phone.getId());
				docPhone.setEdit(true);
				docPhones.add(docPhone);
			}
		}
	}
	return docPhones;

}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入方法依赖的package包/类
protected List <GroupMemberBo> populateGroupMembers(IdentityManagementPersonDocument identityManagementPersonDocument) {
		List <GroupMemberBo>  groupPrincipals = new ArrayList<GroupMemberBo>();
//		List<? extends Group> origGroups = getGroupService().getGroupsByPrincipalId(identityManagementPersonDocument.getPrincipalId());
		if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getGroups())){
			for (PersonDocumentGroup group : identityManagementPersonDocument.getGroups()) {
				GroupMember.Builder groupPrincipalImpl = GroupMember.Builder.create(group.getGroupId(), identityManagementPersonDocument.getPrincipalId(), KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
				if (group.getActiveFromDate() != null) {
					groupPrincipalImpl.setActiveFromDate(new DateTime(group.getActiveFromDate().getTime()));
				}
				if (group.getActiveToDate() != null) {
					groupPrincipalImpl.setActiveToDate(new DateTime(group.getActiveToDate().getTime()));
				}
				groupPrincipalImpl.setId(group.getGroupMemberId());


                //groupPrincipalImpl.setVersionNumber(group.getVersionNumber());
				// get the ORM-layer optimisic locking value
				// TODO: this should be replaced with the retrieval and storage of that value
				// in the document tables and not re-retrieved here
				Collection<GroupMember> currGroupMembers = getGroupService().getMembers(Collections.singletonList(group.getGroupId()));
				if(ObjectUtils.isNotNull(currGroupMembers)){
					for (GroupMember origGroupMember: currGroupMembers) {
                        if (origGroupMember.isActive(new DateTime(System.currentTimeMillis()))
                            && KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE.equals(origGroupMember.getType())) {
                            if(origGroupMember.getId()!=null && StringUtils.equals(origGroupMember.getId(), group.getGroupMemberId())){
                                groupPrincipalImpl.setObjectId(origGroupMember.getObjectId());
                                groupPrincipalImpl.setVersionNumber(origGroupMember.getVersionNumber());
                            }
                        }
					}
				}

				groupPrincipals.add(GroupMemberBo.from(groupPrincipalImpl.build()));

			}
		}
		return groupPrincipals;
	}