下面列出了org.springframework.beans.PropertyAccessorUtils#isNestedOrIndexedProperty ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private boolean isPersonProperty(Object bo, String propertyName) {
try {
if (PropertyAccessorUtils.isNestedOrIndexedProperty( propertyName ) // is a nested property
&& !StringUtils.contains(propertyName, "add.") ) {// exclude add line properties (due to path parsing problems in PropertyUtils.getPropertyType)
int lastIndex = PropertyAccessorUtils.getLastNestedPropertySeparatorIndex(propertyName);
String propertyTypeName = lastIndex != -1 ? StringUtils.substring(propertyName, 0, lastIndex) : StringUtils.EMPTY;
Class<?> type = PropertyUtils.getPropertyType(bo, propertyTypeName);
// property type indicates a Person object
if ( type != null ) {
return Person.class.isAssignableFrom(type);
}
LOG.warn( "Unable to determine type of nested property: " + bo.getClass().getName() + " / " + propertyName );
}
} catch (Exception ex) {
if ( LOG.isDebugEnabled() ) {
LOG.debug("Unable to determine if property on " + bo.getClass().getName() + " to a person object: " + propertyName, ex );
}
}
return false;
}
@Override
public Map<String, String> getInquiryParameters(Object dataObject, List<String> keys, String propertyName) {
Map<String, String> inquiryParameters = new HashMap<String, String>();
org.kuali.rice.krad.data.metadata.DataObjectRelationship dataObjectRelationship = null;
DataObjectMetadata objectMetadata =
KRADServiceLocator.getDataObjectService().getMetadataRepository().getMetadata(dataObject.getClass());
if (objectMetadata != null) {
dataObjectRelationship = objectMetadata.getRelationshipByLastAttributeInRelationship(propertyName);
}
for (String keyName : keys) {
String keyConversion = keyName;
if (dataObjectRelationship != null) {
keyConversion = dataObjectRelationship.getParentAttributeNameRelatedToChildAttributeName(keyName);
} else if (PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName)) {
String nestedAttributePrefix = KRADUtils.getNestedAttributePrefix(propertyName);
keyConversion = nestedAttributePrefix + "." + keyName;
}
inquiryParameters.put(keyConversion, keyName);
}
return inquiryParameters;
}
/**
* Gets the property type for a property name.
*
* @param objectMetadata the metadata object.
* @param propertyName the name of the property.
* @return the property type for a property name.
*/
private Class<?> getPropertyTypeChild(DataObjectMetadata objectMetadata, String propertyName){
if(PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName)){
String attributePrefix = StringUtils.substringBefore(propertyName,".");
String attributeName = StringUtils.substringAfter(propertyName,".");
if(StringUtils.isNotBlank(attributePrefix) && StringUtils.isNotBlank(attributeName) &&
objectMetadata!= null){
Class<?> propertyType = traverseRelationship(objectMetadata,attributePrefix,attributeName);
if(propertyType != null){
return propertyType;
}
}
}
return getPropertyType(propertyName);
}
/**
* Gets the property type for a property name in a relationship.
*
* @param objectMetadata the metadata object.
* @param attributePrefix the prefix of the property that indicated it was in a relationship.
* @param attributeName the name of the property.
* @return the property type for a property name.
*/
private Class<?> traverseRelationship(DataObjectMetadata objectMetadata,String attributePrefix,
String attributeName){
DataObjectRelationship rd = objectMetadata.getRelationship(attributePrefix);
if(rd != null){
DataObjectMetadata relatedObjectMetadata =
dataObjectService.getMetadataRepository().getMetadata(rd.getRelatedType());
if(relatedObjectMetadata != null){
if(PropertyAccessorUtils.isNestedOrIndexedProperty(attributeName)){
return getPropertyTypeChild(relatedObjectMetadata,attributeName);
} else{
if(relatedObjectMetadata.getAttribute(attributeName) == null &&
relatedObjectMetadata.getRelationship(attributeName)!=null){
DataObjectRelationship relationship = relatedObjectMetadata.getRelationship(attributeName);
return relationship.getRelatedType();
}
return relatedObjectMetadata.getAttribute(attributeName).getDataType().getType();
}
}
}
return null;
}
@Override
public Map<String, String> getInquiryParameters(Object dataObject, List<String> keys, String propertyName) {
Map<String, String> inquiryParameters = new HashMap<String, String>();
Class<?> objectClass = ObjectUtils.materializeClassForProxiedObject(dataObject);
org.kuali.rice.krad.bo.DataObjectRelationship relationship =
dataObjectMetaDataService.getDataObjectRelationship(dataObject, objectClass, propertyName, "", true,
false, true);
for (String keyName : keys) {
String keyConversion = keyName;
if (relationship != null) {
keyConversion = relationship.getParentAttributeForChildAttribute(keyName);
} else if (PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName)) {
String nestedAttributePrefix = KRADUtils.getNestedAttributePrefix(propertyName);
keyConversion = nestedAttributePrefix + "." + keyName;
}
inquiryParameters.put(keyConversion, keyName);
}
return inquiryParameters;
}
/**
* {@inheritDoc}
*/
@Override
public void refreshReferences(String referencesToRefresh) {
Object model = ViewLifecycle.getModel();
for (String reference : StringUtils.split(referencesToRefresh, KRADConstants.REFERENCES_TO_REFRESH_SEPARATOR)) {
if (StringUtils.isBlank(reference)) {
continue;
}
//ToDo: handle add line
if (PropertyAccessorUtils.isNestedOrIndexedProperty(reference)) {
String parentPath = KRADUtils.getNestedAttributePrefix(reference);
Object parentObject = ObjectPropertyUtils.getPropertyValue(model, parentPath);
String referenceObjectName = KRADUtils.getNestedAttributePrimitive(reference);
if (parentObject == null) {
LOG.warn("Unable to refresh references for " + referencesToRefresh +
". Object not found in model. Nothing refreshed.");
continue;
}
refreshReference(parentObject, referenceObjectName);
} else {
refreshReference(model, reference);
}
}
}
/**
* @see org.kuali.rice.krad.service.DictionaryValidationService#validateReferenceExistsAndIsActive(java.lang.Object
* dataObject,
* String, String, String)
*/
@Override
public boolean validateReferenceExistsAndIsActive(Object dataObject, String referenceName,
String attributeToHighlightOnFail, String displayFieldName) {
// if we're dealing with a nested attribute, we need to resolve down to the BO where the primitive attribute is located
// this is primarily to deal with the case of a defaultExistenceCheck that uses an "extension", i.e referenceName
// would be extension.attributeName
if (PropertyAccessorUtils.isNestedOrIndexedProperty(referenceName)) {
String nestedAttributePrefix = KRADUtils.getNestedAttributePrefix(referenceName);
String nestedAttributePrimitive = KRADUtils.getNestedAttributePrimitive(referenceName);
Object nestedObject = KradDataServiceLocator.getDataObjectService().wrap(dataObject)
.getPropertyValueNullSafe(nestedAttributePrefix);
return validateReferenceExistsAndIsActive(nestedObject, nestedAttributePrimitive,
attributeToHighlightOnFail, displayFieldName);
}
boolean hasReferences = validateFkFieldsPopulated(dataObject, referenceName);
boolean referenceExists = hasReferences && validateReferenceExists(dataObject, referenceName);
boolean canIncludeActiveReference = referenceExists && (!(dataObject instanceof Inactivatable) ||
((Inactivatable) dataObject).isActive());
boolean referenceActive = canIncludeActiveReference && validateReferenceIsActive(dataObject, referenceName);
if(hasReferences && !referenceExists) {
GlobalVariables.getMessageMap().putError(attributeToHighlightOnFail, RiceKeyConstants.ERROR_EXISTENCE,
displayFieldName);
return false;
} else if(canIncludeActiveReference && !referenceActive) {
GlobalVariables.getMessageMap().putError(attributeToHighlightOnFail, RiceKeyConstants.ERROR_INACTIVE,
displayFieldName);
return false;
}
return true;
}
@Override
/**
* Recursively calls getPropertyTypeChild if nested property to allow it to properly look it up
*/
public Class<?> getPropertyType(Object object, String propertyName) {
DataObjectWrapper<?> wrappedObject = dataObjectService.wrap(object);
if (PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName)) {
return wrappedObject.getPropertyTypeNullSafe(wrappedObject.getWrappedClass(), propertyName);
}
return wrappedObject.getPropertyType(propertyName);
}
/**
* @see Inquirable#buildInquirableLink(java.lang.Object,
* java.lang.String, org.kuali.rice.krad.uif.widget.Inquiry)
*/
@Override
public void buildInquirableLink(Object dataObject, String propertyName, Inquiry inquiry) {
Class<?> inquiryObjectClass = null;
// inquiry into data object class if property is title attribute
Class<?> objectClass = KRADUtils.materializeClassForProxiedObject(dataObject);
if (propertyName.equals(KRADServiceLocatorWeb.getLegacyDataAdapter().getTitleAttribute(objectClass))) {
inquiryObjectClass = objectClass;
} else if (PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName)) {
String nestedPropertyName = KRADUtils.getNestedAttributePrefix(propertyName);
Object nestedPropertyObject = KRADUtils.getNestedValue(dataObject, nestedPropertyName);
if (KRADUtils.isNotNull(nestedPropertyObject)) {
String nestedPropertyPrimitive = KRADUtils.getNestedAttributePrimitive(propertyName);
Class<?> nestedPropertyObjectClass = KRADUtils.materializeClassForProxiedObject(nestedPropertyObject);
if (nestedPropertyPrimitive.equals(KRADServiceLocatorWeb.getLegacyDataAdapter().getTitleAttribute(
nestedPropertyObjectClass))) {
inquiryObjectClass = nestedPropertyObjectClass;
}
}
}
// if not title, then get primary relationship
if (inquiryObjectClass == null) {
inquiryObjectClass = getLegacyDataAdapter().getInquiryObjectClassIfNotTitle(dataObject,propertyName);
}
// if haven't found inquiry class, then no inquiry can be rendered
if (inquiryObjectClass == null) {
inquiry.setRender(false);
return;
}
if (DocumentHeader.class.isAssignableFrom(inquiryObjectClass)) {
String documentNumber = (String) KradDataServiceLocator.getDataObjectService().wrap(dataObject).getPropertyValueNullSafe(propertyName);
if (StringUtils.isNotBlank(documentNumber)) {
inquiry.getInquiryLink().setHref(getConfigurationService().getPropertyValueAsString(
KRADConstants.WORKFLOW_URL_KEY)
+ KRADConstants.DOCHANDLER_DO_URL
+ documentNumber
+ KRADConstants.DOCHANDLER_URL_CHUNK);
inquiry.getInquiryLink().setLinkText(documentNumber);
inquiry.setRender(true);
}
return;
}
synchronized (SUPER_CLASS_TRANSLATOR_LIST) {
for (Class<?> clazz : SUPER_CLASS_TRANSLATOR_LIST) {
if (clazz.isAssignableFrom(inquiryObjectClass)) {
inquiryObjectClass = clazz;
break;
}
}
}
if (!inquiryObjectClass.isInterface() && ExternalizableBusinessObject.class.isAssignableFrom(
inquiryObjectClass)) {
inquiryObjectClass = ExternalizableBusinessObjectUtils.determineExternalizableBusinessObjectSubInterface(
inquiryObjectClass);
}
// listPrimaryKeyFieldNames returns an unmodifiable list. So a copy is necessary.
List<String> keys = new ArrayList<String>(getLegacyDataAdapter().listPrimaryKeyFieldNames(
inquiryObjectClass));
if (keys == null) {
keys = Collections.emptyList();
}
// build inquiry parameter mappings
Map<String, String> inquiryParameters = getLegacyDataAdapter().getInquiryParameters(dataObject,keys,propertyName);
inquiry.buildInquiryLink(dataObject, propertyName, inquiryObjectClass, inquiryParameters);
}
@Override
public org.kuali.rice.krad.bo.DataObjectRelationship getDataObjectRelationship(Object dataObject,
Class<?> dataObjectClass, String attributeName, String attributePrefix, boolean keysOnly,
boolean supportsLookup, boolean supportsInquiry) {
RelationshipDefinition ddReference = getDictionaryRelationship(dataObjectClass, attributeName);
org.kuali.rice.krad.bo.DataObjectRelationship relationship = null;
DataObjectAttributeRelationship rel = null;
if (PropertyAccessorUtils.isNestedOrIndexedProperty(attributeName)) {
if (ddReference != null) {
if (classHasSupportedFeatures(ddReference.getTargetClass(), supportsLookup, supportsInquiry)) {
relationship = populateRelationshipFromDictionaryReference(dataObjectClass, ddReference,
attributePrefix, keysOnly);
return relationship;
}
}
if (dataObject == null) {
try {
dataObject = KRADUtils.createNewObjectFromClass(dataObjectClass);
} catch (RuntimeException e) {
// found interface or abstract class, just swallow exception and return a null relationship
return null;
}
}
// recurse down to the next object to find the relationship
int nextObjectIndex = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(attributeName);
if (nextObjectIndex == StringUtils.INDEX_NOT_FOUND) {
nextObjectIndex = attributeName.length();
}
String localPrefix = StringUtils.substring(attributeName, 0, nextObjectIndex);
String localAttributeName = StringUtils.substring(attributeName, nextObjectIndex + 1);
Object nestedObject = ObjectPropertyUtils.getPropertyValue(dataObject, localPrefix);
Class<?> nestedClass = null;
if (nestedObject == null) {
nestedClass = ObjectPropertyUtils.getPropertyType(dataObject, localPrefix);
} else {
nestedClass = nestedObject.getClass();
}
String fullPrefix = localPrefix;
if (StringUtils.isNotBlank(attributePrefix)) {
fullPrefix = attributePrefix + "." + localPrefix;
}
relationship = getDataObjectRelationship(nestedObject, nestedClass, localAttributeName, fullPrefix,
keysOnly, supportsLookup, supportsInquiry);
return relationship;
}
// non-nested reference, get persistence relationships first
int maxSize = Integer.MAX_VALUE;
if (isPersistable(dataObjectClass)) {
DataObjectMetadata metadata = dataObjectService.getMetadataRepository().getMetadata(dataObjectClass);
DataObjectRelationship dataObjectRelationship = metadata.getRelationship(attributeName);
if (dataObjectRelationship != null) {
List<DataObjectAttributeRelationship> attributeRelationships =
dataObjectRelationship.getAttributeRelationships();
for (DataObjectAttributeRelationship dataObjectAttributeRelationship : attributeRelationships) {
if (classHasSupportedFeatures(dataObjectRelationship.getRelatedType(), supportsLookup,
supportsInquiry)) {
maxSize = attributeRelationships.size();
relationship = transformToDeprecatedDataObjectRelationship(dataObjectClass, attributeName,
attributePrefix, dataObjectRelationship.getRelatedType(),
dataObjectAttributeRelationship);
break;
}
}
}
} else {
ModuleService moduleService = kualiModuleService.getResponsibleModuleService(dataObjectClass);
if (moduleService != null && moduleService.isExternalizable(dataObjectClass)) {
relationship = getRelationshipMetadata(dataObjectClass, attributeName, attributePrefix);
if ((relationship != null) && classHasSupportedFeatures(relationship.getRelatedClass(), supportsLookup,
supportsInquiry)) {
return relationship;
} else {
return null;
}
}
}
if (ddReference != null && ddReference.getPrimitiveAttributes().size() < maxSize) {
if (classHasSupportedFeatures(ddReference.getTargetClass(), supportsLookup, supportsInquiry)) {
relationship = populateRelationshipFromDictionaryReference(dataObjectClass, ddReference, null,
keysOnly);
}
}
return relationship;
}
protected DataObjectRelationship getDataObjectRelationship(RelationshipDefinition ddReference, Object dataObject,
Class<?> dataObjectClass, String attributeName, String attributePrefix, boolean keysOnly,
boolean supportsLookup, boolean supportsInquiry) {
DataObjectRelationship relationship = null;
// if it is nested then replace the data object and attributeName with the
// sub-refs
if (PropertyAccessorUtils.isNestedOrIndexedProperty(attributeName)) {
if (ddReference != null) {
if (classHasSupportedFeatures(ddReference.getTargetClass(), supportsLookup, supportsInquiry)) {
relationship = populateRelationshipFromDictionaryReference(dataObjectClass, ddReference,
attributePrefix, keysOnly);
return relationship;
}
}
// recurse down to the next object to find the relationship
String localPrefix = StringUtils.substringBefore(attributeName, ".");
String localAttributeName = StringUtils.substringAfter(attributeName, ".");
if (dataObject == null) {
try {
dataObject = KRADUtils.createNewObjectFromClass(dataObjectClass);
} catch (RuntimeException e) {
// found interface or abstract class, just swallow exception and return a null relationship
return null;
}
}
Object nestedObject = ObjectPropertyUtils.getPropertyValue(dataObject, localPrefix);
Class<?> nestedClass = null;
if (nestedObject == null) {
nestedClass = ObjectPropertyUtils.getPropertyType(dataObject, localPrefix);
} else {
nestedClass = nestedObject.getClass();
}
String fullPrefix = localPrefix;
if (StringUtils.isNotBlank(attributePrefix)) {
fullPrefix = attributePrefix + "." + localPrefix;
}
relationship = getDataObjectRelationship(nestedObject, nestedClass, localAttributeName, fullPrefix,
keysOnly, supportsLookup, supportsInquiry);
return relationship;
}
// non-nested reference, get persistence relationships first
int maxSize = Integer.MAX_VALUE;
// try persistable reference first
if (getPersistenceStructureService().isPersistable(dataObjectClass)) {
Map<String, DataObjectRelationship> rels = getPersistenceStructureService().getRelationshipMetadata(
dataObjectClass, attributeName, attributePrefix);
if (rels.size() > 0) {
for (DataObjectRelationship rel : rels.values()) {
if (rel.getParentToChildReferences().size() < maxSize) {
if (classHasSupportedFeatures(rel.getRelatedClass(), supportsLookup, supportsInquiry)) {
maxSize = rel.getParentToChildReferences().size();
relationship = rel;
}
}
}
}
} else {
ModuleService moduleService = getKualiModuleService().getResponsibleModuleService(dataObjectClass);
if (moduleService != null && moduleService.isExternalizable(dataObjectClass)) {
relationship = getRelationshipMetadata(dataObjectClass, attributeName, attributePrefix);
if ((relationship != null) && classHasSupportedFeatures(relationship.getRelatedClass(), supportsLookup,
supportsInquiry)) {
return relationship;
} else {
return null;
}
}
}
if (ddReference != null && ddReference.getPrimitiveAttributes().size() < maxSize) {
if (classHasSupportedFeatures(ddReference.getTargetClass(), supportsLookup, supportsInquiry)) {
relationship = populateRelationshipFromDictionaryReference(dataObjectClass, ddReference, null,
keysOnly);
}
}
return relationship;
}