import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Test
@Legacy
   /**
    * test that a business object relationship definitions have the expected values
    */
public void testBOMetaDataService() throws Exception {
	Account ta = new Account();
DataObjectRelationship br = KNSServiceLocator.getBusinessObjectMetaDataService().getBusinessObjectRelationship(
	ta, "extension.accountType");
	assertEquals( "mismatch on parent class", Account.class, br.getParentClass() );
	assertEquals( "mismatch on related class", AccountType.class, br.getRelatedClass() );
	System.out.println( br.getParentToChildReferences() );
assertEquals("parent/child key not correct - should be extension.accountTypeCode/accountTypeCode",
	"accountTypeCode", br.getParentToChildReferences().get("extension.accountTypeCode"));
	br = KNSServiceLocator.getBusinessObjectMetaDataService().getBusinessObjectRelationship( ta, "extension" );
	assertNull( "extension is not lookupable, should have returned null", br );
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * Determines wheter or not to create an automatic quickfinder widget for this field within the current lifecycle.
 *
 * @return True if an automatic quickfinder widget should be created for this field on the current lifecycle.
 */
protected boolean hasAutoQuickfinderRelationship() {
    String propertyName = getBindingInfo().getBindingName();

    // get object instance and class for parent
    View view = ViewLifecycle.getView();
    Object model = ViewLifecycle.getModel();
    Object parentObject = ViewModelUtils.getParentObjectForMetadata(view, model, this);
    Class<?> parentObjectClass = null;
    if (parentObject != null) {
        parentObjectClass = parentObject.getClass();
    }

    // get relationship from metadata service
    @SuppressWarnings("deprecation")
    DataObjectRelationship relationship = null;
    if (parentObject != null) {
        relationship = KRADServiceLocatorWeb.getLegacyDataAdapter().getDataObjectRelationship(parentObject,
                parentObjectClass, propertyName, "", true, true, false);
    }

    return relationship != null;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * Retrieves any {@link org.kuali.rice.krad.bo.DataObjectRelationship} that is associated with the given
 * field and has a configured lookup view.
 *
 * @param view view instance the quickfinder is associated with
 * @param model object containing the view data
 * @param field input field instance the quickfinder should apply to
 * @return data object relationship for the field, or null if one could not be found
 */
protected DataObjectRelationship getRelationshipForField(View view, Object model, InputField field) {
    String propertyName = field.getBindingInfo().getBindingName();

    // get object instance and class for parent
    Object parentObject = ViewModelUtils.getParentObjectForMetadata(view, model, field);
    Class<?> parentObjectClass = null;
    if (parentObject != null) {
        parentObjectClass = parentObject.getClass();
    }

    // get relationship from metadata service
    if (parentObjectClass != null) {
        return KRADServiceLocatorWeb.getLegacyDataAdapter().getDataObjectRelationship(parentObject,
                parentObjectClass, propertyName, "", true, true, false);
    }

    return null;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * For attributes that are codes (determined by whether they have a
 * reference to a KualiCode bo and similar naming) sets the name as an
 * additional display property
 * 
 * @param businessObjectClass -
 *            class containing attribute
 * @param attributeName - 
 *            name of attribute in the business object
 * @param field - 
 *            property display element
 */
public static void setAdditionalDisplayPropertyForCodes(Class businessObjectClass, String attributeName, PropertyRenderingConfigElement field) {
	try {
		DataObjectRelationship relationship = getBusinessObjectMetaDataService().getBusinessObjectRelationship(
				(BusinessObject) businessObjectClass.newInstance(), attributeName);

		if (relationship != null && attributeName.startsWith(relationship.getParentAttributeName())
				&& KualiCode.class.isAssignableFrom(relationship.getRelatedClass())) {
			field.setAdditionalDisplayPropertyName(relationship.getParentAttributeName() + "."
					+ KRADPropertyConstants.NAME);
		}
	} catch (Exception e) {
		throw new RuntimeException("Cannot get new instance of class to check for KualiCode references: "
				+ e.getMessage());
	}
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
protected DataObjectRelationship getRelationshipMetadata(Class<?> dataObjectClass, String attributeName,
        String attributePrefix) {

    RelationshipDefinition relationshipDefinition = getDictionaryRelationship(dataObjectClass, attributeName);
    if (relationshipDefinition == null) {
        return null;
    }

    DataObjectRelationship dataObjectRelationship = new DataObjectRelationship(
            relationshipDefinition.getSourceClass(), relationshipDefinition.getObjectAttributeName(),
            relationshipDefinition.getTargetClass());

    if (!StringUtils.isEmpty(attributePrefix)) {
        attributePrefix += ".";
    }

    List<PrimitiveAttributeDefinition> primitives = relationshipDefinition.getPrimitiveAttributes();
    for (PrimitiveAttributeDefinition primitiveAttributeDefinition : primitives) {
        dataObjectRelationship.getParentToChildReferences().put(
                attributePrefix + primitiveAttributeDefinition.getSourceName(),
                primitiveAttributeDefinition.getTargetName());
    }

    return dataObjectRelationship;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Override
   public boolean isAttributeLookupable(Class boClass, String attributeName) {
	Object obj = null;
	if (boClass != null && BusinessObject.class.isAssignableFrom(boClass)) {
		obj = ObjectUtils.createNewObjectFromClass(boClass);
	}
	if (obj != null) {
		BusinessObject bo = (BusinessObject) obj;
		DataObjectRelationship relationship = getBusinessObjectRelationship(bo, attributeName);

		if (relationship != null && relationship.getRelatedClass() != null
				&& BusinessObject.class.isAssignableFrom(relationship.getRelatedClass())) {
			return isLookupable(relationship.getRelatedClass());
		}
		else {
			return false;
		}
	}
	else {
		return false;
	}
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Override
public String getReferenceComponentLabel(Class componentClass, String propertyName) {
    DataObjectRelationship relationship = null;
    try {
        relationship = businessObjectMetaDataService.getBusinessObjectRelationship((BusinessObject) componentClass.newInstance(), propertyName);
    }
    catch (Exception e) {
        if ( LOG.isDebugEnabled() ) {
            LOG.debug("KfsBusinessObjectMetadataServiceImpl unable to instantiate componentClass: " + componentClass, e);
        }
    }
    if (relationship != null) {
        return dataDictionaryService.getDataDictionary().getBusinessObjectEntry(relationship.getRelatedClass().getName()).getObjectLabel();
    }
    return "";
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * get the relationship metadata for the detail line fields
 * 
 * @return the relationship metadata for the detail line fields
 */
public Map<String, DataObjectRelationship> getRelationshipMetadata() {
    LOG.debug("getRelationshipMetadata() start");

    PersistenceStructureService persistenceStructureService = SpringContext.getBean(PersistenceStructureService.class);

    Map<String, DataObjectRelationship> relationshipMetadata = new HashMap<String, DataObjectRelationship>();
    for (String attributeName : this.getInquirableFieldNames()) {
        Map<String, Class<? extends BusinessObject>> primitiveReference = LookupUtils.getPrimitiveReference(newDetailLine, attributeName);

        if (primitiveReference != null && !primitiveReference.isEmpty()) {
            DataObjectRelationship primitiveRelationship = this.getPrimitiveDataObjectRelationship(persistenceStructureService.getRelationshipMetadata(newDetailLine.getClass(), attributeName));
            relationshipMetadata.put(attributeName, primitiveRelationship);
        }
    }

    return relationshipMetadata;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * pick up the primitive relationship for an attribute from a set of relationships. Generally, the primitive relationship is
 * that has the minimum number of primary keys.
 * 
 * @param relationshipMetadata the relationship metadata that contains the primitive relationship
 * @return the primitive relationship for an attribute from a set of relationships.
 */
protected DataObjectRelationship getPrimitiveDataObjectRelationship(Map<String, DataObjectRelationship> relationshipMetadata) {
    int minCountOfKeys = Integer.MAX_VALUE;
    DataObjectRelationship primitiveRelationship = null;

    for (String attribute : relationshipMetadata.keySet()) {
        DataObjectRelationship currentRelationship = relationshipMetadata.get(attribute);

        Map<String, String> parentToChildReferences = currentRelationship.getParentToChildReferences();
        if (parentToChildReferences.size() < minCountOfKeys) {
            minCountOfKeys = parentToChildReferences.size();
            primitiveRelationship = currentRelationship;
        }
    }
    return primitiveRelationship;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Override
public String getReferenceComponentLabel(Class componentClass, String propertyName) {
    DataObjectRelationship relationship = null;
    try {
        relationship = businessObjectMetaDataService.getBusinessObjectRelationship((BusinessObject) componentClass.newInstance(), propertyName);
    }
    catch (Exception e) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("KfsBusinessObjectMetadataServiceImpl unable to instantiate componentClass: " + componentClass, e);
        }
    }
    if (relationship != null) {
        return dataDictionaryService.getDataDictionary().getBusinessObjectEntry(relationship.getRelatedClass().getName()).getObjectLabel();
    }
    return "";
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Test
   /**
    * test that a business object relationship definitions have the expected values
    */
public void testBOMetaDataService() throws Exception {
	Account ta = new Account();
DataObjectRelationship br = KNSServiceLocator.getBusinessObjectMetaDataService().getBusinessObjectRelationship(
	ta, "extension.accountType");
	assertEquals( "mismatch on parent class", Account.class, br.getParentClass() );
	assertEquals( "mismatch on related class", AccountType.class, br.getRelatedClass() );
	System.out.println( br.getParentToChildReferences() );
assertEquals("parent/child key not correct - should be extension.accountTypeCode/accountTypeCode",
	"accountTypeCode", br.getParentToChildReferences().get("extension.accountTypeCode"));
	br = KNSServiceLocator.getBusinessObjectMetaDataService().getBusinessObjectRelationship( ta, "extension" );
	assertNull( "extension is not lookupable, should have returned null", br );
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
protected void generateLookupParameters(InputField field, DataObjectRelationship relationship) {
    lookupParameters = new HashMap<String, String>();
    for (Map.Entry<String, String> entry : relationship.getParentToChildReferences().entrySet()) {
        String fromField = entry.getKey();
        String toField = entry.getValue();

        // TODO: displayedFieldnames and displayedQFFieldNames in
        // generateLookupParameters(BusinessObject,
        // String, DataObjectRelationship, String, List, String)

        if (relationship.getUserVisibleIdentifierKey() == null || relationship.getUserVisibleIdentifierKey().equals(
                fromField)) {
            lookupParameters.put(fromField, toField);
        }
    }
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
public boolean isAttributeLookupable(Class boClass, String attributeName) {
	Object obj = null;
	if (boClass != null && BusinessObject.class.isAssignableFrom(boClass)) {
		obj = ObjectUtils.createNewObjectFromClass(boClass);
	}
	if (obj != null) {
		BusinessObject bo = (BusinessObject) obj;
		DataObjectRelationship relationship = getBusinessObjectRelationship(bo, attributeName);

		if (relationship != null && relationship.getRelatedClass() != null
				&& BusinessObject.class.isAssignableFrom(relationship.getRelatedClass())) {
			return isLookupable(relationship.getRelatedClass());
		}
		else {
			return false;
		}
	}
	else {
		return false;
	}
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * If quickfinder not manually configured attempts to find a relationship to build the quickfinder on, then also
 * adjusts the path for any configured field conversions, lookup parameters, and refresh refreshes.
 *
 * @param view view instance the quickfinder is associated with
 * @param model object containing the view data
 * @param inputField input field instance the quickfinder should apply to
 */
protected void setupForInputField(View view, Object model, InputField inputField) {
    // if quickfinder class name not specified, attempt to find a relationship to build the quickfinder from
    if (StringUtils.isBlank(dataObjectClassName)) {
        DataObjectRelationship relationship = getRelationshipForField(view, model, inputField);

        // if no relationship found cannot have a quickfinder
        if (relationship == null) {
            setRender(false);

            return;
        }

        dataObjectClassName = relationship.getRelatedClass().getName();

        if ((fieldConversions == null) || fieldConversions.isEmpty()) {
            generateFieldConversions(relationship);
        }

        if ((lookupParameters == null) || lookupParameters.isEmpty()) {
            generateLookupParameters(relationship);
        }
    }

    // adjust paths based on associated attribute field
    updateFieldConversions(inputField.getBindingInfo());
    updateLookupParameters(inputField.getBindingInfo());
    updateReferencesToRefresh(inputField.getBindingInfo());

    // add the quickfinders action as an input field addon
    inputField.addPostInputAddon(quickfinderAction);
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * Generates the lookup field conversions based on the references from the given relationship.
 *
 * @param relationship relationship field conversions will be generated from
 */
protected void generateFieldConversions(DataObjectRelationship relationship) {
    fieldConversions = new HashMap<String, String>();

    for (Map.Entry<String, String> entry : relationship.getParentToChildReferences().entrySet()) {
        String fromField = entry.getValue();
        String toField = entry.getKey();

        fieldConversions.put(fromField, toField);
    }
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * Generates the lookup parameters based on the references from the given relationship.
 *
 * @param relationship relationship lookup parameters will be generated from
 */
protected void generateLookupParameters(DataObjectRelationship relationship) {
    lookupParameters = new HashMap<String, String>();

    for (Map.Entry<String, String> entry : relationship.getParentToChildReferences().entrySet()) {
        String fromField = entry.getKey();
        String toField = entry.getValue();

        if (relationship.getUserVisibleIdentifierKey() == null || relationship.getUserVisibleIdentifierKey().equals(
                fromField)) {
            lookupParameters.put(fromField, toField);
        }
    }
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.LegacyDataAdapter#getDataObjectRelationship(java.lang.Object, java.lang.Class,
 * java.lang.String, java.lang.String, boolean, boolean, boolean)
 */
@Override
public DataObjectRelationship getDataObjectRelationship(Object dataObject, Class<?> dataObjectClass,
        String attributeName, String attributePrefix, boolean keysOnly, boolean supportsLookup,
        boolean supportsInquiry) {
    return null;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Deprecated
private static String generateFieldConversions(Object businessObject, String collectionName, DataObjectRelationship relationship, String propertyPrefix, List displayedFieldNames, String nestedObjectPrefix) {
    String fieldConversions = "";

    if ( LOG.isDebugEnabled() ) {
        LOG.debug( "generateFieldConversions(" + businessObject.getClass().getName() + "," + collectionName + ",\n" + relationship + "\n," + propertyPrefix + "," + displayedFieldNames + "," + nestedObjectPrefix + ")" );
    }

    // get the references for the given property
    for ( Map.Entry<String,String> entry : relationship.getParentToChildReferences().entrySet() ) {
        String fromField = entry.getValue();
        String toField = entry.getKey();

        // find the displayed to field mapping
        if (!displayedFieldNames.contains(toField)) {
            toField = translateToDisplayedField(businessObject.getClass(), toField, displayedFieldNames);
        }

        if (StringUtils.isNotBlank(fieldConversions)) {
            fieldConversions += ",";
        }

        if ( StringUtils.isNotEmpty( propertyPrefix ) ) {
            toField = propertyPrefix + "." + toField;
        }

        if ( StringUtils.isNotEmpty( collectionName ) ) {
            toField = collectionName + toField;
        }

        fieldConversions += fromField + ":" + toField;
    }

    return fieldConversions;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Deprecated
private static String generateLookupParameters(Object businessObject, String collectionName, DataObjectRelationship relationship, String propertyPrefix, List displayedFieldNames, String nestedObjectPrefix) {

    String lookupParameters = "";

    List displayedQFFieldNames = getBusinessObjectDictionaryService().getLookupFieldNames(relationship.getRelatedClass());
    for ( Map.Entry<String,String> entry : relationship.getParentToChildReferences().entrySet() ) {
        String fromField = entry.getKey();
        String toField = entry.getValue();

        if ( relationship.getUserVisibleIdentifierKey() == null || relationship.getUserVisibleIdentifierKey().equals( fromField ) ) {
            // find the displayed from field mapping
            if (!displayedFieldNames.contains(fromField)) {
                fromField = translateToDisplayedField(businessObject.getClass(), fromField, displayedFieldNames);
            }

            // translate to field
            if (displayedQFFieldNames != null && !displayedQFFieldNames.contains(toField)) {
                toField = translateToDisplayedField(relationship.getRelatedClass(), toField, displayedQFFieldNames);
            }

            if (StringUtils.isNotBlank(lookupParameters)) {
                lookupParameters += ",";
            }

            if (propertyPrefix != null && !propertyPrefix.equals("")) {
                fromField = propertyPrefix + "." + fromField;
            }

            if ( StringUtils.isNotEmpty( collectionName ) ) {
                fromField = collectionName + fromField;
            }

            lookupParameters += fromField + ":" + toField;
        }
    }

    return lookupParameters;
}
 

import org.kuali.rice.krad.bo.DataObjectRelationship; //导入依赖的package包/类
@Override
public DataObjectRelationship getDataObjectRelationship(Object dataObject, Class<?> dataObjectClass,
           String attributeName, String attributePrefix, boolean keysOnly, boolean supportsLookup,
           boolean supportsInquiry) {
       RelationshipDefinition ddReference = getDictionaryRelationship(dataObjectClass, attributeName);

       return getDataObjectRelationship(ddReference, dataObject, dataObjectClass, attributeName, attributePrefix,
               keysOnly, supportsLookup, supportsInquiry);
   }