Coverage Report

Coverage Report - org.kuali.rice.kns.service.KNSServiceLocator

Classes in this File

Line Coverage

Branch Coverage

Complexity

KNSServiceLocator

0/91

0/12

1.155

 /*
  * Copyright 2007 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;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import javax.persistence.EntityManagerFactory;
 
 import org.kuali.rice.core.database.platform.DatabasePlatform;
 import org.kuali.rice.core.resourceloader.GlobalResourceLoader;
 import org.kuali.rice.core.resourceloader.RiceResourceLoaderFactory;
 import org.kuali.rice.core.resourceloader.SpringResourceLoader;
 import org.kuali.rice.core.service.EncryptionService;
 import org.kuali.rice.kns.dao.BusinessObjectDao;
 import org.kuali.rice.kns.dao.DocumentDao;
 import org.kuali.rice.kns.inquiry.Inquirable;
 import org.kuali.rice.kns.lookup.LookupResultsService;
 import org.kuali.rice.kns.lookup.Lookupable;
 import org.kuali.rice.kns.question.Question;
 import org.kuali.rice.kns.util.OjbCollectionHelper;
 import org.kuali.rice.kns.util.cache.MethodCacheInterceptor;
 import org.kuali.rice.kns.util.spring.NamedOrderedListBean;
 import org.kuali.rice.kns.workflow.service.KualiWorkflowInfo;
 import org.kuali.rice.kns.workflow.service.WorkflowAttributePropertyResolutionService;
 import org.kuali.rice.kns.workflow.service.WorkflowDocumentService;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.support.TransactionTemplate;
 
 import com.opensymphony.oscache.general.GeneralCacheAdministrator;
 
 public class KNSServiceLocator<T extends Object> {
 
     public static final String VALIDATION_COMPLETION_UTILS = "validationCompletionUtils";
 
     public static Object getService(String serviceName) {
         return GlobalResourceLoader.getService(serviceName);
     }
 
     public static <T> T getNervousSystemContextBean(Class<T> type) {
         Collection<T> beansOfType = getBeansOfType(type).values();
         if (beansOfType.isEmpty()) {
             throw new NoSuchBeanDefinitionException("No beans of this type in the KNS application context: "
                     + type.getName());
         }
         if (beansOfType.size() > 1) {
             return getNervousSystemContextBean(type, type.getSimpleName().substring(0, 1).toLowerCase() + type.getSimpleName().substring(1));
         }
         return beansOfType.iterator().next();
     }
 
     @SuppressWarnings("unchecked")
     public static <T> T getNervousSystemContextBean(Class<T> type, String name) {
         return (T) RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBean(name);
     }
 
     @SuppressWarnings("unchecked")
     public static <T> Map<String, T> getBeansOfType(Class<T> type) {
             SpringResourceLoader springResourceLoader = RiceResourceLoaderFactory.getSpringResourceLoader();
             if ( springResourceLoader != null ) {
                     return new HashMap((Map) springResourceLoader.getContext().getBeansOfType(type));
             } else {
                     return new HashMap(0);
             }
     }
 
     public static String[] getBeanNames() {
         return RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanDefinitionNames();
     }
 
     public static Set<String> getSingletonNames() {
         Set<String> singletonNames = new HashSet<String>();
         Collections.addAll(singletonNames, RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory()
                 .getSingletonNames());
         return singletonNames;
     }
 
     public static Set<Class> getSingletonTypes() {
         Set<Class> singletonTypes = new HashSet<Class>();
         for (String singletonName : getSingletonNames()) {
             singletonTypes.add(RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory().getType(
                     singletonName));
         }
         return singletonTypes;
     }
 
     public static boolean isSingleton( String beanName ) {
             try {
                 return RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory().isSingleton(beanName);
             } catch ( NoSuchBeanDefinitionException ex ) {
                 // service is not in Spring so we can't assume
                 return false;
             }
     }
             
     public static List<NamedOrderedListBean> getNamedOrderedListBeans(String listName) {
         List<NamedOrderedListBean> namedOrderedListBeans = new ArrayList<NamedOrderedListBean>();
         for (Object namedOrderedListBean : RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeansOfType(
                 NamedOrderedListBean.class).values()) {
             if (((NamedOrderedListBean) namedOrderedListBean).getName().equals(listName)) {
                 namedOrderedListBeans.add((NamedOrderedListBean) namedOrderedListBean);
             }
         }
         return namedOrderedListBeans;
     }
 
     public static final String ENCRYPTION_SERVICE = "encryptionService";
 
     public static final EncryptionService getEncryptionService() {
         return (EncryptionService) getService(ENCRYPTION_SERVICE);
     }
     
     public static final String POST_DATA_LOAD_ENCRYPTION_SERVICE = "postDataLoadEncryptionService";
     
     public static final PostDataLoadEncryptionService getPostDataLoadEncryptionService() {
             return (PostDataLoadEncryptionService) getService(POST_DATA_LOAD_ENCRYPTION_SERVICE);
     }
     
         public static final String EXCEPTION_INCIDENT_REPORT_SERVICE = "knsExceptionIncidentService";
     public static final KualiExceptionIncidentService getKualiExceptionIncidentService() {
             return (KualiExceptionIncidentService) getService(EXCEPTION_INCIDENT_REPORT_SERVICE);
     }
 
 
     public static final String MAIL_SERVICE = "mailService";
 
     public static final MailService getMailService() {
         return (MailService) getService(MAIL_SERVICE);
     }
 
     public static final String METHOD_CACHE_INTERCEPTOR = "methodCacheInterceptor";
 
     public static MethodCacheInterceptor getMethodCacheInterceptor() {
         return (MethodCacheInterceptor) getService(METHOD_CACHE_INTERCEPTOR);
     }
 
     public static final String BUSINESS_OBJECT_AUTHORIZATION_SERVICE = "businessObjectAuthorizationService";
 
     public static BusinessObjectAuthorizationService getBusinessObjectAuthorizationService() {
         return (BusinessObjectAuthorizationService) getService(BUSINESS_OBJECT_AUTHORIZATION_SERVICE);
     }
 
     public static final String XML_OBJECT_SERIALIZER_SERVICE = "xmlObjectSerializerService";
 
     public static XmlObjectSerializerService getXmlObjectSerializerService() {
         return (XmlObjectSerializerService) getService(XML_OBJECT_SERIALIZER_SERVICE);
     }
 
     public static final String DOCUMENT_SERVICE = "documentService";
 
     public static DocumentService getDocumentService() {
         return (DocumentService) getService(DOCUMENT_SERVICE);
     }
 
     public static final String DOCUMENT_HEADER_SERVICE = "documentHeaderService";
 
     public static DocumentHeaderService getDocumentHeaderService() {
     return (DocumentHeaderService) getService(DOCUMENT_HEADER_SERVICE);
     }
 
     public static final String POST_PROCESSOR_SERVICE = "postProcessorService";
 
     public static PostProcessorService getPostProcessorService() {
         return (PostProcessorService) getService(POST_PROCESSOR_SERVICE);
     }
 
     public static final String DATETIME_SERVICE = "dateTimeService";
 
     public static DateTimeService getDateTimeService() {
         return (DateTimeService) getService(DATETIME_SERVICE);
     }
 
     public static final String LOOKUP_SERVICE = "lookupService";
 
     public static LookupService getLookupService() {
         return (LookupService) getService(LOOKUP_SERVICE);
     }
 
     public static final String LOOKUP_RESULTS_SERVICE = "lookupResultsService";
 
     public static LookupResultsService getLookupResultsService() {
         return (LookupResultsService) getService(LOOKUP_RESULTS_SERVICE);
     }
 
     public static final String KUALI_MODULE_SERVICE = "kualiModuleService";
 
     public static KualiModuleService getKualiModuleService() {
         return (KualiModuleService) getService(KUALI_MODULE_SERVICE);
     }
 
     public static final String WORKFLOW_DOCUMENT_SERVICE = "workflowDocumentService";
 
     public static WorkflowDocumentService getWorkflowDocumentService() {
         return (WorkflowDocumentService) getService(WORKFLOW_DOCUMENT_SERVICE);
     }
 
     public static final String WORKFLOW_INFO_SERVICE = "workflowInfoService";
 
     public static KualiWorkflowInfo getWorkflowInfoService() {
         return (KualiWorkflowInfo) getService(WORKFLOW_INFO_SERVICE);
     }
 
     public static final String KUALI_CONFIGURATION_SERVICE = "kualiConfigurationService";
 
     public static KualiConfigurationService getKualiConfigurationService() {
         return (KualiConfigurationService) getService(KUALI_CONFIGURATION_SERVICE);
     }
     
     public static final String PARAMETER_SERVICE = "parameterService";
     
     public static ParameterService getParameterService() {
             return (ParameterService) getService(PARAMETER_SERVICE);
     }
     
     public static final String PARAMETER_SERVER_SERVICE = "parameterServerService";
     
     public static ParameterServerService getParameterServerService() {
             return (ParameterServerService) getService(PARAMETER_SERVER_SERVICE);
     }
 
     public static final String BUSINESS_OBJECT_DICTIONARY_SERVICE = "businessObjectDictionaryService";
 
     public static BusinessObjectDictionaryService getBusinessObjectDictionaryService() {
         return (BusinessObjectDictionaryService) getService(BUSINESS_OBJECT_DICTIONARY_SERVICE);
     }
 
     public static final String BUSINESS_OBJECT_METADATA_SERVICE = "businessObjectMetaDataService";
 
     public static BusinessObjectMetaDataService getBusinessObjectMetaDataService() {
         return (BusinessObjectMetaDataService) getService(BUSINESS_OBJECT_METADATA_SERVICE);
     }
 
     public static final String TRANSACTIONAL_DOCUMENT_DICTIONARY_SERVICE = "transactionalDocumentDictionaryService";
 
     public static TransactionalDocumentDictionaryService getTransactionalDocumentDictionaryService() {
         return (TransactionalDocumentDictionaryService) getService(TRANSACTIONAL_DOCUMENT_DICTIONARY_SERVICE);
     }
 
     public static final String MAINTENANCE_DOCUMENT_DICTIONARY_SERVICE = "maintenanceDocumentDictionaryService";
 
     public static MaintenanceDocumentDictionaryService getMaintenanceDocumentDictionaryService() {
         return (MaintenanceDocumentDictionaryService) getService(MAINTENANCE_DOCUMENT_DICTIONARY_SERVICE);
     }
 
     public static final String DATA_DICTIONARY_SERVICE = "dataDictionaryService";
 
     public static DataDictionaryService getDataDictionaryService() {
         return (DataDictionaryService) getService(DATA_DICTIONARY_SERVICE);
     }
 
     public static final String MAINTENANCE_DOCUMENT_SERVICE = "maintenanceDocumentService";
 
     public static MaintenanceDocumentService getMaintenanceDocumentService() {
         return (MaintenanceDocumentService) getService(MAINTENANCE_DOCUMENT_SERVICE);
     }
 
     public static final String NOTE_SERVICE = "noteService";
 
     public static NoteService getNoteService() {
         return (NoteService) getService(NOTE_SERVICE);
     }
 
     public static final String PERSISTENCE_SERVICE = "persistenceService";
 
     public static PersistenceService getPersistenceService() {
         return (PersistenceService) getService(PERSISTENCE_SERVICE);
     }
 
     public static final String PERSISTENCE_STRUCTURE_SERVICE = "persistenceStructureService";
 
     public static PersistenceStructureService getPersistenceStructureService() {
         return (PersistenceStructureService) getService(PERSISTENCE_STRUCTURE_SERVICE);
     }
 
     public static final String KUALI_RULE_SERVICE = "kualiRuleService";
 
     public static KualiRuleService getKualiRuleService() {
         return (KualiRuleService) getService(KUALI_RULE_SERVICE);
     }
 
     public static final String BUSINESS_OBJECT_SERVICE = "businessObjectService";
 
     public static BusinessObjectService getBusinessObjectService() {
         return (BusinessObjectService) getService(BUSINESS_OBJECT_SERVICE);
     }
 
     public static final String NAMESPACE_SERVICE = "namespaceService";
 
     public static NamespaceService getNamespaceService() {
         return (NamespaceService) getService(NAMESPACE_SERVICE);
     }
     
     // special ones for Inquirable and Lookupable
     public static final String KUALI_INQUIRABLE = "kualiInquirable";
 
     public static Inquirable getKualiInquirable() {
         return (Inquirable) getService(KUALI_INQUIRABLE);
     }
 
     public static final String KUALI_LOOKUPABLE = "kualiLookupable";
 
     public static Lookupable getKualiLookupable() {
         return (Lookupable) getService(KUALI_LOOKUPABLE);
     }
 
     public static Lookupable getLookupable(String lookupableName) {
         return (Lookupable) getService(lookupableName);
     }
 
     // special one for QuestionPrompt
     public static Question getQuestion(String questionName) {
         return (Question) getService(questionName);
     }
 
     // DictionaryValidationService
     public static final String DICTIONARY_VALIDATION_SERVICE = "dictionaryValidationService";
 
     public static DictionaryValidationService getDictionaryValidationService() {
         return (DictionaryValidationService) getService(DICTIONARY_VALIDATION_SERVICE);
     }
 
     // AttachmentService
     public static final String ATTACHMENT_SERVICE = "attachmentService";
 
     public static AttachmentService getAttachmentService() {
         return (AttachmentService) getService(ATTACHMENT_SERVICE);
     }
 
     // SequenceAccessorService
     public static final String SEQUENCE_ACCESSOR_SERVICE = "sequenceAccessorService";
 
     public static SequenceAccessorService getSequenceAccessorService() {
         return (SequenceAccessorService) getService(SEQUENCE_ACCESSOR_SERVICE);
     }
 
     // KeyValuesService
     public static final String KEY_VALUES_SERVICE = "keyValuesService";
 
     public static KeyValuesService getKeyValuesService() {
         return (KeyValuesService) getService(KEY_VALUES_SERVICE);
     }
 
     public static final String OJB_COLLECTION_HELPER = "ojbCollectionHelper";
 
     public static OjbCollectionHelper getOjbCollectionHelper() {
         return (OjbCollectionHelper) getService(OJB_COLLECTION_HELPER);
     }
 
     public static final String PERSISTENCE_CACHE_ADMINISTRATOR = "persistenceCacheAdministrator";
 
     public static final GeneralCacheAdministrator getPersistenceCacheAdministrator() {
         return (GeneralCacheAdministrator) getService(PERSISTENCE_CACHE_ADMINISTRATOR);
     }
 
     public static final String TRANSACTION_MANAGER = "transactionManager";
 
     public static PlatformTransactionManager getTransactionManager() {
         return (PlatformTransactionManager) getService(TRANSACTION_MANAGER);
     }
 
     public static final String TRANSACTION_TEMPLATE = "transactionTemplate";
 
     public static TransactionTemplate getTransactionTemplate() {
         return (TransactionTemplate) getService(TRANSACTION_TEMPLATE);
     }
         
     public static final String PESSIMISTIC_LOCK_SERVICE = "pessimisticLockService";
     
     public static PessimisticLockService getPessimisticLockService() {
         return (PessimisticLockService) getService(PESSIMISTIC_LOCK_SERVICE);
     }
     
     public static final String DOCUMENT_SERIALIZER_SERVICE = "documentSerializerService";
     
     public static DocumentSerializerService getDocumentSerializerService() {
         return (DocumentSerializerService) getService(DOCUMENT_SERIALIZER_SERVICE);
     }
     
     public static final String ENTITY_MANAGER_FACTORY = "entityManagerFactory";
 
     public static EntityManagerFactory getEntityManagerFactory() {
             return (EntityManagerFactory) getService(ENTITY_MANAGER_FACTORY);
     }
 
     public static final String PERSISTENCE_SERVICE_OJB = "persistenceServiceOjb";
     
     public static PersistenceService getPersistenceServiceOjb() {
         return (PersistenceService) getService(PERSISTENCE_SERVICE_OJB);
     }
     
     public static final String SESSION_DOCUMENT_SERVICE = "sessionDocumentService";
 
     public static SessionDocumentService getSessionDocumentService() {
         return (SessionDocumentService) getService(SESSION_DOCUMENT_SERVICE);
     }
 
     public static final String DEFAULT_INACTIVATION_BLOCKING_DETECTION_SERVICE = "inactivationBlockingDetectionService";
     
     public static InactivationBlockingDetectionService getInactivationBlockingDetectionService(String serviceName) {
         return (InactivationBlockingDetectionService) getService(serviceName);
     }
     
     public static final String INACTIVATION_BLOCKING_DISPLAY_SERVICE = "inactivationBlockingDisplayService";
     
     public static InactivationBlockingDisplayService getInactivationBlockingDisplayService() {
             return (InactivationBlockingDisplayService) getService(INACTIVATION_BLOCKING_DISPLAY_SERVICE);
     }
     
     public static final String SERIALIZER_SERVICE = "businessObjectSerializerService";
     
     public static BusinessObjectSerializerService getBusinessObjectSerializerService() {
         return (BusinessObjectSerializerService) getService(SERIALIZER_SERVICE);
     }
     
     public static final String COUNTRY_SERVICE = "countryService";
 
     public static CountryService getCountryService() {
         return (CountryService) getService(COUNTRY_SERVICE);
     }
     
     public static final String STATE_SERVICE = "stateService";
 
     public static StateService getStateService() {
         return (StateService) getService(STATE_SERVICE);
     }
     
     public static final String DOCUMENT_DAO = "documentDao";
     
     public static DocumentDao getDocumentDao() {
         return (DocumentDao) getService(DOCUMENT_DAO);
     }
     
     public static final String BUSINESS_OBJECT_DAO = "businessObjectDao";
     
     public static BusinessObjectDao getBusinessObjectDao() {
         return (BusinessObjectDao) getService(BUSINESS_OBJECT_DAO);
     }
     
 
    public static final String DB_PLATFORM = "dbPlatform";
     
     public static DatabasePlatform getDatabasePlatform() {
         return (DatabasePlatform) getService(DB_PLATFORM);
     }
     
     public static final String MAINTENANCE_DOCUMENT_AUTHORIZATION_SERVICE = "maintenanceDocumentAuthorizationService";
     
     public static BusinessObjectAuthorizationService getMaintenanceDocumentAuthorizationService() {
             return (BusinessObjectAuthorizationService) getService(MAINTENANCE_DOCUMENT_AUTHORIZATION_SERVICE);
     }
     
     public static final String DOCUMENT_HELPER_SERVICE = "documentHelperService";
     
     public static DocumentHelperService getDocumentHelperService() {
         return (DocumentHelperService) getService(DOCUMENT_HELPER_SERVICE);
     }
     
     public static final String RICE_APPLICATION_CONFIGURATION_SERVICE = "riceApplicationConfigurationService";
     
     public static RiceApplicationConfigurationService getRiceApplicationConfigurationService() {
             return (RiceApplicationConfigurationService) getService(RICE_APPLICATION_CONFIGURATION_SERVICE);
     }
 
     public static final String RICE_APPLICATION_CONFIGURATION_MEDIATION_SERVICE = "riceApplicationConfigurationMediationService";
     
     public static RiceApplicationConfigurationMediationService getRiceApplicationConfigurationMediationService() {
             return (RiceApplicationConfigurationMediationService) getService(RICE_APPLICATION_CONFIGURATION_MEDIATION_SERVICE);
     }
     
     public static final String WORKFLOW_ATTRIBUTE_PROPERTY_RESOLUTION_SERVICE = "workflowAttributesPropertyResolutionService";
     
     public static WorkflowAttributePropertyResolutionService getWorkflowAttributePropertyResolutionService() {
             return (WorkflowAttributePropertyResolutionService) getService(WORKFLOW_ATTRIBUTE_PROPERTY_RESOLUTION_SERVICE);
     }
     
     public static final String INACTIVATEABLE_FROM_TO_SERVICE = "inactivateableFromToService";
     
     public static InactivateableFromToService getInactivateableFromToService() {
             return (InactivateableFromToService) getService(INACTIVATEABLE_FROM_TO_SERVICE);
     }
     
 }

1		/*
2		* Copyright 2007 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License"); you may not use this file except in
5		* compliance with the License. You may obtain a copy of the License at
6		*
7		* http://www.opensource.org/licenses/ecl2.php
8		*
9		* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS
10		* IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
11		* language governing permissions and limitations under the License.
12		*/
13		package org.kuali.rice.kns.service;
14
15		import java.util.ArrayList;
16		import java.util.Collection;
17		import java.util.Collections;
18		import java.util.HashMap;
19		import java.util.HashSet;
20		import java.util.List;
21		import java.util.Map;
22		import java.util.Set;
23
24		import javax.persistence.EntityManagerFactory;
25
26		import org.kuali.rice.core.database.platform.DatabasePlatform;
27		import org.kuali.rice.core.resourceloader.GlobalResourceLoader;
28		import org.kuali.rice.core.resourceloader.RiceResourceLoaderFactory;
29		import org.kuali.rice.core.resourceloader.SpringResourceLoader;
30		import org.kuali.rice.core.service.EncryptionService;
31		import org.kuali.rice.kns.dao.BusinessObjectDao;
32		import org.kuali.rice.kns.dao.DocumentDao;
33		import org.kuali.rice.kns.inquiry.Inquirable;
34		import org.kuali.rice.kns.lookup.LookupResultsService;
35		import org.kuali.rice.kns.lookup.Lookupable;
36		import org.kuali.rice.kns.question.Question;
37		import org.kuali.rice.kns.util.OjbCollectionHelper;
38		import org.kuali.rice.kns.util.cache.MethodCacheInterceptor;
39		import org.kuali.rice.kns.util.spring.NamedOrderedListBean;
40		import org.kuali.rice.kns.workflow.service.KualiWorkflowInfo;
41		import org.kuali.rice.kns.workflow.service.WorkflowAttributePropertyResolutionService;
42		import org.kuali.rice.kns.workflow.service.WorkflowDocumentService;
43		import org.springframework.beans.factory.NoSuchBeanDefinitionException;
44		import org.springframework.transaction.PlatformTransactionManager;
45		import org.springframework.transaction.support.TransactionTemplate;
46
47		import com.opensymphony.oscache.general.GeneralCacheAdministrator;
48
49	0	public class KNSServiceLocator<T extends Object> {
50
51		public static final String VALIDATION_COMPLETION_UTILS = "validationCompletionUtils";
52
53		public static Object getService(String serviceName) {
54	0	return GlobalResourceLoader.getService(serviceName);
55		}
56
57		public static <T> T getNervousSystemContextBean(Class<T> type) {
58	0	Collection<T> beansOfType = getBeansOfType(type).values();
59	0	if (beansOfType.isEmpty()) {
60	0	throw new NoSuchBeanDefinitionException("No beans of this type in the KNS application context: "
61		+ type.getName());
62		}
63	0	if (beansOfType.size() > 1) {
64	0	return getNervousSystemContextBean(type, type.getSimpleName().substring(0, 1).toLowerCase() + type.getSimpleName().substring(1));
65		}
66	0	return beansOfType.iterator().next();
67		}
68
69		@SuppressWarnings("unchecked")
70		public static <T> T getNervousSystemContextBean(Class<T> type, String name) {
71	0	return (T) RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBean(name);
72		}
73
74		@SuppressWarnings("unchecked")
75		public static <T> Map<String, T> getBeansOfType(Class<T> type) {
76	0	SpringResourceLoader springResourceLoader = RiceResourceLoaderFactory.getSpringResourceLoader();
77	0	if ( springResourceLoader != null ) {
78	0	return new HashMap((Map) springResourceLoader.getContext().getBeansOfType(type));
79		} else {
80	0	return new HashMap(0);
81		}
82		}
83
84		public static String[] getBeanNames() {
85	0	return RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanDefinitionNames();
86		}
87
88		public static Set<String> getSingletonNames() {
89	0	Set<String> singletonNames = new HashSet<String>();
90	0	Collections.addAll(singletonNames, RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory()
91		.getSingletonNames());
92	0	return singletonNames;
93		}
94
95		public static Set<Class> getSingletonTypes() {
96	0	Set<Class> singletonTypes = new HashSet<Class>();
97	0	for (String singletonName : getSingletonNames()) {
98	0	singletonTypes.add(RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory().getType(
99		singletonName));
100		}
101	0	return singletonTypes;
102		}
103
104		public static boolean isSingleton( String beanName ) {
105		try {
106	0	return RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeanFactory().isSingleton(beanName);
107	0	} catch ( NoSuchBeanDefinitionException ex ) {
108		// service is not in Spring so we can't assume
109	0	return false;
110		}
111		}
112
113		public static List<NamedOrderedListBean> getNamedOrderedListBeans(String listName) {
114	0	List<NamedOrderedListBean> namedOrderedListBeans = new ArrayList<NamedOrderedListBean>();
115	0	for (Object namedOrderedListBean : RiceResourceLoaderFactory.getSpringResourceLoader().getContext().getBeansOfType(
116		NamedOrderedListBean.class).values()) {
117	0	if (((NamedOrderedListBean) namedOrderedListBean).getName().equals(listName)) {
118	0	namedOrderedListBeans.add((NamedOrderedListBean) namedOrderedListBean);
119		}
120		}
121	0	return namedOrderedListBeans;
122		}
123
124		public static final String ENCRYPTION_SERVICE = "encryptionService";
125
126		public static final EncryptionService getEncryptionService() {
127	0	return (EncryptionService) getService(ENCRYPTION_SERVICE);
128		}
129
130		public static final String POST_DATA_LOAD_ENCRYPTION_SERVICE = "postDataLoadEncryptionService";
131
132		public static final PostDataLoadEncryptionService getPostDataLoadEncryptionService() {
133	0	return (PostDataLoadEncryptionService) getService(POST_DATA_LOAD_ENCRYPTION_SERVICE);
134		}
135
136		public static final String EXCEPTION_INCIDENT_REPORT_SERVICE = "knsExceptionIncidentService";
137		public static final KualiExceptionIncidentService getKualiExceptionIncidentService() {
138	0	return (KualiExceptionIncidentService) getService(EXCEPTION_INCIDENT_REPORT_SERVICE);
139		}
140
141
142		public static final String MAIL_SERVICE = "mailService";
143
144		public static final MailService getMailService() {
145	0	return (MailService) getService(MAIL_SERVICE);
146		}
147
148		public static final String METHOD_CACHE_INTERCEPTOR = "methodCacheInterceptor";
149
150		public static MethodCacheInterceptor getMethodCacheInterceptor() {
151	0	return (MethodCacheInterceptor) getService(METHOD_CACHE_INTERCEPTOR);
152		}
153
154		public static final String BUSINESS_OBJECT_AUTHORIZATION_SERVICE = "businessObjectAuthorizationService";
155
156		public static BusinessObjectAuthorizationService getBusinessObjectAuthorizationService() {
157	0	return (BusinessObjectAuthorizationService) getService(BUSINESS_OBJECT_AUTHORIZATION_SERVICE);
158		}
159
160		public static final String XML_OBJECT_SERIALIZER_SERVICE = "xmlObjectSerializerService";
161
162		public static XmlObjectSerializerService getXmlObjectSerializerService() {
163	0	return (XmlObjectSerializerService) getService(XML_OBJECT_SERIALIZER_SERVICE);
164		}
165
166		public static final String DOCUMENT_SERVICE = "documentService";
167
168		public static DocumentService getDocumentService() {
169	0	return (DocumentService) getService(DOCUMENT_SERVICE);
170		}
171
172		public static final String DOCUMENT_HEADER_SERVICE = "documentHeaderService";
173
174		public static DocumentHeaderService getDocumentHeaderService() {
175	0	return (DocumentHeaderService) getService(DOCUMENT_HEADER_SERVICE);
176		}
177
178		public static final String POST_PROCESSOR_SERVICE = "postProcessorService";
179
180		public static PostProcessorService getPostProcessorService() {
181	0	return (PostProcessorService) getService(POST_PROCESSOR_SERVICE);
182		}
183
184		public static final String DATETIME_SERVICE = "dateTimeService";
185
186		public static DateTimeService getDateTimeService() {
187	0	return (DateTimeService) getService(DATETIME_SERVICE);
188		}
189
190		public static final String LOOKUP_SERVICE = "lookupService";
191
192		public static LookupService getLookupService() {
193	0	return (LookupService) getService(LOOKUP_SERVICE);
194		}
195
196		public static final String LOOKUP_RESULTS_SERVICE = "lookupResultsService";
197
198		public static LookupResultsService getLookupResultsService() {
199	0	return (LookupResultsService) getService(LOOKUP_RESULTS_SERVICE);
200		}
201
202		public static final String KUALI_MODULE_SERVICE = "kualiModuleService";
203
204		public static KualiModuleService getKualiModuleService() {
205	0	return (KualiModuleService) getService(KUALI_MODULE_SERVICE);
206		}
207
208		public static final String WORKFLOW_DOCUMENT_SERVICE = "workflowDocumentService";
209
210		public static WorkflowDocumentService getWorkflowDocumentService() {
211	0	return (WorkflowDocumentService) getService(WORKFLOW_DOCUMENT_SERVICE);
212		}
213
214		public static final String WORKFLOW_INFO_SERVICE = "workflowInfoService";
215
216		public static KualiWorkflowInfo getWorkflowInfoService() {
217	0	return (KualiWorkflowInfo) getService(WORKFLOW_INFO_SERVICE);
218		}
219
220		public static final String KUALI_CONFIGURATION_SERVICE = "kualiConfigurationService";
221
222		public static KualiConfigurationService getKualiConfigurationService() {
223	0	return (KualiConfigurationService) getService(KUALI_CONFIGURATION_SERVICE);
224		}
225
226		public static final String PARAMETER_SERVICE = "parameterService";
227
228		public static ParameterService getParameterService() {
229	0	return (ParameterService) getService(PARAMETER_SERVICE);
230		}
231
232		public static final String PARAMETER_SERVER_SERVICE = "parameterServerService";
233
234		public static ParameterServerService getParameterServerService() {
235	0	return (ParameterServerService) getService(PARAMETER_SERVER_SERVICE);
236		}
237
238		public static final String BUSINESS_OBJECT_DICTIONARY_SERVICE = "businessObjectDictionaryService";
239
240		public static BusinessObjectDictionaryService getBusinessObjectDictionaryService() {
241	0	return (BusinessObjectDictionaryService) getService(BUSINESS_OBJECT_DICTIONARY_SERVICE);
242		}
243
244		public static final String BUSINESS_OBJECT_METADATA_SERVICE = "businessObjectMetaDataService";
245
246		public static BusinessObjectMetaDataService getBusinessObjectMetaDataService() {
247	0	return (BusinessObjectMetaDataService) getService(BUSINESS_OBJECT_METADATA_SERVICE);
248		}
249
250		public static final String TRANSACTIONAL_DOCUMENT_DICTIONARY_SERVICE = "transactionalDocumentDictionaryService";
251
252		public static TransactionalDocumentDictionaryService getTransactionalDocumentDictionaryService() {
253	0	return (TransactionalDocumentDictionaryService) getService(TRANSACTIONAL_DOCUMENT_DICTIONARY_SERVICE);
254		}
255
256		public static final String MAINTENANCE_DOCUMENT_DICTIONARY_SERVICE = "maintenanceDocumentDictionaryService";
257
258		public static MaintenanceDocumentDictionaryService getMaintenanceDocumentDictionaryService() {
259	0	return (MaintenanceDocumentDictionaryService) getService(MAINTENANCE_DOCUMENT_DICTIONARY_SERVICE);
260		}
261
262		public static final String DATA_DICTIONARY_SERVICE = "dataDictionaryService";
263
264		public static DataDictionaryService getDataDictionaryService() {
265	0	return (DataDictionaryService) getService(DATA_DICTIONARY_SERVICE);
266		}
267
268		public static final String MAINTENANCE_DOCUMENT_SERVICE = "maintenanceDocumentService";
269
270		public static MaintenanceDocumentService getMaintenanceDocumentService() {
271	0	return (MaintenanceDocumentService) getService(MAINTENANCE_DOCUMENT_SERVICE);
272		}
273
274		public static final String NOTE_SERVICE = "noteService";
275
276		public static NoteService getNoteService() {
277	0	return (NoteService) getService(NOTE_SERVICE);
278		}
279
280		public static final String PERSISTENCE_SERVICE = "persistenceService";
281
282		public static PersistenceService getPersistenceService() {
283	0	return (PersistenceService) getService(PERSISTENCE_SERVICE);
284		}
285
286		public static final String PERSISTENCE_STRUCTURE_SERVICE = "persistenceStructureService";
287
288		public static PersistenceStructureService getPersistenceStructureService() {
289	0	return (PersistenceStructureService) getService(PERSISTENCE_STRUCTURE_SERVICE);
290		}
291
292		public static final String KUALI_RULE_SERVICE = "kualiRuleService";
293
294		public static KualiRuleService getKualiRuleService() {
295	0	return (KualiRuleService) getService(KUALI_RULE_SERVICE);
296		}
297
298		public static final String BUSINESS_OBJECT_SERVICE = "businessObjectService";
299
300		public static BusinessObjectService getBusinessObjectService() {
301	0	return (BusinessObjectService) getService(BUSINESS_OBJECT_SERVICE);
302		}
303
304		public static final String NAMESPACE_SERVICE = "namespaceService";
305
306		public static NamespaceService getNamespaceService() {
307	0	return (NamespaceService) getService(NAMESPACE_SERVICE);
308		}
309
310		// special ones for Inquirable and Lookupable
311		public static final String KUALI_INQUIRABLE = "kualiInquirable";
312
313		public static Inquirable getKualiInquirable() {
314	0	return (Inquirable) getService(KUALI_INQUIRABLE);
315		}
316
317		public static final String KUALI_LOOKUPABLE = "kualiLookupable";
318
319		public static Lookupable getKualiLookupable() {
320	0	return (Lookupable) getService(KUALI_LOOKUPABLE);
321		}
322
323		public static Lookupable getLookupable(String lookupableName) {
324	0	return (Lookupable) getService(lookupableName);
325		}
326
327		// special one for QuestionPrompt
328		public static Question getQuestion(String questionName) {
329	0	return (Question) getService(questionName);
330		}
331
332		// DictionaryValidationService
333		public static final String DICTIONARY_VALIDATION_SERVICE = "dictionaryValidationService";
334
335		public static DictionaryValidationService getDictionaryValidationService() {
336	0	return (DictionaryValidationService) getService(DICTIONARY_VALIDATION_SERVICE);
337		}
338
339		// AttachmentService
340		public static final String ATTACHMENT_SERVICE = "attachmentService";
341
342		public static AttachmentService getAttachmentService() {
343	0	return (AttachmentService) getService(ATTACHMENT_SERVICE);
344		}
345
346		// SequenceAccessorService
347		public static final String SEQUENCE_ACCESSOR_SERVICE = "sequenceAccessorService";
348
349		public static SequenceAccessorService getSequenceAccessorService() {
350	0	return (SequenceAccessorService) getService(SEQUENCE_ACCESSOR_SERVICE);
351		}
352
353		// KeyValuesService
354		public static final String KEY_VALUES_SERVICE = "keyValuesService";
355
356		public static KeyValuesService getKeyValuesService() {
357	0	return (KeyValuesService) getService(KEY_VALUES_SERVICE);
358		}
359
360		public static final String OJB_COLLECTION_HELPER = "ojbCollectionHelper";
361
362		public static OjbCollectionHelper getOjbCollectionHelper() {
363	0	return (OjbCollectionHelper) getService(OJB_COLLECTION_HELPER);
364		}
365
366		public static final String PERSISTENCE_CACHE_ADMINISTRATOR = "persistenceCacheAdministrator";
367
368		public static final GeneralCacheAdministrator getPersistenceCacheAdministrator() {
369	0	return (GeneralCacheAdministrator) getService(PERSISTENCE_CACHE_ADMINISTRATOR);
370		}
371
372		public static final String TRANSACTION_MANAGER = "transactionManager";
373
374		public static PlatformTransactionManager getTransactionManager() {
375	0	return (PlatformTransactionManager) getService(TRANSACTION_MANAGER);
376		}
377
378		public static final String TRANSACTION_TEMPLATE = "transactionTemplate";
379
380		public static TransactionTemplate getTransactionTemplate() {
381	0	return (TransactionTemplate) getService(TRANSACTION_TEMPLATE);
382		}
383
384		public static final String PESSIMISTIC_LOCK_SERVICE = "pessimisticLockService";
385
386		public static PessimisticLockService getPessimisticLockService() {
387	0	return (PessimisticLockService) getService(PESSIMISTIC_LOCK_SERVICE);
388		}
389
390		public static final String DOCUMENT_SERIALIZER_SERVICE = "documentSerializerService";
391
392		public static DocumentSerializerService getDocumentSerializerService() {
393	0	return (DocumentSerializerService) getService(DOCUMENT_SERIALIZER_SERVICE);
394		}
395
396		public static final String ENTITY_MANAGER_FACTORY = "entityManagerFactory";
397
398		public static EntityManagerFactory getEntityManagerFactory() {
399	0	return (EntityManagerFactory) getService(ENTITY_MANAGER_FACTORY);
400		}
401
402		public static final String PERSISTENCE_SERVICE_OJB = "persistenceServiceOjb";
403
404		public static PersistenceService getPersistenceServiceOjb() {
405	0	return (PersistenceService) getService(PERSISTENCE_SERVICE_OJB);
406		}
407
408		public static final String SESSION_DOCUMENT_SERVICE = "sessionDocumentService";
409
410		public static SessionDocumentService getSessionDocumentService() {
411	0	return (SessionDocumentService) getService(SESSION_DOCUMENT_SERVICE);
412		}
413
414		public static final String DEFAULT_INACTIVATION_BLOCKING_DETECTION_SERVICE = "inactivationBlockingDetectionService";
415
416		public static InactivationBlockingDetectionService getInactivationBlockingDetectionService(String serviceName) {
417	0	return (InactivationBlockingDetectionService) getService(serviceName);
418		}
419
420		public static final String INACTIVATION_BLOCKING_DISPLAY_SERVICE = "inactivationBlockingDisplayService";
421
422		public static InactivationBlockingDisplayService getInactivationBlockingDisplayService() {
423	0	return (InactivationBlockingDisplayService) getService(INACTIVATION_BLOCKING_DISPLAY_SERVICE);
424		}
425
426		public static final String SERIALIZER_SERVICE = "businessObjectSerializerService";
427
428		public static BusinessObjectSerializerService getBusinessObjectSerializerService() {
429	0	return (BusinessObjectSerializerService) getService(SERIALIZER_SERVICE);
430		}
431
432		public static final String COUNTRY_SERVICE = "countryService";
433
434		public static CountryService getCountryService() {
435	0	return (CountryService) getService(COUNTRY_SERVICE);
436		}
437
438		public static final String STATE_SERVICE = "stateService";
439
440		public static StateService getStateService() {
441	0	return (StateService) getService(STATE_SERVICE);
442		}
443
444		public static final String DOCUMENT_DAO = "documentDao";
445
446		public static DocumentDao getDocumentDao() {
447	0	return (DocumentDao) getService(DOCUMENT_DAO);
448		}
449
450		public static final String BUSINESS_OBJECT_DAO = "businessObjectDao";
451
452		public static BusinessObjectDao getBusinessObjectDao() {
453	0	return (BusinessObjectDao) getService(BUSINESS_OBJECT_DAO);
454		}
455
456
457		public static final String DB_PLATFORM = "dbPlatform";
458
459		public static DatabasePlatform getDatabasePlatform() {
460	0	return (DatabasePlatform) getService(DB_PLATFORM);
461		}
462
463		public static final String MAINTENANCE_DOCUMENT_AUTHORIZATION_SERVICE = "maintenanceDocumentAuthorizationService";
464
465		public static BusinessObjectAuthorizationService getMaintenanceDocumentAuthorizationService() {
466	0	return (BusinessObjectAuthorizationService) getService(MAINTENANCE_DOCUMENT_AUTHORIZATION_SERVICE);
467		}
468
469		public static final String DOCUMENT_HELPER_SERVICE = "documentHelperService";
470
471		public static DocumentHelperService getDocumentHelperService() {
472	0	return (DocumentHelperService) getService(DOCUMENT_HELPER_SERVICE);
473		}
474
475		public static final String RICE_APPLICATION_CONFIGURATION_SERVICE = "riceApplicationConfigurationService";
476
477		public static RiceApplicationConfigurationService getRiceApplicationConfigurationService() {
478	0	return (RiceApplicationConfigurationService) getService(RICE_APPLICATION_CONFIGURATION_SERVICE);
479		}
480
481		public static final String RICE_APPLICATION_CONFIGURATION_MEDIATION_SERVICE = "riceApplicationConfigurationMediationService";
482
483		public static RiceApplicationConfigurationMediationService getRiceApplicationConfigurationMediationService() {
484	0	return (RiceApplicationConfigurationMediationService) getService(RICE_APPLICATION_CONFIGURATION_MEDIATION_SERVICE);
485		}
486
487		public static final String WORKFLOW_ATTRIBUTE_PROPERTY_RESOLUTION_SERVICE = "workflowAttributesPropertyResolutionService";
488
489		public static WorkflowAttributePropertyResolutionService getWorkflowAttributePropertyResolutionService() {
490	0	return (WorkflowAttributePropertyResolutionService) getService(WORKFLOW_ATTRIBUTE_PROPERTY_RESOLUTION_SERVICE);
491		}
492
493		public static final String INACTIVATEABLE_FROM_TO_SERVICE = "inactivateableFromToService";
494
495		public static InactivateableFromToService getInactivateableFromToService() {
496	0	return (InactivateableFromToService) getService(INACTIVATEABLE_FROM_TO_SERVICE);
497		}
498
499		}