import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
@Test
   /**
    * tests that various properties of the business object extension are of the expected Java Class
    */
public void testObjectUtils_getPropertyType() throws Exception {
	Account ta = new Account();
assertEquals("physical property type mismatch", PersistableBusinessObjectExtension.class, PropertyUtils
	.getPropertyType(ta, "extension"));
assertEquals("DD property type mismatch", AccountExtension.class, ObjectUtils.getPropertyType(ta, "extension",
           KNSServiceLocator.getPersistenceStructureService()));
assertEquals("extension.accountType attribute class mismatch", AccountType.class, ObjectUtils.getPropertyType(
	ta, "extension.accountType", KNSServiceLocator.getPersistenceStructureService()));
assertEquals("extension.accountType.codeAndDescription attribute class mismatch", String.class, ObjectUtils
	.getPropertyType(ta, "extension.accountType.codeAndDescription", KNSServiceLocator
		.getPersistenceStructureService()));
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * Updates fields of type kualiuser sets the universal user id and/or name if required. 
 * 
 * @param field
 * @param businessObject
 */
private static final void updateUserFields(Field field, BusinessObject businessObject){
    // for user fields, attempt to pull the principal ID and person's name from the source object
    if ( field.getFieldType().equals(Field.KUALIUSER) ) {
        // this is supplemental, so catch and log any errors
        try {
            if ( StringUtils.isNotBlank(field.getUniversalIdAttributeName()) ) {
                Object principalId = ObjectUtils.getNestedValue(businessObject, field.getUniversalIdAttributeName());
                if ( principalId != null ) {
                    field.setUniversalIdValue(principalId.toString());
                }
            }
            if ( StringUtils.isNotBlank(field.getPersonNameAttributeName()) ) {
                Object personName = ObjectUtils.getNestedValue(businessObject, field.getPersonNameAttributeName());
                if ( personName != null ) {
                    field.setPersonNameValue( personName.toString() );
                }
            }
        } catch ( Exception ex ) {
            LOG.warn( "Unable to get principal ID or person name property in SectionBridge.", ex );
        }
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * Delegates to {@link PropertyUtils#getPropertyType(Object, String)}to look up the property type for the provided keypath.
 * Caches the resulting class so that subsequent lookups for the same keypath can be satisfied by looking in the cache.
 *
 * @throws NoSuchMethodException
 * @throws InvocationTargetException
 * @throws IllegalAccessException
 */
protected Class getPropertyType(String keypath) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Map propertyTypes = (Map) classCache.get(getClass());
    if (propertyTypes == null) {
        propertyTypes = new HashMap();
        classCache.put(getClass(), propertyTypes);
    }

    // if type has not been retrieve previousely, use ObjectUtils to get type
    if (!propertyTypes.containsKey(keypath)) {
        Class type = ObjectUtils.easyGetPropertyType(this, keypath);
        propertyTypes.put(keypath, type);
    }

    Class propertyType = (Class) propertyTypes.get(keypath);
    return propertyType;
}
 

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 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包/类
/**
   * Retrieves a value from the form for the purposes of passing it as a parameter into the lookup or inquiry frameworks 
   * 
   * @param parameterName the name of the parameter, as expected by the lookup or inquiry frameworks
   * @param parameterValueLocation the name of the property containing the value of the parameter
   * @return the value of the parameter
   */
  public String retrieveFormValueForLookupInquiryParameters(String parameterName, String parameterValueLocation) {
  	// dereference literal values by simply trimming of the prefix
  	if (parameterValueLocation.startsWith(literalPrefixAndDelimiter)) {
  		return parameterValueLocation.substring(literalPrefixAndDelimiter.length());
  	}

  	Object value = ObjectUtils.getPropertyValue(this, parameterValueLocation);
if (value == null) {
	return null;
}
if (value instanceof String) {
	return (String) value;
}
Formatter formatter = Formatter.getFormatter(value.getClass());
return (String) formatter.format(value);	
  }
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
protected void copyParametersToBO(Map<String, String> parameters, PersistableBusinessObject newBO) throws Exception{
	for (String parmName : parameters.keySet()) {
		String propertyValue = parameters.get(parmName);

		if (StringUtils.isNotBlank(propertyValue)) {
			String propertyName = parmName;
			// set value of property in bo
			if (PropertyUtils.isWriteable(newBO, propertyName)) {
				Class type = ObjectUtils.easyGetPropertyType(newBO, propertyName);
				if (type != null && Formatter.getFormatter(type) != null) {
					Formatter formatter = Formatter.getFormatter(type);
					Object obj = formatter.convertFromPresentationFormat(propertyValue);
					ObjectUtils.setObjectProperty(newBO, propertyName, obj.getClass(), obj);
				}
				else {
					ObjectUtils.setObjectProperty(newBO, propertyName, String.class, propertyValue);
				}
			}
		}
	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * This method clears the value of the primary key fields on a Business Object.
 * 
 * @param document - document to clear the pk fields on
 */
   protected void clearPrimaryKeyFields(MaintenanceDocument document) {
	// get business object being maintained and its keys
	PersistableBusinessObject bo = document.getNewMaintainableObject().getBusinessObject();
	List<String> keyFieldNames = KRADServiceLocatorWeb.getLegacyDataAdapter().listPrimaryKeyFieldNames(bo.getClass());

	for (String keyFieldName : keyFieldNames) {
		try {
			ObjectUtils.setObjectProperty(bo, keyFieldName, null);
		}
		catch (Exception e) {
			LOG.error("Unable to clear primary key field: " + e.getMessage());
			throw new RuntimeException("Unable to clear primary key field: " + e.getMessage());
		}
	}
       bo.setObjectId(null);
       bo.setVersionNumber(new Long(1));
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
@Deprecated
protected AnchorHtmlData getInquiryUrlForPrimaryKeys(Class clazz, Object businessObject, List<String> primaryKeys,
		String displayText) {
	if (businessObject == null)
		return new AnchorHtmlData(KRADConstants.EMPTY_STRING, KRADConstants.EMPTY_STRING);

	Properties parameters = new Properties();
	parameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, KRADConstants.START_METHOD);
	parameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, clazz.getName());

	String titleAttributeValue;
	Map<String, String> fieldList = new HashMap<String, String>();
	for (String primaryKey : primaryKeys) {
		titleAttributeValue = (String) ObjectUtils.getPropertyValue(businessObject, primaryKey);
		parameters.put(primaryKey, titleAttributeValue);
		fieldList.put(primaryKey, titleAttributeValue);
	}
	if (StringUtils.isEmpty(displayText))
		return getHyperLink(clazz, fieldList, UrlFactory.parameterizeUrl(KRADConstants.INQUIRY_ACTION, parameters));
	else
		return getHyperLink(clazz, fieldList, UrlFactory.parameterizeUrl(KRADConstants.INQUIRY_ACTION, parameters),
				displayText);
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
protected List<RemotableAttributeError> validatePrimitiveFromDescriptor(String kimTypeId, String entryName, Object object, PropertyDescriptor propertyDescriptor) {
    List<RemotableAttributeError> errors = new ArrayList<RemotableAttributeError>();
    // validate the primitive attributes if defined in the dictionary
    if (null != propertyDescriptor && getDataDictionaryService().isAttributeDefined(entryName, propertyDescriptor.getName())) {
        Object value = ObjectUtils.getPropertyValue(object, propertyDescriptor.getName());
        Class<?> propertyType = propertyDescriptor.getPropertyType();

        if (TypeUtils.isStringClass(propertyType) || TypeUtils.isIntegralClass(propertyType) || TypeUtils.isDecimalClass(propertyType) || TypeUtils.isTemporalClass(propertyType)) {

            // check value format against dictionary
            if (value != null && StringUtils.isNotBlank(value.toString())) {
                if (!TypeUtils.isTemporalClass(propertyType)) {
                    errors.addAll(validateAttributeFormat(kimTypeId, entryName, propertyDescriptor.getName(), value.toString(), propertyDescriptor.getName()));
                }
            }
            else {
            	// if it's blank, then we check whether the attribute should be required
                errors.addAll(validateAttributeRequired(kimTypeId, entryName, propertyDescriptor.getName(), value, propertyDescriptor.getName()));
            }
        }
    }
    return errors;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * This method validates that there should only exist one entry in the collection whose
 * fields match the fields specified within the duplicateIdentificationFields in the
 * maintenance document data dictionary.
 * If the duplicateIdentificationFields is not specified in the DD, by default it would
 * allow the addition to happen and return true.
 * It will return false if it fails the uniqueness validation.
 *
 * @param document
 * @param collectionName
 * @param bo
 * @return
 */
protected boolean validateDuplicateIdentifierInDataDictionary(MaintenanceDocument document, String collectionName,
        PersistableBusinessObject bo) {
    boolean valid = true;
    Object maintBo = document.getNewMaintainableObject().getDataObject();
    Collection maintCollection = (Collection) ObjectUtils.getPropertyValue(maintBo, collectionName);
    List<String> duplicateIdentifier = document.getNewMaintainableObject()
            .getDuplicateIdentifierFieldsFromDataDictionary(
                    document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName(), collectionName);
    if (duplicateIdentifier.size() > 0) {
        List<String> existingIdentifierString = document.getNewMaintainableObject()
                .getMultiValueIdentifierList(maintCollection, duplicateIdentifier);
        if (document.getNewMaintainableObject()
                .hasBusinessObjectExisted(bo, existingIdentifierString, duplicateIdentifier)) {
            valid = false;
            GlobalVariables.getMessageMap()
                    .putError(duplicateIdentifier.get(0), RiceKeyConstants.ERROR_DUPLICATE_ELEMENT, "entries in ",
                            document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName());
        }
    }
    return valid;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
protected void setNewCollectionLineDefaultValues(String collectionName, PersistableBusinessObject addLine) {
	PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(addLine);
	for (int i = 0; i < descriptors.length; ++i) {
		PropertyDescriptor propertyDescriptor = descriptors[i];

		String fieldName = propertyDescriptor.getName();
		Class propertyType = propertyDescriptor.getPropertyType();
		String value = getMaintenanceDocumentDictionaryService().getCollectionFieldDefaultValue(getDocumentTypeName(),
				collectionName, fieldName);

		if (value != null) {
			try {
				ObjectUtils.setObjectProperty(addLine, fieldName, propertyType, value);
			}
			catch (Exception ex) {
				LOG.error("Unable to set default property of collection object: " + "\nobject: " + addLine
						+ "\nfieldName=" + fieldName + "\npropertyType=" + propertyType + "\nvalue=" + value, ex);
			}
		}

	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
protected void clearCollectionRestrictedValues(String fieldNamePrefix, BusinessObject businessObject,
		MaintainableCollectionDefinition collectionDefinition,
		MaintenanceDocumentRestrictions maintenanceDocumentRestrictions) {
	String collectionName = fieldNamePrefix + collectionDefinition.getName();
	Collection<BusinessObject> collection = (Collection<BusinessObject>) ObjectUtils.getPropertyValue(
			businessObject, collectionDefinition.getName());

	if (collection != null) {
		int i = 0;
		// even though it's technically a Collection, we're going to index
		// it like a list
		for (BusinessObject collectionItem : collection) {
			String collectionItemNamePrefix = collectionName + "[" + i + "].";
			for (MaintainableCollectionDefinition subCollectionDefinition : collectionDefinition
					.getMaintainableCollections()) {
				clearCollectionRestrictedValues(collectionItemNamePrefix, collectionItem, subCollectionDefinition,
						maintenanceDocumentRestrictions);
			}
			for (MaintainableFieldDefinition fieldDefinition : collectionDefinition.getMaintainableFields()) {
				clearFieldRestrictedValues(collectionItemNamePrefix, collectionItem, fieldDefinition,
						maintenanceDocumentRestrictions);
			}
			i++;
		}
	}
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
protected void performCollectionForceUpperCase(String fieldNamePrefix, BusinessObject bo,
		MaintainableCollectionDefinition collectionDefinition, Map fieldValues) {
	String collectionName = fieldNamePrefix + collectionDefinition.getName();
	Collection<BusinessObject> collection = (Collection<BusinessObject>) ObjectUtils.getPropertyValue(bo,
			collectionDefinition.getName());
	if (collection != null) {
		int i = 0;
		// even though it's technically a Collection, we're going to index
		// it like a list
		for (BusinessObject collectionItem : collection) {
			String collectionItemNamePrefix = collectionName + "[" + i + "].";
			// String collectionItemNamePrefix = "";
			for (MaintainableFieldDefinition fieldDefinition : collectionDefinition.getMaintainableFields()) {
				performFieldForceUpperCase(collectionItemNamePrefix, collectionItem, fieldDefinition, fieldValues);
			}
			for (MaintainableCollectionDefinition subCollectionDefinition : collectionDefinition
					.getMaintainableCollections()) {
				performCollectionForceUpperCase(collectionItemNamePrefix, collectionItem, subCollectionDefinition,
						fieldValues);
			}
			i++;
		}
	}
}
 

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 static String getFullyMaskedValue(String className, String fieldName, Object formObject, String propertyName) {
	String displayMaskValue = null;
	Object propertyValue = ObjectUtils.getPropertyValue(formObject, propertyName);

	DataDictionaryEntryBase entry = (DataDictionaryEntryBase) KRADServiceLocatorWeb.getDataDictionaryService()
			.getDataDictionary().getDictionaryObjectEntry(className);
	AttributeDefinition a = entry.getAttributeDefinition(fieldName);

	AttributeSecurity attributeSecurity = a.getAttributeSecurity();
	if (attributeSecurity != null && attributeSecurity.isMask()) {
		MaskFormatter maskFormatter = attributeSecurity.getMaskFormatter();
		displayMaskValue = maskFormatter.maskValue(propertyValue);

	}
	return displayMaskValue;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
public static String getPartiallyMaskedValue(String className, String fieldName, Object formObject,
		String propertyName) {
	String displayMaskValue = null;
	Object propertyValue = ObjectUtils.getPropertyValue(formObject, propertyName);

	DataDictionaryEntryBase entry = (DataDictionaryEntryBase) KRADServiceLocatorWeb.getDataDictionaryService()
			.getDataDictionary().getDictionaryObjectEntry(className);
	AttributeDefinition a = entry.getAttributeDefinition(fieldName);

	AttributeSecurity attributeSecurity = a.getAttributeSecurity();
	if (attributeSecurity != null && attributeSecurity.isPartialMask()) {
		MaskFormatter partialMaskFormatter = attributeSecurity.getPartialMaskFormatter();
		displayMaskValue = partialMaskFormatter.maskValue(propertyValue);

	}
	return displayMaskValue;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * @param bo
 * @param propertyName
 * @return true if one (or more) of the intermediate objects in the given propertyName is null
 */
private static boolean containsIntermediateNull(Object bo, String propertyName) {
    boolean containsNull = false;

    if (StringUtils.contains(propertyName, ".")) {
        String prefix = StringUtils.substringBefore(propertyName, ".");
        Object propertyValue = ObjectUtils.getPropertyValue(bo, prefix);

        if (propertyValue == null) {
            containsNull = true;
        }
        else {
            String suffix = StringUtils.substringAfter(propertyName, ".");
            containsNull = containsIntermediateNull(propertyValue, suffix);
        }
    }

    return containsNull;
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
/**
 * Adds to the criteria object based on query characters given
 */
private void addStringRangeCriteria(String propertyName, String propertyValue, Criteria criteria) {

    try {
        if (StringUtils.contains(propertyValue, SearchOperator.BETWEEN.op())) {
            String[] rangeValues = StringUtils.split(propertyValue, SearchOperator.BETWEEN.op());
            if (rangeValues.length < 2)
                throw new IllegalArgumentException("Improper syntax of BETWEEN operator in " + propertyName);

            criteria.addBetween(propertyName, rangeValues[0], rangeValues[1]);
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN_EQUAL.op())) {
            criteria.addGreaterOrEqualThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN_EQUAL.op())) {
            criteria.addLessOrEqualThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN.op())) {
            criteria.addGreaterThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN.op())) {
            criteria.addLessThan(propertyName, ObjectUtils.clean(propertyValue));
        } else {
            criteria.addEqualTo(propertyName, ObjectUtils.clean(propertyValue));
        }
    } catch (IllegalArgumentException ex) {
        GlobalVariables.getMessageMap().putError("lookupCriteria[" + propertyName + "]", RiceKeyConstants.ERROR_BETWEEN_SYNTAX, propertyName);
    }
}
 

import org.kuali.rice.krad.util.ObjectUtils; //导入依赖的package包/类
private Object getReferenceFKValue(Object persistableObject, ObjectReferenceDescriptor chkRefCld, String fkName) {
    ClassDescriptor classDescriptor = getClassDescriptor(persistableObject.getClass());
    Object referenceObject = ObjectUtils.getPropertyValue(persistableObject, chkRefCld.getAttributeName());

    if (referenceObject == null) {
        return null;
    }

    FieldDescriptor[] refFkNames = chkRefCld.getForeignKeyFieldDescriptors(classDescriptor);
    ClassDescriptor refCld = getClassDescriptor(chkRefCld.getItemClass());
    FieldDescriptor[] refPkNames = refCld.getPkFields();


    Object fkValue = null;
    for (int i = 0; i < refFkNames.length; i++) {
        FieldDescriptor fkField = refFkNames[i];

        if (fkField.getAttributeName().equals(fkName)) {
            fkValue = ObjectUtils.getPropertyValue(referenceObject, refPkNames[i].getAttributeName());
            break;
        }
    }

    return fkValue;
}