Coverage Report

Coverage Report - org.kuali.rice.kns.service.impl.ModuleServiceBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

ModuleServiceBase

0/157

0/94

3.517

 /*
  * Copyright 2007-2008 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.kns.service.impl;
 
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 
 import org.apache.commons.beanutils.PropertyUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.kns.bo.BusinessObject;
 import org.kuali.rice.kns.bo.BusinessObjectRelationship;
 import org.kuali.rice.kns.bo.ExternalizableBusinessObject;
 import org.kuali.rice.kns.bo.ModuleConfiguration;
 import org.kuali.rice.kns.datadictionary.BusinessObjectEntry;
 import org.kuali.rice.kns.datadictionary.PrimitiveAttributeDefinition;
 import org.kuali.rice.kns.datadictionary.RelationshipDefinition;
 import org.kuali.rice.kns.service.*;
 import org.kuali.rice.kns.util.ExternalizableBusinessObjectUtils;
 import org.kuali.rice.kns.util.KNSConstants;
 import org.kuali.rice.kns.util.ObjectUtils;
 import org.kuali.rice.kns.util.UrlFactory;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.context.ApplicationContext;
 
 /**
  * This class implements ModuleService interface.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public class ModuleServiceBase implements ModuleService {
 
         protected static final Logger LOG = Logger.getLogger(ModuleServiceBase.class);
 
         protected ModuleConfiguration moduleConfiguration;
         protected BusinessObjectService businessObjectService;
         protected LookupService lookupService;
         protected BusinessObjectDictionaryService businessObjectDictionaryService;
         protected KualiModuleService kualiModuleService;
         protected ApplicationContext applicationContext;
 
         /***
          * @see org.kuali.rice.kns.service.ModuleService#isResponsibleFor(java.lang.Class)
          */
         public boolean isResponsibleFor(Class businessObjectClass) {
                 if(getModuleConfiguration() == null)
                         throw new IllegalStateException("Module configuration has not been initialized for the module service.");
 
                 if (getModuleConfiguration().getPackagePrefixes() == null || businessObjectClass == null) {
                         return false;
                 }
                 for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
                         if (businessObjectClass.getPackage().getName().startsWith(prefix)) {
                                 return true;
                         }
                 }
                 if (ExternalizableBusinessObject.class.isAssignableFrom(businessObjectClass)) {
                         Class externalizableBusinessObjectInterface = ExternalizableBusinessObjectUtils.determineExternalizableBusinessObjectSubInterface(businessObjectClass);
                         if (externalizableBusinessObjectInterface != null) {
                                 for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
                                         if (externalizableBusinessObjectInterface.getPackage().getName().startsWith(prefix)) {
                                                 return true;
                                         }
                                 }
                         }
                 }
                 return false;
         }
 
 
 
         /***
          * @see org.kuali.rice.kns.service.ModuleService#isResponsibleFor(java.lang.Class)
          */
         public boolean isResponsibleForJob(String jobName) {
                 if(getModuleConfiguration() == null)
                         throw new IllegalStateException("Module configuration has not been initialized for the module service.");
 
                 if (getModuleConfiguration().getJobNames() == null || StringUtils.isEmpty(jobName))
                         return false;
 
                 return getModuleConfiguration().getJobNames().contains(jobName);
         }
 
     /***
      * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
      */
     public <T extends ExternalizableBusinessObject> T getExternalizableBusinessObject(Class<T> businessObjectClass, Map<String, Object> fieldValues) {
             Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(businessObjectClass);
                 ExternalizableBusinessObject businessObject = (ExternalizableBusinessObject)
                         getBusinessObjectService().findByPrimaryKey(implementationClass, fieldValues);
         return (T) businessObject;
         }
 
     /***
      * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
      */
         public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsList(
                         Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues) {
                 Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
                 return (List<T>) getBusinessObjectService().findMatching(implementationClass, fieldValues);
         }
 
         /***
          * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectsListForLookup(java.lang.Class, java.util.Map, boolean)
          */
         public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsListForLookup(
                         Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues, boolean unbounded) {
                 Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
                 if (isExternalizableBusinessObjectLookupable(implementationClass)) {
                     return (List<T>) getLookupService().findCollectionBySearchHelper(implementationClass, fieldValues, unbounded);
                 } else {
                    throw new BusinessObjectNotLookupableException("External business object is not a Lookupable:  " + implementationClass);
                 }
         }
 
         public List listPrimaryKeyFieldNames(Class businessObjectInterfaceClass){
                 Class clazz = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
                 return KNSServiceLocator.getPersistenceStructureService().listPrimaryKeyFieldNames(clazz);
         }
 
         /***
          * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectDictionaryEntry(java.lang.Class)
          */
         public BusinessObjectEntry getExternalizableBusinessObjectDictionaryEntry(
                         Class businessObjectInterfaceClass) {
                 Class boClass = businessObjectInterfaceClass;
                 if(businessObjectInterfaceClass.isInterface())
                         boClass = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
                 return boClass==null?null:
                         KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntryForConcreteClass(boClass.getName());
         }
 
         public String getExternalizableBusinessObjectInquiryUrl(Class inquiryBusinessObjectClass, Map<String, String[]> parameters) {
                 if(!ExternalizableBusinessObject.class.isAssignableFrom(inquiryBusinessObjectClass)) {
                 return KNSConstants.EMPTY_STRING;
                 }
                 String businessObjectClassAttribute;
                 if(inquiryBusinessObjectClass.isInterface()){
                         Class implementationClass = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
                         if (implementationClass == null) {
                                 LOG.error("Can't find ExternalizableBusinessObject implementation class for interface " + inquiryBusinessObjectClass.getName());
                                 throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for interface " + inquiryBusinessObjectClass.getName());
                         }
                         businessObjectClassAttribute = implementationClass.getName();
                 }else{
                         LOG.warn("Inquiry was invoked with a non-interface class object " + inquiryBusinessObjectClass.getName());
                         businessObjectClassAttribute = inquiryBusinessObjectClass.getName();
                 }
         return UrlFactory.parameterizeUrl(
                         getInquiryUrl(inquiryBusinessObjectClass),
                         getUrlParameters(businessObjectClassAttribute, parameters));
         }
 
         protected Properties getUrlParameters(String businessObjectClassAttribute, Map<String, String[]> parameters){
                 Properties urlParameters = new Properties();
                 for (String paramName : parameters.keySet()) {
                         String[] parameterValues = parameters.get(paramName);
                         if (parameterValues.length > 0) {
                                 urlParameters.put(paramName, parameterValues[0]);
                         }
                 }
                 urlParameters.put(KNSConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, businessObjectClassAttribute);
                 urlParameters.put(KNSConstants.DISPATCH_REQUEST_PARAMETER, KNSConstants.CONTINUE_WITH_INQUIRY_METHOD_TO_CALL);
                 return urlParameters;
         }
 
         protected String getInquiryUrl(Class inquiryBusinessObjectClass){
                 String riceBaseUrl = KNSServiceLocator.getKualiConfigurationService().getPropertyString(KNSConstants.APPLICATION_URL_KEY);
                 String inquiryUrl = riceBaseUrl;
                 if (!inquiryUrl.endsWith("/")) {
                         inquiryUrl = inquiryUrl + "/";
                 }
                 return inquiryUrl + "kr/" + KNSConstants.INQUIRY_ACTION;
         }
 
         /**
          * This overridden method ...
          *
          * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectLookupUrl(java.lang.Class, java.util.Map)
          */
         public String getExternalizableBusinessObjectLookupUrl(Class inquiryBusinessObjectClass, Map<String, String> parameters) {
                 Properties urlParameters = new Properties();
 
                 String riceBaseUrl = KNSServiceLocator.getKualiConfigurationService().getPropertyString(KNSConstants.APPLICATION_URL_KEY);
                 String lookupUrl = riceBaseUrl;
                 if (!lookupUrl.endsWith("/")) {
                         lookupUrl = lookupUrl + "/";
                 }
                 if (parameters.containsKey(KNSConstants.MULTIPLE_VALUE)) {
                         lookupUrl = lookupUrl + "kr/" + KNSConstants.MULTIPLE_VALUE_LOOKUP_ACTION;
                 }
                 else {
                         lookupUrl = lookupUrl + "kr/" + KNSConstants.LOOKUP_ACTION;
                 }
                 for (String paramName : parameters.keySet()) {
                         urlParameters.put(paramName, parameters.get(paramName));
                 }
 
                 Class clazz = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
                 urlParameters.put(KNSConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, clazz==null?"":clazz.getName());
 
                 return UrlFactory.parameterizeUrl(lookupUrl, urlParameters);
         }
 
         /***
          *
          * This method assumes that the property type for externalizable relationship in the business object is an interface
          * and gets the concrete implementation for it
          *
          * @see org.kuali.rice.kns.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.kns.bo.BusinessObject, org.kuali.rice.kns.bo.BusinessObject, java.lang.String)
          */
         public <T extends ExternalizableBusinessObject> T retrieveExternalizableBusinessObjectIfNecessary(
                         BusinessObject businessObject, T currentInstanceExternalizableBO, String externalizableRelationshipName) {
 
                 if(businessObject==null) return null;
                 Class clazz;
                 try{
                         clazz = getExternalizableBusinessObjectImplementation(
                                         PropertyUtils.getPropertyType(businessObject, externalizableRelationshipName));
                 } catch(Exception iex){
                         LOG.warn("Exception:"+iex+" thrown while trying to get property type for property:"+externalizableRelationshipName+
                                         " from business object:"+businessObject);
                         return null;
                 }
 
                 //Get the business object entry for this business object from data dictionary
                 //using the class name (without the package) as key
                 BusinessObjectEntry entry =
                         KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(
                                         businessObject.getClass().getSimpleName());
                 RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
                 List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions = relationshipDefinition.getPrimitiveAttributes();
 
                 Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
                 Object sourcePropertyValue;
                 Object targetPropertyValue = null;
                 boolean sourceTargetPropertyValuesSame = true;
                 for(PrimitiveAttributeDefinition primitiveAttributeDefinition: primitiveAttributeDefinitions){
                     sourcePropertyValue = ObjectUtils.getPropertyValue(
                                     businessObject, primitiveAttributeDefinition.getSourceName());
                     if(currentInstanceExternalizableBO!=null)
                             targetPropertyValue = ObjectUtils.getPropertyValue(currentInstanceExternalizableBO, primitiveAttributeDefinition.getTargetName());
                     if(sourcePropertyValue==null){
                         return null;
                     } else if(targetPropertyValue==null || (targetPropertyValue!=null && !targetPropertyValue.equals(sourcePropertyValue))){
                             sourceTargetPropertyValuesSame = false;
                     }
                     fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
                 }
 
                 if(!sourceTargetPropertyValuesSame)
                         return (T) getExternalizableBusinessObject(clazz, fieldValuesInEBO);
                 return currentInstanceExternalizableBO;
         }
 
         /***
          *
          * This method assumes that the externalizableClazz is an interface
          * and gets the concrete implementation for it
          *
          * @see org.kuali.rice.kns.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.kns.bo.BusinessObject, org.kuali.rice.kns.bo.BusinessObject, java.lang.String)
          */
         public List<? extends ExternalizableBusinessObject> retrieveExternalizableBusinessObjectsList(
                         BusinessObject businessObject, String externalizableRelationshipName, Class externalizableClazz) {
 
                 if(businessObject==null) return null;
                 //Get the business object entry for this business object from data dictionary
                 //using the class name (without the package) as key
                 String className = businessObject.getClass().getName();
                 String key = className.substring(className.lastIndexOf(".")+1);
                 BusinessObjectEntry entry =
                         KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(key);
                 RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
                 List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions = relationshipDefinition.getPrimitiveAttributes();
                 Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
                 Object sourcePropertyValue;
                 for(PrimitiveAttributeDefinition primitiveAttributeDefinition: primitiveAttributeDefinitions){
                     sourcePropertyValue = ObjectUtils.getPropertyValue(
                                     businessObject, primitiveAttributeDefinition.getSourceName());
                     if(sourcePropertyValue==null){
                         return null;
                     }
                     fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
                 }
                 return getExternalizableBusinessObjectsList(
                                 getExternalizableBusinessObjectImplementation(externalizableClazz), fieldValuesInEBO);
         }
 
         /**
          * @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectImplementation(java.lang.Class)
          */
         public <E extends ExternalizableBusinessObject> Class<E> getExternalizableBusinessObjectImplementation(Class<E> externalizableBusinessObjectInterface) {
                 if (getModuleConfiguration() == null) {
                         throw new IllegalStateException("Module configuration has not been initialized for the module service.");
                 }
                 int classModifiers = externalizableBusinessObjectInterface.getModifiers();
                 if (!Modifier.isInterface(classModifiers) && !Modifier.isAbstract(classModifiers)) {
                         // the interface is really a non-abstract class
                         return externalizableBusinessObjectInterface;
                 }
                 if (getModuleConfiguration().getExternalizableBusinessObjectImplementations() == null) {
                         return null;
                 }
                 else {
                         Class<E> implementationClass = getModuleConfiguration().getExternalizableBusinessObjectImplementations().get(externalizableBusinessObjectInterface);
                         int implClassModifiers = implementationClass.getModifiers();
                         if (Modifier.isInterface(implClassModifiers) || Modifier.isAbstract(implClassModifiers)) {
                                 throw new RuntimeException("Implementation class must be non-abstract class: ebo interface: " + externalizableBusinessObjectInterface.getName() + " impl class: "
                                                 + implementationClass.getName() + " module: " + getModuleConfiguration().getNamespaceCode());
                         }
                         return implementationClass;
                 }
 
         }
 
         /***
          * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
          */
         public void afterPropertiesSet() throws Exception {
                 KualiModuleService kualiModuleService = null;
                 try {
                         kualiModuleService = KNSServiceLocatorWeb.getKualiModuleService();
                         if ( kualiModuleService == null ) {
                                 kualiModuleService = ((KualiModuleService)applicationContext.getBean( KNSServiceLocatorWeb.KUALI_MODULE_SERVICE ));
                         }
                 } catch ( NoSuchBeanDefinitionException ex ) {
                         kualiModuleService = ((KualiModuleService)applicationContext.getBean( KNSServiceLocatorWeb.KUALI_MODULE_SERVICE ));
                 }
                 kualiModuleService.getInstalledModuleServices().add( this );
         }
 
         /**
          * @return the moduleConfiguration
          */
         public ModuleConfiguration getModuleConfiguration() {
                 return this.moduleConfiguration;
         }
 
         /**
          * @param moduleConfiguration the moduleConfiguration to set
          */
         public void setModuleConfiguration(ModuleConfiguration moduleConfiguration) {
                 this.moduleConfiguration = moduleConfiguration;
         }
 
     /***
      * @see org.kuali.rice.kns.service.ModuleService#isExternalizable(java.lang.Class)
      */
     public boolean isExternalizable(Class boClazz){
             if(boClazz==null) return false;
             return ExternalizableBusinessObject.class.isAssignableFrom(boClazz);
     }
 
         public boolean isExternalizableBusinessObjectLookupable(Class boClass) {
                 return getBusinessObjectDictionaryService().isLookupable(boClass);
         }
 
         public boolean isExternalizableBusinessObjectInquirable(Class boClass) {
                 return getBusinessObjectDictionaryService().isInquirable(boClass);
         }
 
         public <T extends ExternalizableBusinessObject> T createNewObjectFromExternalizableClass(Class<T> boClass) {
                 try {
                         return (T) getExternalizableBusinessObjectImplementation(boClass).newInstance();
                 } catch (Exception e) {
                         throw new RuntimeException("Unable to create externalizable business object class", e);
                 }
         }
 
         public BusinessObjectRelationship getBusinessObjectRelationship(Class boClass, String attributeName, String attributePrefix){
                 return null;
         }
 
 
 
         public BusinessObjectDictionaryService getBusinessObjectDictionaryService () {
                 if ( businessObjectDictionaryService == null ) {
                         businessObjectDictionaryService = KNSServiceLocatorWeb.getBusinessObjectDictionaryService();
                 }
                 return businessObjectDictionaryService;
         }
 
         /**
          * @return the businessObjectService
          */
         public BusinessObjectService getBusinessObjectService() {
                 if ( businessObjectService == null ) {
                         businessObjectService = KNSServiceLocator.getBusinessObjectService();
                 }
                 return businessObjectService;
         }
 
     /**
      * Gets the lookupService attribute.
      * @return Returns the lookupService.
      */
     protected LookupService getLookupService() {
         return lookupService != null ? lookupService : KNSServiceLocatorWeb.getLookupService();
     }
 
         /**
          * @return the kualiModuleService
          */
         public KualiModuleService getKualiModuleService() {
                 return this.kualiModuleService;
         }
 
         /**
          * @param kualiModuleService the kualiModuleService to set
          */
         public void setKualiModuleService(KualiModuleService kualiModuleService) {
                 this.kualiModuleService = kualiModuleService;
         }
 
         /**
          * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
          */
         public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
                 this.applicationContext = applicationContext;
         }
 
 
 
         /**
          * This overridden method ...
          *
          * @see org.kuali.rice.kns.service.ModuleService#listAlternatePrimaryKeyFieldNames(java.lang.Class)
          */
         public List<List<String>> listAlternatePrimaryKeyFieldNames(
                         Class businessObjectInterfaceClass) {
                 return null;
         }
 
 }
 

