Coverage Report

Coverage Report - org.kuali.rice.krad.service.impl.PersistenceServiceImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

PersistenceServiceImpl

0/36

0/12

1.8

 /*
  * Copyright 2005-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.krad.service.impl;
 
 import java.util.Iterator;
 import java.util.List;
 
 import org.apache.log4j.Logger;
 import org.kuali.rice.krad.bo.PersistableBusinessObject;
 import org.kuali.rice.krad.service.PersistenceService;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
  * This class is the service implementation for the Persistence structure.
  * OjbRepositoryExplorer provides functions for extracting information from the
  * OJB repository at runtime. This is the default implementation, that is
  * delivered with Kuali.
  */
 @Transactional
 public class PersistenceServiceImpl extends PersistenceServiceImplBase implements PersistenceService {
 
         private static Logger LOG = Logger.getLogger(PersistenceServiceImpl.class);
 
         private PersistenceService persistenceServiceJpa;
 
         private PersistenceService persistenceServiceOjb;
 
         public void setPersistenceServiceJpa(PersistenceService persistenceServiceJpa) {
                 this.persistenceServiceJpa = persistenceServiceJpa;
         }
 
         public void setPersistenceServiceOjb(PersistenceService persistenceServiceOjb) {
                 this.persistenceServiceOjb = persistenceServiceOjb;
         }
 
         private PersistenceService getService(Class clazz) {
             return (isJpaEnabledForKradClass(clazz)) ?
                                                 persistenceServiceJpa : persistenceServiceOjb;
         }
 
         // This method is for OJB specfic features. It is now being called directly where needed.
         public void clearCache() {
                 throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
         }
 
         // This method is for OJB specfic features. It is now being called directly where needed.
         public void loadRepositoryDescriptor(String ojbRepositoryFilePath) {
                 throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
         }
 
         public Object resolveProxy(Object o) {
                 return getService(o.getClass()).resolveProxy(o);
         }
 
         /**
          * @see org.kuali.rice.krad.service.PersistenceService#retrieveNonKeyFields(java.lang.Object)
          */
         public void retrieveNonKeyFields(Object persistableObject) {
                 getService(persistableObject.getClass()).retrieveNonKeyFields(persistableObject);
         }
 
         /**
          * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
          *      String referenceObjectName)
          */
         public void retrieveReferenceObject(Object persistableObject, String referenceObjectName) {
                 getService(persistableObject.getClass()).retrieveReferenceObject(persistableObject, referenceObjectName);
         }
 
         /**
          * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
          *      String referenceObjectName)
          */
         public void retrieveReferenceObjects(Object persistableObject, List referenceObjectNames) {
                 getService(persistableObject.getClass()).retrieveReferenceObjects(persistableObject, referenceObjectNames);
         }
 
         /**
          * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
          *      String referenceObjectName)
          */
         public void retrieveReferenceObjects(List persistableObjects, List referenceObjectNames) {
                 if (persistableObjects == null) {
                         throw new IllegalArgumentException("invalid (null) persistableObjects");
                 }
                 if (persistableObjects.isEmpty()) {
                         throw new IllegalArgumentException("invalid (empty) persistableObjects");
                 }
                 if (referenceObjectNames == null) {
                         throw new IllegalArgumentException("invalid (null) referenceObjectNames");
                 }
                 if (referenceObjectNames.isEmpty()) {
                         throw new IllegalArgumentException("invalid (empty) referenceObjectNames");
                 }
 
                 for (Iterator i = persistableObjects.iterator(); i.hasNext();) {
                         Object persistableObject = i.next();
                         retrieveReferenceObjects(persistableObject, referenceObjectNames);
                 }
         }
 
         /**
          * @see org.kuali.rice.krad.service.PersistenceService#getFlattenedPrimaryKeyFieldValues(java.lang.Object)
          */
         public String getFlattenedPrimaryKeyFieldValues(Object persistableObject) {
                 return getService(persistableObject.getClass()).getFlattenedPrimaryKeyFieldValues(persistableObject);
         }
 
         /**
          * For each reference object to the parent persistableObject, sets the key
          * values for that object. First, if the reference object already has a
          * value for the key, the value is left unchanged. Otherwise, for
          * non-anonymous keys, the value is taken from the parent object. For
          * anonymous keys, all other persistableObjects are checked until a value
          * for the key is found.
          * 
          * @see org.kuali.rice.krad.service.PersistenceService#getReferencedObject(java.lang.Object,
          *      org.apache.ojb.broker.metadata.ObjectReferenceDescriptor)
          */
         public void linkObjects(Object persistableObject) {
                 getService(persistableObject.getClass()).linkObjects(persistableObject);
         }
 
         /**
          * 
          * @see org.kuali.rice.krad.service.PersistenceService#allForeignKeyValuesPopulatedForReference(org.kuali.rice.krad.bo.BusinessObject,
          *      java.lang.String)
          */
         public boolean allForeignKeyValuesPopulatedForReference(PersistableBusinessObject bo, String referenceName) {
                 return getService(bo.getClass()).allForeignKeyValuesPopulatedForReference(bo, referenceName);
         }
 
         /**
          * 
          * @see org.kuali.rice.krad.service.PersistenceService#refreshAllNonUpdatingReferences(org.kuali.rice.krad.bo.BusinessObject)
          */
         public void refreshAllNonUpdatingReferences(PersistableBusinessObject bo) {
                 getService(bo.getClass()).refreshAllNonUpdatingReferences(bo);
         }
 
         /**
          * Defers to the service for the given class
          * 
          * @see org.kuali.rice.krad.service.PersistenceService#isProxied(java.lang.Object)
          */
         public boolean isProxied(Object bo) {
                 return getService(bo.getClass()).isProxied(bo);
         }
 
 }

