Coverage Report

Coverage Report - org.kuali.rice.krad.datadictionary.DataDictionaryIndexMapper

Classes in this File

Line Coverage

Branch Coverage

Complexity

DataDictionaryIndexMapper

0/92

0/58

3.867

 /*
  * Copyright 2007-2010 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.krad.datadictionary;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
 import org.kuali.rice.krad.service.ModuleService;
 import org.kuali.rice.krad.uif.container.View;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * A DataDictionaryMapper that simply consults the statically initialized
  * DataDictionaryIndex mappings
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class DataDictionaryIndexMapper implements DataDictionaryMapper {
         private static final Logger LOG = Logger.getLogger(DataDictionaryIndexMapper.class);
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getAllInactivationBlockingMetadatas(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.Class)
          */
         public Set<InactivationBlockingMetadata> getAllInactivationBlockingMetadatas(DataDictionaryIndex index, Class<?> blockedClass) {
         return index.getInactivationBlockersForClass().get(blockedClass);
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectClassNames(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
          */
         public List<String> getBusinessObjectClassNames(DataDictionaryIndex index) {
                 List classNames = new ArrayList();
                 classNames.addAll(index.getBusinessObjectEntries().keySet());
 
                 return Collections.unmodifiableList(classNames);
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectEntries(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
          */
         public Map<String, BusinessObjectEntry> getBusinessObjectEntries(DataDictionaryIndex index) {
                 return index.getBusinessObjectEntries();
         }
 
         /**
      * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDataObjectEntryForConcreteClass(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
      */
         @Override
     public DataObjectEntry getDataObjectEntryForConcreteClass(DataDictionaryIndex ddIndex, String className) {
             if (StringUtils.isBlank(className)) {
             throw new IllegalArgumentException("invalid (blank) className");
         }
         if ( LOG.isDebugEnabled() ) {
             LOG.debug("calling getDataObjectEntry '" + className + "'");
         }
         
         String trimmedClassName = className;
         int index = className.indexOf("$$");
         if (index >= 0) {
             trimmedClassName = className.substring(0, index);
         }
         return ddIndex.getDataObjectEntries().get(trimmedClassName);
     }
 
     /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectEntryForConcreteClass(java.lang.String)
          */
         public BusinessObjectEntry getBusinessObjectEntryForConcreteClass(DataDictionaryIndex ddIndex, String className) {
                 if (StringUtils.isBlank(className)) {
                         throw new IllegalArgumentException("invalid (blank) className");
                 }
                 if ( LOG.isDebugEnabled() ) {
                     LOG.debug("calling getBusinessObjectEntry '" + className + "'");
                 }
                 int index = className.indexOf("$$");
                 if (index >= 0) {
                         className = className.substring(0, index);
                 }
                 return ddIndex.getBusinessObjectEntries().get(className);
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDictionaryObjectEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
          */
         public DataDictionaryEntry getDictionaryObjectEntry(DataDictionaryIndex ddIndex, String className) {
                 if (StringUtils.isBlank(className)) {
                         throw new IllegalArgumentException("invalid (blank) className");
                 }
                 if ( LOG.isDebugEnabled() ) {
                     LOG.debug("calling getDictionaryObjectEntry '" + className + "'");
                 }
                 int index = className.indexOf("$$");
                 if (index >= 0) {
                         className = className.substring(0, index);
                 }
 
                 // look in the JSTL key cache
                 DataDictionaryEntry entry = ddIndex.getEntriesByJstlKey().get(className);
                 
                 // check the Object list
                 if (entry == null){
                         entry = ddIndex.getDataObjectEntries().get(className);
                 }
                 // check the document list
                 if ( entry == null ) {
                     entry = getDocumentEntry(ddIndex, className);
                 }
                 return entry;
         }
 
         /**
      * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDataObjectEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
      */
         @Override
     public DataObjectEntry getDataObjectEntry(DataDictionaryIndex index, String className) {
             DataObjectEntry entry = getDataObjectEntryForConcreteClass(index, className);
             
         if (entry == null) {
             Class<?> boClass = null;
             try{
                 boClass = Class.forName(className);
                 ModuleService responsibleModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
                 if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)) {
                     entry = responsibleModuleService.getExternalizableBusinessObjectDictionaryEntry(boClass);
                 }
             } catch(ClassNotFoundException cnfex){
                 // swallow so we can return null
             }
         }
         
         return entry;
     }
 
         public BusinessObjectEntry getBusinessObjectEntry(DataDictionaryIndex index, String className ) {
                 BusinessObjectEntry entry = getBusinessObjectEntryForConcreteClass(index, className);
                 if (entry == null) {
                         Class boClass = null;
                         try{
                                 boClass = Class.forName(className);
                                 ModuleService responsibleModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
                                 if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)) {
                                         return responsibleModuleService.getExternalizableBusinessObjectDictionaryEntry(boClass);
                                 }
                         } catch(ClassNotFoundException cnfex){
                         }
                         return null;
                 }
                 else {
                         return entry;
                 }
         }
         
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentEntries(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
          */
         public Map<String, DocumentEntry> getDocumentEntries(DataDictionaryIndex index) {
                 return Collections.unmodifiableMap(index.getDocumentEntries());
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
          */
         public DocumentEntry getDocumentEntry(DataDictionaryIndex index, String documentTypeDDKey) {
 
                 if (StringUtils.isBlank(documentTypeDDKey)) {
                         throw new IllegalArgumentException("invalid (blank) documentTypeName");
                 }
                 if ( LOG.isDebugEnabled() ) {
                     LOG.debug("calling getDocumentEntry by documentTypeName '" + documentTypeDDKey + "'");
                 }
 
                 DocumentEntry de = index.getDocumentEntries().get(documentTypeDDKey);        
                 
                 if ( de == null ) {
                     try {
                         Class<?> clazz = Class.forName( documentTypeDDKey );
                         de = index.getDocumentEntriesByBusinessObjectClass().get(clazz);
                         if ( de == null ) {
                             de = index.getDocumentEntriesByMaintainableClass().get(clazz);
                         }
                     } catch ( ClassNotFoundException ex ) {
                         LOG.warn( "Unable to find document entry for key: " + documentTypeDDKey );
                     }
                 }
                 
         return de;
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentTypeName(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
          */
         public String getDocumentTypeName(DataDictionaryIndex index,
                         String documentTypeName) {
                 // TODO arh14 - THIS METHOD NEEDS JAVADOCS
                 return null;
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getMaintenanceDocumentEntryForBusinessObjectClass(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.Class)
          */
         public MaintenanceDocumentEntry getMaintenanceDocumentEntryForBusinessObjectClass(DataDictionaryIndex index, Class<?> businessObjectClass) {
                 if (businessObjectClass == null) {
                         throw new IllegalArgumentException("invalid (null) dataObjectClass");
                 }
                 if ( LOG.isDebugEnabled() ) {
                     LOG.debug("calling getDocumentEntry by dataObjectClass '" + businessObjectClass + "'");
                 }
 
                 return (MaintenanceDocumentEntry) index.getDocumentEntriesByBusinessObjectClass().get(businessObjectClass);
         }
         
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewById(org.kuali.rice.krad.datadictionary.view.ViewDictionaryIndex,
          *      java.lang.String)
          */
         public View getViewById(UifDictionaryIndex index, String viewId) {
                 if (StringUtils.isBlank(viewId)) {
                         throw new IllegalArgumentException("invalid (blank) view id");
                 }
                 if (LOG.isDebugEnabled()) {
                         LOG.debug("calling getViewById by id '" + viewId + "'");
                 }
 
                 return index.getViewById(viewId);
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewByTypeIndex(UifDictionaryIndex,
          *      java.lang.String, java.util.Map)
          */
         public View getViewByTypeIndex(UifDictionaryIndex index, String viewTypeName, Map<String, String> indexKey) {
                 if (StringUtils.isBlank(viewTypeName)) {
                         throw new IllegalArgumentException("invalid (blank) view type name");
                 }
                 if ((indexKey == null) || indexKey.isEmpty()) {
                         throw new IllegalArgumentException("index key must have at least one entry");
                 }
 
                 return index.getViewByTypeIndex(viewTypeName, indexKey);
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewsForType(UifDictionaryIndex,
          *      java.lang.String)
          */
         public List<View> getViewsForType(UifDictionaryIndex index, String viewTypeName) {
                 if (StringUtils.isBlank(viewTypeName)) {
                         throw new IllegalArgumentException("invalid (blank) view type name");
                 }
 
                 return index.getViewsForType(viewTypeName);
         }
 
 }

1		/*
2		* Copyright 2007-2010 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.krad.datadictionary;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.apache.log4j.Logger;
20		import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
21		import org.kuali.rice.krad.service.ModuleService;
22		import org.kuali.rice.krad.uif.container.View;
23
24		import java.util.ArrayList;
25		import java.util.Collections;
26		import java.util.List;
27		import java.util.Map;
28		import java.util.Set;
29
30		/**
31		* A DataDictionaryMapper that simply consults the statically initialized
32		* DataDictionaryIndex mappings
33		*
34		* @author Kuali Rice Team (rice.collab@kuali.org)
35		*/
36	0	public class DataDictionaryIndexMapper implements DataDictionaryMapper {
37	0	private static final Logger LOG = Logger.getLogger(DataDictionaryIndexMapper.class);
38
39		/**
40		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getAllInactivationBlockingMetadatas(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.Class)
41		*/
42		public Set<InactivationBlockingMetadata> getAllInactivationBlockingMetadatas(DataDictionaryIndex index, Class<?> blockedClass) {
43	0	return index.getInactivationBlockersForClass().get(blockedClass);
44		}
45
46		/**
47		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectClassNames(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
48		*/
49		public List<String> getBusinessObjectClassNames(DataDictionaryIndex index) {
50	0	List classNames = new ArrayList();
51	0	classNames.addAll(index.getBusinessObjectEntries().keySet());
52
53	0	return Collections.unmodifiableList(classNames);
54		}
55
56		/**
57		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectEntries(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
58		*/
59		public Map<String, BusinessObjectEntry> getBusinessObjectEntries(DataDictionaryIndex index) {
60	0	return index.getBusinessObjectEntries();
61		}
62
63		/**
64		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDataObjectEntryForConcreteClass(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
65		*/
66		@Override
67		public DataObjectEntry getDataObjectEntryForConcreteClass(DataDictionaryIndex ddIndex, String className) {
68	0	if (StringUtils.isBlank(className)) {
69	0	throw new IllegalArgumentException("invalid (blank) className");
70		}
71	0	if ( LOG.isDebugEnabled() ) {
72	0	LOG.debug("calling getDataObjectEntry '" + className + "'");
73		}
74
75	0	String trimmedClassName = className;
76	0	int index = className.indexOf("$$");
77	0	if (index >= 0) {
78	0	trimmedClassName = className.substring(0, index);
79		}
80	0	return ddIndex.getDataObjectEntries().get(trimmedClassName);
81		}
82
83		/**
84		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getBusinessObjectEntryForConcreteClass(java.lang.String)
85		*/
86		public BusinessObjectEntry getBusinessObjectEntryForConcreteClass(DataDictionaryIndex ddIndex, String className) {
87	0	if (StringUtils.isBlank(className)) {
88	0	throw new IllegalArgumentException("invalid (blank) className");
89		}
90	0	if ( LOG.isDebugEnabled() ) {
91	0	LOG.debug("calling getBusinessObjectEntry '" + className + "'");
92		}
93	0	int index = className.indexOf("$$");
94	0	if (index >= 0) {
95	0	className = className.substring(0, index);
96		}
97	0	return ddIndex.getBusinessObjectEntries().get(className);
98		}
99
100		/**
101		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDictionaryObjectEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
102		*/
103		public DataDictionaryEntry getDictionaryObjectEntry(DataDictionaryIndex ddIndex, String className) {
104	0	if (StringUtils.isBlank(className)) {
105	0	throw new IllegalArgumentException("invalid (blank) className");
106		}
107	0	if ( LOG.isDebugEnabled() ) {
108	0	LOG.debug("calling getDictionaryObjectEntry '" + className + "'");
109		}
110	0	int index = className.indexOf("$$");
111	0	if (index >= 0) {
112	0	className = className.substring(0, index);
113		}
114
115		// look in the JSTL key cache
116	0	DataDictionaryEntry entry = ddIndex.getEntriesByJstlKey().get(className);
117
118		// check the Object list
119	0	if (entry == null){
120	0	entry = ddIndex.getDataObjectEntries().get(className);
121		}
122		// check the document list
123	0	if ( entry == null ) {
124	0	entry = getDocumentEntry(ddIndex, className);
125		}
126	0	return entry;
127		}
128
129		/**
130		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDataObjectEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
131		*/
132		@Override
133		public DataObjectEntry getDataObjectEntry(DataDictionaryIndex index, String className) {
134	0	DataObjectEntry entry = getDataObjectEntryForConcreteClass(index, className);
135
136	0	if (entry == null) {
137	0	Class<?> boClass = null;
138		try{
139	0	boClass = Class.forName(className);
140	0	ModuleService responsibleModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
141	0	if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)) {
142	0	entry = responsibleModuleService.getExternalizableBusinessObjectDictionaryEntry(boClass);
143		}
144	0	} catch(ClassNotFoundException cnfex){
145		// swallow so we can return null
146	0	}
147		}
148
149	0	return entry;
150		}
151
152		public BusinessObjectEntry getBusinessObjectEntry(DataDictionaryIndex index, String className ) {
153	0	BusinessObjectEntry entry = getBusinessObjectEntryForConcreteClass(index, className);
154	0	if (entry == null) {
155	0	Class boClass = null;
156		try{
157	0	boClass = Class.forName(className);
158	0	ModuleService responsibleModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
159	0	if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)) {
160	0	return responsibleModuleService.getExternalizableBusinessObjectDictionaryEntry(boClass);
161		}
162	0	} catch(ClassNotFoundException cnfex){
163	0	}
164	0	return null;
165		}
166		else {
167	0	return entry;
168		}
169		}
170
171		/**
172		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentEntries(org.kuali.rice.krad.datadictionary.DataDictionaryIndex)
173		*/
174		public Map<String, DocumentEntry> getDocumentEntries(DataDictionaryIndex index) {
175	0	return Collections.unmodifiableMap(index.getDocumentEntries());
176		}
177
178		/**
179		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
180		*/
181		public DocumentEntry getDocumentEntry(DataDictionaryIndex index, String documentTypeDDKey) {
182
183	0	if (StringUtils.isBlank(documentTypeDDKey)) {
184	0	throw new IllegalArgumentException("invalid (blank) documentTypeName");
185		}
186	0	if ( LOG.isDebugEnabled() ) {
187	0	LOG.debug("calling getDocumentEntry by documentTypeName '" + documentTypeDDKey + "'");
188		}
189
190	0	DocumentEntry de = index.getDocumentEntries().get(documentTypeDDKey);
191
192	0	if ( de == null ) {
193		try {
194	0	Class<?> clazz = Class.forName( documentTypeDDKey );
195	0	de = index.getDocumentEntriesByBusinessObjectClass().get(clazz);
196	0	if ( de == null ) {
197	0	de = index.getDocumentEntriesByMaintainableClass().get(clazz);
198		}
199	0	} catch ( ClassNotFoundException ex ) {
200	0	LOG.warn( "Unable to find document entry for key: " + documentTypeDDKey );
201	0	}
202		}
203
204	0	return de;
205		}
206
207		/**
208		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDocumentTypeName(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.String)
209		*/
210		public String getDocumentTypeName(DataDictionaryIndex index,
211		String documentTypeName) {
212		// TODO arh14 - THIS METHOD NEEDS JAVADOCS
213	0	return null;
214		}
215
216		/**
217		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getMaintenanceDocumentEntryForBusinessObjectClass(org.kuali.rice.krad.datadictionary.DataDictionaryIndex, java.lang.Class)
218		*/
219		public MaintenanceDocumentEntry getMaintenanceDocumentEntryForBusinessObjectClass(DataDictionaryIndex index, Class<?> businessObjectClass) {
220	0	if (businessObjectClass == null) {
221	0	throw new IllegalArgumentException("invalid (null) dataObjectClass");
222		}
223	0	if ( LOG.isDebugEnabled() ) {
224	0	LOG.debug("calling getDocumentEntry by dataObjectClass '" + businessObjectClass + "'");
225		}
226
227	0	return (MaintenanceDocumentEntry) index.getDocumentEntriesByBusinessObjectClass().get(businessObjectClass);
228		}
229
230		/**
231		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewById(org.kuali.rice.krad.datadictionary.view.ViewDictionaryIndex,
232		* java.lang.String)
233		*/
234		public View getViewById(UifDictionaryIndex index, String viewId) {
235	0	if (StringUtils.isBlank(viewId)) {
236	0	throw new IllegalArgumentException("invalid (blank) view id");
237		}
238	0	if (LOG.isDebugEnabled()) {
239	0	LOG.debug("calling getViewById by id '" + viewId + "'");
240		}
241
242	0	return index.getViewById(viewId);
243		}
244
245		/**
246		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewByTypeIndex(UifDictionaryIndex,
247		* java.lang.String, java.util.Map)
248		*/
249		public View getViewByTypeIndex(UifDictionaryIndex index, String viewTypeName, Map<String, String> indexKey) {
250	0	if (StringUtils.isBlank(viewTypeName)) {
251	0	throw new IllegalArgumentException("invalid (blank) view type name");
252		}
253	0	if ((indexKey == null) \|\| indexKey.isEmpty()) {
254	0	throw new IllegalArgumentException("index key must have at least one entry");
255		}
256
257	0	return index.getViewByTypeIndex(viewTypeName, indexKey);
258		}
259
260		/**
261		* @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getViewsForType(UifDictionaryIndex,
262		* java.lang.String)
263		*/
264		public List<View> getViewsForType(UifDictionaryIndex index, String viewTypeName) {
265	0	if (StringUtils.isBlank(viewTypeName)) {
266	0	throw new IllegalArgumentException("invalid (blank) view type name");
267		}
268
269	0	return index.getViewsForType(viewTypeName);
270		}
271
272		}