1		/*
2		* Copyright 2007-2008 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.kns.service.impl;
17
18		import java.lang.reflect.Modifier;
19		import java.util.HashMap;
20		import java.util.List;
21		import java.util.Map;
22		import java.util.Properties;
23
24		import org.apache.commons.beanutils.PropertyUtils;
25		import org.apache.commons.lang.StringUtils;
26		import org.apache.log4j.Logger;
27		import org.kuali.rice.kns.bo.BusinessObject;
28		import org.kuali.rice.kns.bo.BusinessObjectRelationship;
29		import org.kuali.rice.kns.bo.ExternalizableBusinessObject;
30		import org.kuali.rice.kns.bo.ModuleConfiguration;
31		import org.kuali.rice.kns.datadictionary.BusinessObjectEntry;
32		import org.kuali.rice.kns.datadictionary.PrimitiveAttributeDefinition;
33		import org.kuali.rice.kns.datadictionary.RelationshipDefinition;
34		import org.kuali.rice.kns.service.*;
35		import org.kuali.rice.kns.util.ExternalizableBusinessObjectUtils;
36		import org.kuali.rice.kns.util.KNSConstants;
37		import org.kuali.rice.kns.util.ObjectUtils;
38		import org.kuali.rice.kns.util.UrlFactory;
39		import org.springframework.beans.BeansException;
40		import org.springframework.beans.factory.NoSuchBeanDefinitionException;
41		import org.springframework.context.ApplicationContext;
42
43		/**
44		* This class implements ModuleService interface.
45		*
46		* @author Kuali Rice Team (rice.collab@kuali.org)
47		*
48		*/
49	0	public class ModuleServiceBase implements ModuleService {
50
51	0	protected static final Logger LOG = Logger.getLogger(ModuleServiceBase.class);
52
53		protected ModuleConfiguration moduleConfiguration;
54		protected BusinessObjectService businessObjectService;
55		protected LookupService lookupService;
56		protected BusinessObjectDictionaryService businessObjectDictionaryService;
57		protected KualiModuleService kualiModuleService;
58		protected ApplicationContext applicationContext;
59
60		/***
61		* @see org.kuali.rice.kns.service.ModuleService#isResponsibleFor(java.lang.Class)
62		*/
63		public boolean isResponsibleFor(Class businessObjectClass) {
64	0	if(getModuleConfiguration() == null)
65	0	throw new IllegalStateException("Module configuration has not been initialized for the module service.");
66
67	0	if (getModuleConfiguration().getPackagePrefixes() == null \|\| businessObjectClass == null) {
68	0	return false;
69		}
70	0	for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
71	0	if (businessObjectClass.getPackage().getName().startsWith(prefix)) {
72	0	return true;
73		}
74		}
75	0	if (ExternalizableBusinessObject.class.isAssignableFrom(businessObjectClass)) {
76	0	Class externalizableBusinessObjectInterface = ExternalizableBusinessObjectUtils.determineExternalizableBusinessObjectSubInterface(businessObjectClass);
77	0	if (externalizableBusinessObjectInterface != null) {
78	0	for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
79	0	if (externalizableBusinessObjectInterface.getPackage().getName().startsWith(prefix)) {
80	0	return true;
81		}
82		}
83		}
84		}
85	0	return false;
86		}
87
88
89
90		/***
91		* @see org.kuali.rice.kns.service.ModuleService#isResponsibleFor(java.lang.Class)
92		*/
93		public boolean isResponsibleForJob(String jobName) {
94	0	if(getModuleConfiguration() == null)
95	0	throw new IllegalStateException("Module configuration has not been initialized for the module service.");
96
97	0	if (getModuleConfiguration().getJobNames() == null \|\| StringUtils.isEmpty(jobName))
98	0	return false;
99
100	0	return getModuleConfiguration().getJobNames().contains(jobName);
101		}
102
103		/***
104		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
105		*/
106		public <T extends ExternalizableBusinessObject> T getExternalizableBusinessObject(Class<T> businessObjectClass, Map<String, Object> fieldValues) {
107	0	Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(businessObjectClass);
108	0	ExternalizableBusinessObject businessObject = (ExternalizableBusinessObject)
109		getBusinessObjectService().findByPrimaryKey(implementationClass, fieldValues);
110	0	return (T) businessObject;
111		}
112
113		/***
114		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
115		*/
116		public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsList(
117		Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues) {
118	0	Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
119	0	return (List<T>) getBusinessObjectService().findMatching(implementationClass, fieldValues);
120		}
121
122		/***
123		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectsListForLookup(java.lang.Class, java.util.Map, boolean)
124		*/
125		public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsListForLookup(
126		Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues, boolean unbounded) {
127	0	Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
128	0	if (isExternalizableBusinessObjectLookupable(implementationClass)) {
129	0	return (List<T>) getLookupService().findCollectionBySearchHelper(implementationClass, fieldValues, unbounded);
130		} else {
131	0	throw new BusinessObjectNotLookupableException("External business object is not a Lookupable: " + implementationClass);
132		}
133		}
134
135		public List listPrimaryKeyFieldNames(Class businessObjectInterfaceClass){
136	0	Class clazz = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
137	0	return KNSServiceLocator.getPersistenceStructureService().listPrimaryKeyFieldNames(clazz);
138		}
139
140		/***
141		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectDictionaryEntry(java.lang.Class)
142		*/
143		public BusinessObjectEntry getExternalizableBusinessObjectDictionaryEntry(
144		Class businessObjectInterfaceClass) {
145	0	Class boClass = businessObjectInterfaceClass;
146	0	if(businessObjectInterfaceClass.isInterface())
147	0	boClass = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
148	0	return boClass==null?null:
149		KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntryForConcreteClass(boClass.getName());
150		}
151
152		public String getExternalizableBusinessObjectInquiryUrl(Class inquiryBusinessObjectClass, Map<String, String[]> parameters) {
153	0	if(!ExternalizableBusinessObject.class.isAssignableFrom(inquiryBusinessObjectClass)) {
154	0	return KNSConstants.EMPTY_STRING;
155		}
156		String businessObjectClassAttribute;
157	0	if(inquiryBusinessObjectClass.isInterface()){
158	0	Class implementationClass = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
159	0	if (implementationClass == null) {
160	0	LOG.error("Can't find ExternalizableBusinessObject implementation class for interface " + inquiryBusinessObjectClass.getName());
161	0	throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for interface " + inquiryBusinessObjectClass.getName());
162		}
163	0	businessObjectClassAttribute = implementationClass.getName();
164	0	}else{
165	0	LOG.warn("Inquiry was invoked with a non-interface class object " + inquiryBusinessObjectClass.getName());
166	0	businessObjectClassAttribute = inquiryBusinessObjectClass.getName();
167		}
168	0	return UrlFactory.parameterizeUrl(
169		getInquiryUrl(inquiryBusinessObjectClass),
170		getUrlParameters(businessObjectClassAttribute, parameters));
171		}
172
173		protected Properties getUrlParameters(String businessObjectClassAttribute, Map<String, String[]> parameters){
174	0	Properties urlParameters = new Properties();
175	0	for (String paramName : parameters.keySet()) {
176	0	String[] parameterValues = parameters.get(paramName);
177	0	if (parameterValues.length > 0) {
178	0	urlParameters.put(paramName, parameterValues[0]);
179		}
180	0	}
181	0	urlParameters.put(KNSConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, businessObjectClassAttribute);
182	0	urlParameters.put(KNSConstants.DISPATCH_REQUEST_PARAMETER, KNSConstants.CONTINUE_WITH_INQUIRY_METHOD_TO_CALL);
183	0	return urlParameters;
184		}
185
186		protected String getInquiryUrl(Class inquiryBusinessObjectClass){
187	0	String riceBaseUrl = KNSServiceLocator.getKualiConfigurationService().getPropertyString(KNSConstants.APPLICATION_URL_KEY);
188	0	String inquiryUrl = riceBaseUrl;
189	0	if (!inquiryUrl.endsWith("/")) {
190	0	inquiryUrl = inquiryUrl + "/";
191		}
192	0	return inquiryUrl + "kr/" + KNSConstants.INQUIRY_ACTION;
193		}
194
195		/**
196		* This overridden method ...
197		*
198		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectLookupUrl(java.lang.Class, java.util.Map)
199		*/
200		public String getExternalizableBusinessObjectLookupUrl(Class inquiryBusinessObjectClass, Map<String, String> parameters) {
201	0	Properties urlParameters = new Properties();
202
203	0	String riceBaseUrl = KNSServiceLocator.getKualiConfigurationService().getPropertyString(KNSConstants.APPLICATION_URL_KEY);
204	0	String lookupUrl = riceBaseUrl;
205	0	if (!lookupUrl.endsWith("/")) {
206	0	lookupUrl = lookupUrl + "/";
207		}
208	0	if (parameters.containsKey(KNSConstants.MULTIPLE_VALUE)) {
209	0	lookupUrl = lookupUrl + "kr/" + KNSConstants.MULTIPLE_VALUE_LOOKUP_ACTION;
210		}
211		else {
212	0	lookupUrl = lookupUrl + "kr/" + KNSConstants.LOOKUP_ACTION;
213		}
214	0	for (String paramName : parameters.keySet()) {
215	0	urlParameters.put(paramName, parameters.get(paramName));
216		}
217
218	0	Class clazz = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
219	0	urlParameters.put(KNSConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, clazz==null?"":clazz.getName());
220
221	0	return UrlFactory.parameterizeUrl(lookupUrl, urlParameters);
222		}
223
224		/***
225		*
226		* This method assumes that the property type for externalizable relationship in the business object is an interface
227		* and gets the concrete implementation for it
228		*
229		* @see org.kuali.rice.kns.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.kns.bo.BusinessObject, org.kuali.rice.kns.bo.BusinessObject, java.lang.String)
230		*/
231		public <T extends ExternalizableBusinessObject> T retrieveExternalizableBusinessObjectIfNecessary(
232		BusinessObject businessObject, T currentInstanceExternalizableBO, String externalizableRelationshipName) {
233
234	0	if(businessObject==null) return null;
235		Class clazz;
236		try{
237	0	clazz = getExternalizableBusinessObjectImplementation(
238		PropertyUtils.getPropertyType(businessObject, externalizableRelationshipName));
239	0	} catch(Exception iex){
240	0	LOG.warn("Exception:"+iex+" thrown while trying to get property type for property:"+externalizableRelationshipName+
241		" from business object:"+businessObject);
242	0	return null;
243	0	}
244
245		//Get the business object entry for this business object from data dictionary
246		//using the class name (without the package) as key
247	0	BusinessObjectEntry entry =
248		KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(
249		businessObject.getClass().getSimpleName());
250	0	RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
251	0	List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions = relationshipDefinition.getPrimitiveAttributes();
252
253	0	Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
254		Object sourcePropertyValue;
255	0	Object targetPropertyValue = null;
256	0	boolean sourceTargetPropertyValuesSame = true;
257	0	for(PrimitiveAttributeDefinition primitiveAttributeDefinition: primitiveAttributeDefinitions){
258	0	sourcePropertyValue = ObjectUtils.getPropertyValue(
259		businessObject, primitiveAttributeDefinition.getSourceName());
260	0	if(currentInstanceExternalizableBO!=null)
261	0	targetPropertyValue = ObjectUtils.getPropertyValue(currentInstanceExternalizableBO, primitiveAttributeDefinition.getTargetName());
262	0	if(sourcePropertyValue==null){
263	0	return null;
264	0	} else if(targetPropertyValue==null \|\| (targetPropertyValue!=null && !targetPropertyValue.equals(sourcePropertyValue))){
265	0	sourceTargetPropertyValuesSame = false;
266		}
267	0	fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
268		}
269
270	0	if(!sourceTargetPropertyValuesSame)
271	0	return (T) getExternalizableBusinessObject(clazz, fieldValuesInEBO);
272	0	return currentInstanceExternalizableBO;
273		}
274
275		/***
276		*
277		* This method assumes that the externalizableClazz is an interface
278		* and gets the concrete implementation for it
279		*
280		* @see org.kuali.rice.kns.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.kns.bo.BusinessObject, org.kuali.rice.kns.bo.BusinessObject, java.lang.String)
281		*/
282		public List<? extends ExternalizableBusinessObject> retrieveExternalizableBusinessObjectsList(
283		BusinessObject businessObject, String externalizableRelationshipName, Class externalizableClazz) {
284
285	0	if(businessObject==null) return null;
286		//Get the business object entry for this business object from data dictionary
287		//using the class name (without the package) as key
288	0	String className = businessObject.getClass().getName();
289	0	String key = className.substring(className.lastIndexOf(".")+1);
290	0	BusinessObjectEntry entry =
291		KNSServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(key);
292	0	RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
293	0	List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions = relationshipDefinition.getPrimitiveAttributes();
294	0	Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
295		Object sourcePropertyValue;
296	0	for(PrimitiveAttributeDefinition primitiveAttributeDefinition: primitiveAttributeDefinitions){
297	0	sourcePropertyValue = ObjectUtils.getPropertyValue(
298		businessObject, primitiveAttributeDefinition.getSourceName());
299	0	if(sourcePropertyValue==null){
300	0	return null;
301		}
302	0	fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
303		}
304	0	return getExternalizableBusinessObjectsList(
305		getExternalizableBusinessObjectImplementation(externalizableClazz), fieldValuesInEBO);
306		}
307
308		/**
309		* @see org.kuali.rice.kns.service.ModuleService#getExternalizableBusinessObjectImplementation(java.lang.Class)
310		*/
311		public <E extends ExternalizableBusinessObject> Class<E> getExternalizableBusinessObjectImplementation(Class<E> externalizableBusinessObjectInterface) {
312	0	if (getModuleConfiguration() == null) {
313	0	throw new IllegalStateException("Module configuration has not been initialized for the module service.");
314		}
315	0	int classModifiers = externalizableBusinessObjectInterface.getModifiers();
316	0	if (!Modifier.isInterface(classModifiers) && !Modifier.isAbstract(classModifiers)) {
317		// the interface is really a non-abstract class
318	0	return externalizableBusinessObjectInterface;
319		}
320	0	if (getModuleConfiguration().getExternalizableBusinessObjectImplementations() == null) {
321	0	return null;
322		}
323		else {
324	0	Class<E> implementationClass = getModuleConfiguration().getExternalizableBusinessObjectImplementations().get(externalizableBusinessObjectInterface);
325	0	int implClassModifiers = implementationClass.getModifiers();
326	0	if (Modifier.isInterface(implClassModifiers) \|\| Modifier.isAbstract(implClassModifiers)) {
327	0	throw new RuntimeException("Implementation class must be non-abstract class: ebo interface: " + externalizableBusinessObjectInterface.getName() + " impl class: "
328		+ implementationClass.getName() + " module: " + getModuleConfiguration().getNamespaceCode());
329		}
330	0	return implementationClass;
331		}
332
333		}
334
335		/***
336		* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
337		*/
338		public void afterPropertiesSet() throws Exception {
339	0	KualiModuleService kualiModuleService = null;
340		try {
341	0	kualiModuleService = KNSServiceLocatorWeb.getKualiModuleService();
342	0	if ( kualiModuleService == null ) {
343	0	kualiModuleService = ((KualiModuleService)applicationContext.getBean( KNSServiceLocatorWeb.KUALI_MODULE_SERVICE ));
344		}
345	0	} catch ( NoSuchBeanDefinitionException ex ) {
346	0	kualiModuleService = ((KualiModuleService)applicationContext.getBean( KNSServiceLocatorWeb.KUALI_MODULE_SERVICE ));
347	0	}
348	0	kualiModuleService.getInstalledModuleServices().add( this );
349	0	}
350
351		/**
352		* @return the moduleConfiguration
353		*/
354		public ModuleConfiguration getModuleConfiguration() {
355	0	return this.moduleConfiguration;
356		}
357
358		/**
359		* @param moduleConfiguration the moduleConfiguration to set
360		*/
361		public void setModuleConfiguration(ModuleConfiguration moduleConfiguration) {
362	0	this.moduleConfiguration = moduleConfiguration;
363	0	}
364
365		/***
366		* @see org.kuali.rice.kns.service.ModuleService#isExternalizable(java.lang.Class)
367		*/
368		public boolean isExternalizable(Class boClazz){
369	0	if(boClazz==null) return false;
370	0	return ExternalizableBusinessObject.class.isAssignableFrom(boClazz);
371		}
372
373		public boolean isExternalizableBusinessObjectLookupable(Class boClass) {
374	0	return getBusinessObjectDictionaryService().isLookupable(boClass);
375		}
376
377		public boolean isExternalizableBusinessObjectInquirable(Class boClass) {
378	0	return getBusinessObjectDictionaryService().isInquirable(boClass);
379		}
380
381		public <T extends ExternalizableBusinessObject> T createNewObjectFromExternalizableClass(Class<T> boClass) {
382		try {
383	0	return (T) getExternalizableBusinessObjectImplementation(boClass).newInstance();
384	0	} catch (Exception e) {
385	0	throw new RuntimeException("Unable to create externalizable business object class", e);
386		}
387		}
388
389		public BusinessObjectRelationship getBusinessObjectRelationship(Class boClass, String attributeName, String attributePrefix){
390	0	return null;
391		}
392
393
394
395		public BusinessObjectDictionaryService getBusinessObjectDictionaryService () {
396	0	if ( businessObjectDictionaryService == null ) {
397	0	businessObjectDictionaryService = KNSServiceLocatorWeb.getBusinessObjectDictionaryService();
398		}
399	0	return businessObjectDictionaryService;
400		}
401
402		/**
403		* @return the businessObjectService
404		*/
405		public BusinessObjectService getBusinessObjectService() {
406	0	if ( businessObjectService == null ) {
407	0	businessObjectService = KNSServiceLocator.getBusinessObjectService();
408		}
409	0	return businessObjectService;
410		}
411
412		/**
413		* Gets the lookupService attribute.
414		* @return Returns the lookupService.
415		*/
416		protected LookupService getLookupService() {
417	0	return lookupService != null ? lookupService : KNSServiceLocatorWeb.getLookupService();
418		}
419
420		/**
421		* @return the kualiModuleService
422		*/
423		public KualiModuleService getKualiModuleService() {
424	0	return this.kualiModuleService;
425		}
426
427		/**
428		* @param kualiModuleService the kualiModuleService to set
429		*/
430		public void setKualiModuleService(KualiModuleService kualiModuleService) {
431	0	this.kualiModuleService = kualiModuleService;
432	0	}
433
434		/**
435		* @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
436		*/
437		public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
438	0	this.applicationContext = applicationContext;
439	0	}
440
441
442
443		/**
444		* This overridden method ...
445		*
446		* @see org.kuali.rice.kns.service.ModuleService#listAlternatePrimaryKeyFieldNames(java.lang.Class)
447		*/
448		public List<List<String>> listAlternatePrimaryKeyFieldNames(
449		Class businessObjectInterfaceClass) {
450	0	return null;
451		}
452
453		}
454