1		/*
2		* Copyright 2005-2007 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.service.impl;
17
18		import java.util.Iterator;
19		import java.util.List;
20
21		import org.apache.log4j.Logger;
22		import org.kuali.rice.krad.bo.PersistableBusinessObject;
23		import org.kuali.rice.krad.service.PersistenceService;
24		import org.springframework.transaction.annotation.Transactional;
25
26		/**
27		* This class is the service implementation for the Persistence structure.
28		* OjbRepositoryExplorer provides functions for extracting information from the
29		* OJB repository at runtime. This is the default implementation, that is
30		* delivered with Kuali.
31		*/
32		@Transactional
33	0	public class PersistenceServiceImpl extends PersistenceServiceImplBase implements PersistenceService {
34
35	0	private static Logger LOG = Logger.getLogger(PersistenceServiceImpl.class);
36
37		private PersistenceService persistenceServiceJpa;
38
39		private PersistenceService persistenceServiceOjb;
40
41		public void setPersistenceServiceJpa(PersistenceService persistenceServiceJpa) {
42	0	this.persistenceServiceJpa = persistenceServiceJpa;
43	0	}
44
45		public void setPersistenceServiceOjb(PersistenceService persistenceServiceOjb) {
46	0	this.persistenceServiceOjb = persistenceServiceOjb;
47	0	}
48
49		private PersistenceService getService(Class clazz) {
50	0	return (isJpaEnabledForKradClass(clazz)) ?
51		persistenceServiceJpa : persistenceServiceOjb;
52		}
53
54		// This method is for OJB specfic features. It is now being called directly where needed.
55		public void clearCache() {
56	0	throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
57		}
58
59		// This method is for OJB specfic features. It is now being called directly where needed.
60		public void loadRepositoryDescriptor(String ojbRepositoryFilePath) {
61	0	throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
62		}
63
64		public Object resolveProxy(Object o) {
65	0	return getService(o.getClass()).resolveProxy(o);
66		}
67
68		/**
69		* @see org.kuali.rice.krad.service.PersistenceService#retrieveNonKeyFields(java.lang.Object)
70		*/
71		public void retrieveNonKeyFields(Object persistableObject) {
72	0	getService(persistableObject.getClass()).retrieveNonKeyFields(persistableObject);
73	0	}
74
75		/**
76		* @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
77		* String referenceObjectName)
78		*/
79		public void retrieveReferenceObject(Object persistableObject, String referenceObjectName) {
80	0	getService(persistableObject.getClass()).retrieveReferenceObject(persistableObject, referenceObjectName);
81	0	}
82
83		/**
84		* @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
85		* String referenceObjectName)
86		*/
87		public void retrieveReferenceObjects(Object persistableObject, List referenceObjectNames) {
88	0	getService(persistableObject.getClass()).retrieveReferenceObjects(persistableObject, referenceObjectNames);
89	0	}
90
91		/**
92		* @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
93		* String referenceObjectName)
94		*/
95		public void retrieveReferenceObjects(List persistableObjects, List referenceObjectNames) {
96	0	if (persistableObjects == null) {
97	0	throw new IllegalArgumentException("invalid (null) persistableObjects");
98		}
99	0	if (persistableObjects.isEmpty()) {
100	0	throw new IllegalArgumentException("invalid (empty) persistableObjects");
101		}
102	0	if (referenceObjectNames == null) {
103	0	throw new IllegalArgumentException("invalid (null) referenceObjectNames");
104		}
105	0	if (referenceObjectNames.isEmpty()) {
106	0	throw new IllegalArgumentException("invalid (empty) referenceObjectNames");
107		}
108
109	0	for (Iterator i = persistableObjects.iterator(); i.hasNext();) {
110	0	Object persistableObject = i.next();
111	0	retrieveReferenceObjects(persistableObject, referenceObjectNames);
112	0	}
113	0	}
114
115		/**
116		* @see org.kuali.rice.krad.service.PersistenceService#getFlattenedPrimaryKeyFieldValues(java.lang.Object)
117		*/
118		public String getFlattenedPrimaryKeyFieldValues(Object persistableObject) {
119	0	return getService(persistableObject.getClass()).getFlattenedPrimaryKeyFieldValues(persistableObject);
120		}
121
122		/**
123		* For each reference object to the parent persistableObject, sets the key
124		* values for that object. First, if the reference object already has a
125		* value for the key, the value is left unchanged. Otherwise, for
126		* non-anonymous keys, the value is taken from the parent object. For
127		* anonymous keys, all other persistableObjects are checked until a value
128		* for the key is found.
129		*
130		* @see org.kuali.rice.krad.service.PersistenceService#getReferencedObject(java.lang.Object,
131		* org.apache.ojb.broker.metadata.ObjectReferenceDescriptor)
132		*/
133		public void linkObjects(Object persistableObject) {
134	0	getService(persistableObject.getClass()).linkObjects(persistableObject);
135	0	}
136
137		/**
138		*
139		* @see org.kuali.rice.krad.service.PersistenceService#allForeignKeyValuesPopulatedForReference(org.kuali.rice.krad.bo.BusinessObject,
140		* java.lang.String)
141		*/
142		public boolean allForeignKeyValuesPopulatedForReference(PersistableBusinessObject bo, String referenceName) {
143	0	return getService(bo.getClass()).allForeignKeyValuesPopulatedForReference(bo, referenceName);
144		}
145
146		/**
147		*
148		* @see org.kuali.rice.krad.service.PersistenceService#refreshAllNonUpdatingReferences(org.kuali.rice.krad.bo.BusinessObject)
149		*/
150		public void refreshAllNonUpdatingReferences(PersistableBusinessObject bo) {
151	0	getService(bo.getClass()).refreshAllNonUpdatingReferences(bo);
152	0	}
153
154		/**
155		* Defers to the service for the given class
156		*
157		* @see org.kuali.rice.krad.service.PersistenceService#isProxied(java.lang.Object)
158		*/
159		public boolean isProxied(Object bo) {
160	0	return getService(bo.getClass()).isProxied(bo);
161		}
162
163		}