001/**
002 * Copyright 2005-2016 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.krad.service.impl;
017
018import java.util.Iterator;
019import java.util.List;
020import java.util.Map;
021
022import org.apache.log4j.Logger;
023import org.kuali.rice.krad.bo.ExternalizableBusinessObject;
024import org.kuali.rice.krad.bo.PersistableBusinessObject;
025import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
026import org.kuali.rice.krad.service.KualiModuleService;
027import org.kuali.rice.krad.service.ModuleService;
028import org.kuali.rice.krad.service.PersistenceService;
029import org.kuali.rice.krad.util.ExternalizableBusinessObjectUtils;
030import org.kuali.rice.krad.util.LegacyDataFramework;
031import org.springframework.beans.BeanUtils;
032import org.springframework.transaction.annotation.Transactional;
033import org.springframework.util.CollectionUtils;
034
035/**
036 * This class is the service implementation for the Persistence structure.
037 * OjbRepositoryExplorer provides functions for extracting information from the
038 * OJB repository at runtime. This is the default implementation, that is
039 * delivered with Kuali.
040 */
041@Deprecated
042@Transactional
043@LegacyDataFramework
044public class PersistenceServiceImpl extends PersistenceServiceImplBase implements PersistenceService {
045
046        private static Logger LOG = Logger.getLogger(PersistenceServiceImpl.class);
047
048    private KualiModuleService kualiModuleService;
049
050        private PersistenceService persistenceServiceOjb;
051
052        public void setPersistenceServiceOjb(PersistenceService persistenceServiceOjb) {
053                this.persistenceServiceOjb = persistenceServiceOjb;
054        }
055
056        private PersistenceService getService(Class clazz) {
057        if (isJpaEnabledForKradClass(clazz)) {
058            throw new IllegalStateException("PersistenceService invoked for non-legacy class: " + clazz);
059        }
060                return persistenceServiceOjb;
061        }
062
063        // This method is for OJB specfic features. It is now being called directly where needed.
064        @Override
065        public void clearCache() {
066                throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
067        }
068
069        // This method is for OJB specfic features. It is now being called directly where needed.
070        @Override
071        public void loadRepositoryDescriptor(String ojbRepositoryFilePath) {
072                throw new UnsupportedOperationException("This should be called directly from the OJB Impl if needed.");
073        }
074
075        @Override
076        public Object resolveProxy(Object o) {
077                return getService(o.getClass()).resolveProxy(o);
078        }
079
080        /**
081         * @see org.kuali.rice.krad.service.PersistenceService#retrieveNonKeyFields(java.lang.Object)
082         */
083        @Override
084        public void retrieveNonKeyFields(Object persistableObject) {
085        if (persistableObject != null &&
086                ExternalizableBusinessObjectUtils.isExternalizableBusinessObject(persistableObject.getClass())) {
087            //
088            // special handling for EBOs
089            //
090            Map<String, ?> criteria = KRADServiceLocatorWeb.getLegacyDataAdapter().getPrimaryKeyFieldValues(persistableObject);
091            if (!CollectionUtils.isEmpty(criteria)) {
092                ModuleService moduleService = getKualiModuleService().getResponsibleModuleService(persistableObject.getClass());
093                if (moduleService != null) {
094                    Class<? extends ExternalizableBusinessObject> clazz =
095                            ExternalizableBusinessObjectUtils.determineExternalizableBusinessObjectSubInterface(persistableObject.getClass());
096                    ExternalizableBusinessObject freshEbo = moduleService.getExternalizableBusinessObject(clazz, (Map<String, Object>)criteria);
097                    if (freshEbo != null) {
098                        BeanUtils.copyProperties(freshEbo, persistableObject);
099                    }
100                }
101            }
102        } else {
103            getService(persistableObject.getClass()).retrieveNonKeyFields(persistableObject);
104        }
105        }
106
107        /**
108         * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
109         *      String referenceObjectName)
110         */
111        @Override
112        public void retrieveReferenceObject(Object persistableObject, String referenceObjectName) {
113                getService(persistableObject.getClass()).retrieveReferenceObject(persistableObject, referenceObjectName);
114        }
115
116        /**
117         * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
118         *      String referenceObjectName)
119         */
120        @Override
121        public void retrieveReferenceObjects(Object persistableObject, List referenceObjectNames) {
122                getService(persistableObject.getClass()).retrieveReferenceObjects(persistableObject, referenceObjectNames);
123        }
124
125        /**
126         * @see org.kuali.rice.krad.service.PersistenceService#retrieveReferenceObject(java.lang.Object,
127         *      String referenceObjectName)
128         */
129        @Override
130        public void retrieveReferenceObjects(List persistableObjects, List referenceObjectNames) {
131                if (persistableObjects == null) {
132                        throw new IllegalArgumentException("invalid (null) persistableObjects");
133                }
134                if (persistableObjects.isEmpty()) {
135                        throw new IllegalArgumentException("invalid (empty) persistableObjects");
136                }
137                if (referenceObjectNames == null) {
138                        throw new IllegalArgumentException("invalid (null) referenceObjectNames");
139                }
140                if (referenceObjectNames.isEmpty()) {
141                        throw new IllegalArgumentException("invalid (empty) referenceObjectNames");
142                }
143
144                for (Iterator i = persistableObjects.iterator(); i.hasNext();) {
145                        Object persistableObject = i.next();
146                        retrieveReferenceObjects(persistableObject, referenceObjectNames);
147                }
148        }
149
150        /**
151         * @see org.kuali.rice.krad.service.PersistenceService#getFlattenedPrimaryKeyFieldValues(java.lang.Object)
152         */
153        @Override
154        public String getFlattenedPrimaryKeyFieldValues(Object persistableObject) {
155                return getService(persistableObject.getClass()).getFlattenedPrimaryKeyFieldValues(persistableObject);
156        }
157
158        /**
159         * For each reference object to the parent persistableObject, sets the key
160         * values for that object. First, if the reference object already has a
161         * value for the key, the value is left unchanged. Otherwise, for
162         * non-anonymous keys, the value is taken from the parent object. For
163         * anonymous keys, all other persistableObjects are checked until a value
164         * for the key is found.
165         *
166         * @see org.kuali.rice.krad.service.PersistenceService#getReferencedObject(java.lang.Object,
167         *      org.apache.ojb.broker.metadata.ObjectReferenceDescriptor)
168         */
169        @Override
170        public void linkObjects(Object persistableObject) {
171                getService(persistableObject.getClass()).linkObjects(persistableObject);
172        }
173
174        /**
175         *
176         * @see org.kuali.rice.krad.service.PersistenceService#allForeignKeyValuesPopulatedForReference(org.kuali.rice.krad.bo.BusinessObject,
177         *      java.lang.String)
178         */
179        @Override
180        public boolean allForeignKeyValuesPopulatedForReference(PersistableBusinessObject bo, String referenceName) {
181                return getService(bo.getClass()).allForeignKeyValuesPopulatedForReference(bo, referenceName);
182        }
183
184        /**
185         *
186         * @see org.kuali.rice.krad.service.PersistenceService#refreshAllNonUpdatingReferences(org.kuali.rice.krad.bo.BusinessObject)
187         */
188        @Override
189        public void refreshAllNonUpdatingReferences(PersistableBusinessObject bo) {
190                getService(bo.getClass()).refreshAllNonUpdatingReferences(bo);
191        }
192
193        /**
194         * Defers to the service for the given class
195         *
196         * @see org.kuali.rice.krad.service.PersistenceService#isProxied(java.lang.Object)
197         */
198        @Override
199        public boolean isProxied(Object bo) {
200                return getService(bo.getClass()).isProxied(bo);
201        }
202
203    public KualiModuleService getKualiModuleService() {
204        return kualiModuleService;
205    }
206
207    public void setKualiModuleService(KualiModuleService kualiModuleService) {
208        this.kualiModuleService = kualiModuleService;
209    }
210}