Coverage Report

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