001/**
002 * Copyright 2005-2018 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 org.apache.commons.lang.StringUtils;
019import org.apache.log4j.Logger;
020import org.kuali.rice.core.api.CoreApiServiceLocator;
021import org.kuali.rice.core.api.config.ConfigurationException;
022import org.kuali.rice.core.api.config.module.RunMode;
023import org.kuali.rice.core.api.config.property.ConfigContext;
024import org.kuali.rice.krad.bo.ExternalizableBusinessObject;
025import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
026import org.kuali.rice.krad.service.ModuleService;
027import org.kuali.rice.krad.util.KRADConstants;
028import org.kuali.rice.krad.util.UrlFactory;
029
030import java.util.List;
031import java.util.Map;
032import java.util.Properties;
033
034/**
035 * Base implementation of the module service
036 *
037 * @author Kuali Rice Team (rice.collab@kuali.org)
038 */
039public class ModuleServiceBase extends RemoteModuleServiceBase implements ModuleService {
040
041    protected static final Logger LOG = Logger.getLogger(ModuleServiceBase.class);
042    /**
043     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
044     */
045    public <T extends ExternalizableBusinessObject> T getExternalizableBusinessObject(Class<T> businessObjectClass,
046            Map<String, Object> fieldValues) {
047        Class<? extends ExternalizableBusinessObject> implementationClass =
048                getExternalizableBusinessObjectImplementation(businessObjectClass);
049        ExternalizableBusinessObject businessObject =
050                (ExternalizableBusinessObject) getLegacyDataAdapter().findByPrimaryKey(implementationClass, fieldValues);
051        return (T) businessObject;
052    }
053
054    /**
055     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObject(java.lang.Class, java.util.Map)
056     */
057    public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsList(
058            Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues) {
059        Class<? extends ExternalizableBusinessObject> implementationClass =
060                getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
061        return (List<T>) getLegacyDataAdapter().findMatching(implementationClass, fieldValues);
062    }
063
064
065
066    @Deprecated
067    public String getExternalizableBusinessObjectInquiryUrl(Class inquiryBusinessObjectClass,
068            Map<String, String[]> parameters) {
069        if (!isExternalizable(inquiryBusinessObjectClass)) {
070            return KRADConstants.EMPTY_STRING;
071        }
072        String businessObjectClassAttribute;
073
074        Class implementationClass = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
075        if (implementationClass == null) {
076            LOG.error("Can't find ExternalizableBusinessObject implementation class for " + inquiryBusinessObjectClass
077                    .getName());
078            throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for interface "
079                    + inquiryBusinessObjectClass.getName());
080        }
081        businessObjectClassAttribute = implementationClass.getName();
082        return UrlFactory.parameterizeUrl(getInquiryUrl(inquiryBusinessObjectClass), getUrlParameters(
083                businessObjectClassAttribute, parameters));
084    }
085
086    @Deprecated
087    @Override
088    protected String getInquiryUrl(Class inquiryBusinessObjectClass) {
089        
090        String riceBaseUrl = "";
091        String potentialUrlAddition = "";
092
093        if (goToCentralRiceForInquiry()) {
094            riceBaseUrl = CoreApiServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.KUALI_RICE_URL_KEY);
095        } else {
096            riceBaseUrl = CoreApiServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.APPLICATION_URL_KEY);
097            potentialUrlAddition = "kr/";
098        }
099        
100        String inquiryUrl = riceBaseUrl;
101        if (!inquiryUrl.endsWith("/")) {
102            inquiryUrl = inquiryUrl + "/";
103        }
104        return inquiryUrl + potentialUrlAddition + KRADConstants.INQUIRY_ACTION;
105    }
106
107    @Override
108    public boolean isExternalizableBusinessObjectLookupable(Class boClass) {
109        Class<? extends ExternalizableBusinessObject> implementationClass = getExternalizableBusinessObjectImplementation(boClass);
110        return KRADServiceLocatorWeb.getLegacyDataAdapter().hasLocalLookup(implementationClass);
111    }
112
113    @Override
114    public boolean isExternalizableBusinessObjectInquirable(Class boClass) {
115        return KRADServiceLocatorWeb.getLegacyDataAdapter().hasLocalInquiry(boClass);
116    }
117
118    /**
119     * This overridden method ...
120     *
121     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObjectLookupUrl(java.lang.Class,
122     *      java.util.Map)
123     */
124    @Deprecated
125    @Override
126    public String getExternalizableBusinessObjectLookupUrl(Class inquiryBusinessObjectClass,
127            Map<String, String> parameters) {
128        Properties urlParameters = new Properties();
129
130        String riceBaseUrl = "";
131        String potentialUrlAddition = "";
132
133        if (goToCentralRiceForInquiry()) {
134            riceBaseUrl = CoreApiServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.KUALI_RICE_URL_KEY);
135        } else {
136            riceBaseUrl = CoreApiServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.APPLICATION_URL_KEY);
137            potentialUrlAddition = "kr/";
138        }
139        
140        String lookupUrl = riceBaseUrl;
141        if (!lookupUrl.endsWith("/")) {
142            lookupUrl = lookupUrl + "/";
143        }
144        
145        if (parameters.containsKey(KRADConstants.MULTIPLE_VALUE)) {
146            lookupUrl = lookupUrl + potentialUrlAddition + KRADConstants.MULTIPLE_VALUE_LOOKUP_ACTION;
147        }
148        else {
149            lookupUrl = lookupUrl + potentialUrlAddition + KRADConstants.LOOKUP_ACTION;
150        }
151           
152        for (String paramName : parameters.keySet()) {
153            urlParameters.put(paramName, parameters.get(paramName));
154        }
155
156        /*Class clazz;
157        if (inquiryBusinessObjectClass.getClass().isInterface()) {*/
158        Class clazz = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
159        /*} else {
160            clazz = inquiryBusinessObjectClass;
161        }*/
162        urlParameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, clazz == null ? "" : clazz.getName());
163
164        return UrlFactory.parameterizeUrl(lookupUrl, urlParameters);
165    }
166
167    public boolean goToCentralRiceForInquiry() {
168        return false;
169    }
170
171    /**
172     * Returns the base URL to use for lookup requests to objects within the module
173     *
174     * @return String base lookup URL
175     */
176    @Override
177    protected String getBaseLookupUrl() {
178        if (goToCentralRiceForInquiry()) {
179            return BaseLookupUrlsHolder.remoteKradBaseLookupUrl;
180        } else {
181            return BaseLookupUrlsHolder.localKradBaseLookupUrl;
182        }
183    }
184
185    protected RunMode getRunMode(String module) {
186        String propertyName = module + ".mode";
187        String runMode = ConfigContext.getCurrentContextConfig().getProperty(propertyName);
188        if (StringUtils.isBlank(runMode)) {
189            throw new ConfigurationException("Failed to determine run mode for module '" + module + "'.  Please be sure to set configuration parameter '" + propertyName + "'");
190        }
191        return RunMode.valueOf(runMode.toUpperCase());
192    }
193}
194