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 org.apache.commons.beanutils.PropertyUtils;
019import org.apache.commons.lang.StringUtils;
020import org.apache.log4j.Logger;
021import org.kuali.rice.core.api.config.property.ConfigurationService;
022import org.kuali.rice.coreservice.framework.CoreFrameworkServiceLocator;
023import org.kuali.rice.coreservice.framework.parameter.ParameterService;
024import org.kuali.rice.krad.bo.BusinessObject;
025import org.kuali.rice.krad.bo.DataObjectRelationship;
026import org.kuali.rice.krad.bo.ExternalizableBusinessObject;
027import org.kuali.rice.krad.bo.ModuleConfiguration;
028import org.kuali.rice.krad.datadictionary.BusinessObjectEntry;
029import org.kuali.rice.krad.datadictionary.PrimitiveAttributeDefinition;
030import org.kuali.rice.krad.datadictionary.RelationshipDefinition;
031import org.kuali.rice.krad.service.BusinessObjectNotLookupableException;
032import org.kuali.rice.krad.service.KRADServiceLocator;
033import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
034import org.kuali.rice.krad.service.KualiModuleService;
035import org.kuali.rice.krad.service.LookupService;
036import org.kuali.rice.krad.service.ModuleService;
037import org.kuali.rice.krad.uif.UifParameters;
038import org.kuali.rice.krad.util.ExternalizableBusinessObjectUtils;
039import org.kuali.rice.krad.util.KRADConstants;
040import org.kuali.rice.krad.util.ObjectUtils;
041import org.kuali.rice.krad.util.UrlFactory;
042import org.springframework.beans.BeansException;
043import org.springframework.beans.factory.NoSuchBeanDefinitionException;
044import org.springframework.context.ApplicationContext;
045
046import java.lang.reflect.Modifier;
047import java.util.HashMap;
048import java.util.List;
049import java.util.Map;
050import java.util.Properties;
051
052
053public abstract class RemoteModuleServiceBase implements ModuleService {
054    protected static final Logger LOG = Logger.getLogger(RemoteModuleServiceBase.class);
055
056    protected ModuleConfiguration moduleConfiguration;
057    protected KualiModuleService kualiModuleService;
058    protected ApplicationContext applicationContext;
059    protected ConfigurationService kualiConfigurationService;
060    protected LookupService lookupService;
061
062    /**
063     * @see org.kuali.rice.krad.service.ModuleService#isResponsibleFor(java.lang.Class)
064     */
065    public boolean isResponsibleFor(Class businessObjectClass) {
066        if (getModuleConfiguration() == null) {
067            throw new IllegalStateException("Module configuration has not been initialized for the module service.");
068        }
069
070        if (getModuleConfiguration().getPackagePrefixes() == null || businessObjectClass == null) {
071            return false;
072        }
073        for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
074            if (businessObjectClass.getPackage().getName().startsWith(prefix)) {
075                return true;
076            }
077        }
078        if (ExternalizableBusinessObject.class.isAssignableFrom(businessObjectClass)) {
079            Class externalizableBusinessObjectInterface =
080                    ExternalizableBusinessObjectUtils.determineExternalizableBusinessObjectSubInterface(
081                            businessObjectClass);
082            if (externalizableBusinessObjectInterface != null) {
083                for (String prefix : getModuleConfiguration().getPackagePrefixes()) {
084                    if (externalizableBusinessObjectInterface.getPackage().getName().startsWith(prefix)) {
085                        return true;
086                    }
087                }
088            }
089        }
090        return false;
091    }
092
093    /**
094     * Utility method to check for the presence of a non blank value in the map for the given key
095     * Note: returns false if a null map is passed in.
096     *
097     * @param map the map to retrieve the value from
098     * @param key the key to use
099     * @return true if there is a non-blank value in the map for the given key.
100     */
101    protected static boolean isNonBlankValueForKey(Map<String, Object> map, String key) {
102        if (map == null) return false;
103
104        Object result = map.get(key);
105        if (result instanceof String) {
106            return !StringUtils.isBlank((String)result);
107        }
108        return result != null;
109    }
110
111    /**
112     * @see org.kuali.rice.krad.service.ModuleService#isResponsibleFor(java.lang.Class)
113     */
114    public boolean isResponsibleForJob(String jobName) {
115        if (getModuleConfiguration() == null) {
116            throw new IllegalStateException("Module configuration has not been initialized for the module service.");
117        }
118
119        if (getModuleConfiguration().getJobNames() == null || StringUtils.isEmpty(jobName)) {
120            return false;
121        }
122
123        return getModuleConfiguration().getJobNames().contains(jobName);
124    }
125
126
127    public List listPrimaryKeyFieldNames(Class businessObjectInterfaceClass) {
128        Class clazz = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
129        return KRADServiceLocator.getPersistenceStructureService().listPrimaryKeyFieldNames(clazz);
130    }
131
132    /**
133     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObjectDictionaryEntry(java.lang.Class)
134     */
135    public BusinessObjectEntry getExternalizableBusinessObjectDictionaryEntry(Class businessObjectInterfaceClass) {
136        Class boClass = getExternalizableBusinessObjectImplementation(businessObjectInterfaceClass);
137
138        return boClass == null ? null : KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary()
139                .getBusinessObjectEntryForConcreteClass(boClass.getName());
140    }
141
142    /**
143     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableDataObjectInquiryUrl(java.lang.Class,
144     * java.util.Properties)
145     */
146    public String getExternalizableDataObjectInquiryUrl(Class<?> inquiryDataObjectClass, Properties parameters) {
147        String baseUrl = getBaseInquiryUrl();
148
149        // if external business object, replace data object in request with the actual impl object class
150        if (ExternalizableBusinessObject.class.isAssignableFrom(inquiryDataObjectClass)) {
151            Class implementationClass = getExternalizableBusinessObjectImplementation(inquiryDataObjectClass.asSubclass(
152                    ExternalizableBusinessObject.class));
153            if (implementationClass == null) {
154                throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for "
155                        + inquiryDataObjectClass.getName());
156            }
157
158            parameters.put(UifParameters.DATA_OBJECT_CLASS_NAME, implementationClass.getName());
159        }
160
161        return UrlFactory.parameterizeUrl(baseUrl, parameters);
162    }
163
164    /**
165     * Returns the base URL to use for inquiry requests to objects within the module
166     *
167     * @return String base inquiry URL
168     */
169    protected String getBaseInquiryUrl() {
170        return getKualiConfigurationService().getPropertyValueAsString(KRADConstants.KRAD_INQUIRY_URL_KEY);
171    }
172
173    /**
174     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableDataObjectLookupUrl(java.lang.Class,
175     * java.util.Properties)
176     */
177    public String getExternalizableDataObjectLookupUrl(Class<?> lookupDataObjectClass, Properties parameters) {
178        String baseUrl = getBaseLookupUrl();
179
180        // if external business object, replace data object in request with the actual impl object class
181        if (ExternalizableBusinessObject.class.isAssignableFrom(lookupDataObjectClass)) {
182            Class implementationClass = getExternalizableBusinessObjectImplementation(lookupDataObjectClass.asSubclass(
183                    ExternalizableBusinessObject.class));
184            if (implementationClass == null) {
185                throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for "
186                        + lookupDataObjectClass.getName());
187            }
188
189            parameters.put(UifParameters.DATA_OBJECT_CLASS_NAME, implementationClass.getName());
190        }
191
192        return UrlFactory.parameterizeUrl(baseUrl, parameters);
193    }
194
195    /**
196     * Returns the base lookup URL for the Rice server
197     *
198     * @return String base lookup URL
199     */
200    protected String getRiceBaseLookupUrl() {
201        return BaseLookupUrlsHolder.remoteKradBaseLookupUrl;
202    }
203
204    // Lazy initialization holder class idiom, see Effective Java item #71
205    protected static final class BaseLookupUrlsHolder {
206
207        public static final String localKradBaseLookupUrl;
208        public static final String remoteKradBaseLookupUrl;
209
210        static {
211            remoteKradBaseLookupUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.KRAD_SERVER_LOOKUP_URL_KEY);
212            localKradBaseLookupUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(KRADConstants.KRAD_LOOKUP_URL_KEY);
213        }
214    }
215
216    /**
217     * Returns the base URL to use for lookup requests to objects within the module
218     *
219     * @return String base lookup URL
220     */
221    protected String getBaseLookupUrl() {
222        return getRiceBaseLookupUrl();
223    }
224
225    @Deprecated
226    public String getExternalizableBusinessObjectInquiryUrl(Class inquiryBusinessObjectClass,
227            Map<String, String[]> parameters) {
228        if (!isExternalizable(inquiryBusinessObjectClass)) {
229            return KRADConstants.EMPTY_STRING;
230        }
231        String businessObjectClassAttribute;
232
233        Class implementationClass = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
234        if (implementationClass == null) {
235            LOG.error("Can't find ExternalizableBusinessObject implementation class for " + inquiryBusinessObjectClass
236                    .getName());
237            throw new RuntimeException("Can't find ExternalizableBusinessObject implementation class for interface "
238                    + inquiryBusinessObjectClass.getName());
239        }
240        businessObjectClassAttribute = implementationClass.getName();
241        return UrlFactory.parameterizeUrl(getInquiryUrl(inquiryBusinessObjectClass), getUrlParameters(
242                businessObjectClassAttribute, parameters));
243    }
244
245    /**
246     * This overridden method ...
247     *
248     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObjectLookupUrl(java.lang.Class,
249     *      java.util.Map)
250     */
251    @Deprecated
252    @Override
253    public String getExternalizableBusinessObjectLookupUrl(Class inquiryBusinessObjectClass,
254            Map<String, String> parameters) {
255        Properties urlParameters = new Properties();
256
257        String riceBaseUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(
258                KRADConstants.KUALI_RICE_URL_KEY);
259        String lookupUrl = riceBaseUrl;
260        if (!lookupUrl.endsWith("/")) {
261            lookupUrl = lookupUrl + "/";
262        }
263        if (parameters.containsKey(KRADConstants.MULTIPLE_VALUE)) {
264            lookupUrl = lookupUrl + KRADConstants.MULTIPLE_VALUE_LOOKUP_ACTION;
265        } else {
266            lookupUrl = lookupUrl + KRADConstants.LOOKUP_ACTION;
267        }
268        for (String paramName : parameters.keySet()) {
269            urlParameters.put(paramName, parameters.get(paramName));
270        }
271
272        Class clazz = getExternalizableBusinessObjectImplementation(inquiryBusinessObjectClass);
273        urlParameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, clazz == null ? "" : clazz.getName());
274
275        return UrlFactory.parameterizeUrl(lookupUrl, urlParameters);
276    }
277
278    /**
279     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObjectsListForLookup(java.lang.Class,
280     *      java.util.Map, boolean)
281     */
282    public <T extends ExternalizableBusinessObject> List<T> getExternalizableBusinessObjectsListForLookup(
283            Class<T> externalizableBusinessObjectClass, Map<String, Object> fieldValues, boolean unbounded) {
284        Class<? extends ExternalizableBusinessObject> implementationClass =
285                getExternalizableBusinessObjectImplementation(externalizableBusinessObjectClass);
286        if (isExternalizableBusinessObjectLookupable(implementationClass)) {
287            Map<String, String> searchCriteria = new HashMap<String, String>();
288            for (Map.Entry<String, Object> fieldValue : fieldValues.entrySet()) {
289                if (fieldValue.getValue() != null) {
290                    searchCriteria.put(fieldValue.getKey(), fieldValue.getValue().toString());
291                } else {
292                    searchCriteria.put(fieldValue.getKey(), null);
293                }
294            }
295            return (List<T>) getLookupService().findCollectionBySearchHelper(implementationClass, searchCriteria,
296                    unbounded);
297        } else {
298            throw new BusinessObjectNotLookupableException(
299                    "External business object is not a Lookupable:  " + implementationClass);
300        }
301    }
302
303    /**
304     * This method assumes that the property type for externalizable relationship in the business object is an interface
305     * and gets the concrete implementation for it
306     *
307     * @see org.kuali.rice.krad.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.krad.bo.BusinessObject,
308     *      org.kuali.rice.krad.bo.BusinessObject, java.lang.String)
309     */
310    public <T extends ExternalizableBusinessObject> T retrieveExternalizableBusinessObjectIfNecessary(
311            BusinessObject businessObject, T currentInstanceExternalizableBO, String externalizableRelationshipName) {
312
313        if (businessObject == null) {
314            return null;
315        }
316        Class clazz;
317        try {
318            clazz = getExternalizableBusinessObjectImplementation(PropertyUtils.getPropertyType(businessObject,
319                    externalizableRelationshipName));
320        } catch (Exception iex) {
321            LOG.warn("Exception:"
322                    + iex
323                    + " thrown while trying to get property type for property:"
324                    + externalizableRelationshipName
325                    + " from business object:"
326                    + businessObject);
327            return null;
328        }
329
330        //Get the business object entry for this business object from data dictionary
331        //using the class name (without the package) as key
332        BusinessObjectEntry entry =
333                KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(
334                        businessObject.getClass().getSimpleName());
335        RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
336        List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions =
337                relationshipDefinition.getPrimitiveAttributes();
338
339        Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
340        Object sourcePropertyValue;
341        Object targetPropertyValue = null;
342        boolean sourceTargetPropertyValuesSame = true;
343        for (PrimitiveAttributeDefinition primitiveAttributeDefinition : primitiveAttributeDefinitions) {
344            sourcePropertyValue = ObjectUtils.getPropertyValue(businessObject,
345                    primitiveAttributeDefinition.getSourceName());
346            if (currentInstanceExternalizableBO != null) {
347                targetPropertyValue = ObjectUtils.getPropertyValue(currentInstanceExternalizableBO,
348                        primitiveAttributeDefinition.getTargetName());
349            }
350            if (sourcePropertyValue == null) {
351                return null;
352            } else if (targetPropertyValue == null || (targetPropertyValue != null && !targetPropertyValue.equals(
353                    sourcePropertyValue))) {
354                sourceTargetPropertyValuesSame = false;
355            }
356            fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
357        }
358
359        if (!sourceTargetPropertyValuesSame) {
360            return (T) getExternalizableBusinessObject(clazz, fieldValuesInEBO);
361        }
362        return currentInstanceExternalizableBO;
363    }
364
365    /**
366     * This method assumes that the externalizableClazz is an interface
367     * and gets the concrete implementation for it
368     *
369     * @see org.kuali.rice.krad.service.ModuleService#retrieveExternalizableBusinessObjectIfNecessary(org.kuali.rice.krad.bo.BusinessObject,
370     *      org.kuali.rice.krad.bo.BusinessObject, java.lang.String)
371     */
372    @Override
373    public List<? extends ExternalizableBusinessObject> retrieveExternalizableBusinessObjectsList(
374            BusinessObject businessObject, String externalizableRelationshipName, Class externalizableClazz) {
375
376        if (businessObject == null) {
377            return null;
378        }
379        //Get the business object entry for this business object from data dictionary
380        //using the class name (without the package) as key
381        String className = businessObject.getClass().getName();
382        String key = className.substring(className.lastIndexOf(".") + 1);
383        BusinessObjectEntry entry =
384                KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getBusinessObjectEntries().get(
385                        key);
386        RelationshipDefinition relationshipDefinition = entry.getRelationshipDefinition(externalizableRelationshipName);
387        List<PrimitiveAttributeDefinition> primitiveAttributeDefinitions =
388                relationshipDefinition.getPrimitiveAttributes();
389        Map<String, Object> fieldValuesInEBO = new HashMap<String, Object>();
390        Object sourcePropertyValue;
391        for (PrimitiveAttributeDefinition primitiveAttributeDefinition : primitiveAttributeDefinitions) {
392            sourcePropertyValue = ObjectUtils.getPropertyValue(businessObject,
393                    primitiveAttributeDefinition.getSourceName());
394            if (sourcePropertyValue == null) {
395                return null;
396            }
397            fieldValuesInEBO.put(primitiveAttributeDefinition.getTargetName(), sourcePropertyValue);
398        }
399        return getExternalizableBusinessObjectsList(getExternalizableBusinessObjectImplementation(externalizableClazz),
400                fieldValuesInEBO);
401    }
402
403    /**
404     * @see org.kuali.rice.krad.service.ModuleService#getExternalizableBusinessObjectImplementation(java.lang.Class)
405     */
406    @Override
407    public <E extends ExternalizableBusinessObject> Class<E> getExternalizableBusinessObjectImplementation(
408            Class<E> externalizableBusinessObjectInterface) {
409        if (getModuleConfiguration() == null) {
410            throw new IllegalStateException("Module configuration has not been initialized for the module service.");
411        }
412        Map<Class, Class> ebos = getModuleConfiguration().getExternalizableBusinessObjectImplementations();
413        if (ebos == null) {
414            return null;
415        }
416        if (ebos.containsValue(externalizableBusinessObjectInterface)) {
417            return externalizableBusinessObjectInterface;
418        } else {
419            Class<E> implementationClass = ebos.get(externalizableBusinessObjectInterface);
420            int implClassModifiers = implementationClass.getModifiers();
421            if (Modifier.isInterface(implClassModifiers) || Modifier.isAbstract(implClassModifiers)) {
422                throw new RuntimeException("Implementation class must be non-abstract class: ebo interface: "
423                        + externalizableBusinessObjectInterface.getName()
424                        + " impl class: "
425                        + implementationClass.getName()
426                        + " module: "
427                        + getModuleConfiguration().getNamespaceCode());
428            }
429            return implementationClass;
430        }
431
432    }
433
434    @Deprecated
435    protected Properties getUrlParameters(String businessObjectClassAttribute, Map<String, String[]> parameters) {
436        Properties urlParameters = new Properties();
437        for (String paramName : parameters.keySet()) {
438            String[] parameterValues = parameters.get(paramName);
439            if (parameterValues.length > 0) {
440                urlParameters.put(paramName, parameterValues[0]);
441            }
442        }
443        urlParameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, businessObjectClassAttribute);
444        urlParameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, KRADConstants.CONTINUE_WITH_INQUIRY_METHOD_TO_CALL);
445        return urlParameters;
446    }
447
448    @Deprecated
449    protected String getInquiryUrl(Class inquiryBusinessObjectClass) {
450        String riceBaseUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(
451                KRADConstants.KUALI_RICE_URL_KEY);
452        String inquiryUrl = riceBaseUrl;
453        if (!inquiryUrl.endsWith("/")) {
454            inquiryUrl = inquiryUrl + "/";
455        }
456        return inquiryUrl + KRADConstants.INQUIRY_ACTION;
457    }
458
459    /**
460     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
461     */
462    public void afterPropertiesSet() throws Exception {
463        KualiModuleService kualiModuleService = null;
464        try {
465            kualiModuleService = KRADServiceLocatorWeb.getKualiModuleService();
466            if (kualiModuleService == null) {
467                kualiModuleService = ((KualiModuleService) applicationContext.getBean(
468                        KRADServiceLocatorWeb.KUALI_MODULE_SERVICE));
469            }
470        } catch (NoSuchBeanDefinitionException ex) {
471            kualiModuleService = ((KualiModuleService) applicationContext.getBean(
472                    KRADServiceLocatorWeb.KUALI_MODULE_SERVICE));
473        }
474        kualiModuleService.getInstalledModuleServices().add(this);
475    }
476
477    /**
478     * @return the moduleConfiguration
479     */
480    public ModuleConfiguration getModuleConfiguration() {
481        return this.moduleConfiguration;
482    }
483
484    /**
485     * @param moduleConfiguration the moduleConfiguration to set
486     */
487    public void setModuleConfiguration(ModuleConfiguration moduleConfiguration) {
488        this.moduleConfiguration = moduleConfiguration;
489    }
490
491    /**
492     * @see org.kuali.rice.krad.service.ModuleService#isExternalizable(java.lang.Class)
493     */
494    @Override
495    public boolean isExternalizable(Class boClazz) {
496        if (boClazz == null) {
497            return false;
498        }
499        return ExternalizableBusinessObject.class.isAssignableFrom(boClazz);
500    }
501
502    public <T extends ExternalizableBusinessObject> T createNewObjectFromExternalizableClass(Class<T> boClass) {
503        try {
504            return (T) getExternalizableBusinessObjectImplementation(boClass).newInstance();
505        } catch (Exception e) {
506            throw new RuntimeException("Unable to create externalizable business object class", e);
507        }
508    }
509
510    public DataObjectRelationship getBusinessObjectRelationship(Class boClass, String attributeName,
511            String attributePrefix) {
512        return null;
513    }
514
515
516    /**
517     * @return the kualiModuleService
518     */
519    public KualiModuleService getKualiModuleService() {
520        return this.kualiModuleService;
521    }
522
523    /**
524     * @param kualiModuleService the kualiModuleService to set
525     */
526    public void setKualiModuleService(KualiModuleService kualiModuleService) {
527        this.kualiModuleService = kualiModuleService;
528    }
529
530    protected ConfigurationService getKualiConfigurationService() {
531        if (this.kualiConfigurationService == null) {
532            this.kualiConfigurationService = KRADServiceLocator.getKualiConfigurationService();
533        }
534
535        return this.kualiConfigurationService;
536    }
537
538    public void setKualiConfigurationService(ConfigurationService kualiConfigurationService) {
539        this.kualiConfigurationService = kualiConfigurationService;
540    }
541
542    /**
543     * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
544     */
545    @Override
546    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
547        this.applicationContext = applicationContext;
548    }
549
550    /**
551     * This overridden method ...
552     *
553     * @see org.kuali.rice.krad.service.ModuleService#listAlternatePrimaryKeyFieldNames(java.lang.Class)
554     */
555    @Override
556    public List<List<String>> listAlternatePrimaryKeyFieldNames(Class businessObjectInterfaceClass) {
557        return null;
558    }
559
560    /**
561     * This method determines whether or not this module is currently locked
562     *
563     * @see org.kuali.rice.krad.service.ModuleService#isLocked()
564     */
565    @Override
566    public boolean isLocked() {
567        ModuleConfiguration configuration = this.getModuleConfiguration();
568        if (configuration != null) {
569            String namespaceCode = configuration.getNamespaceCode();
570            String componentCode = KRADConstants.DetailTypes.ALL_DETAIL_TYPE;
571            String parameterName = KRADConstants.SystemGroupParameterNames.OLTP_LOCKOUT_ACTIVE_IND;
572            ParameterService parameterService = CoreFrameworkServiceLocator.getParameterService();
573            String shouldLockout = parameterService.getParameterValueAsString(namespaceCode, componentCode,
574                    parameterName);
575            if (StringUtils.isNotBlank(shouldLockout)) {
576                return parameterService.getParameterValueAsBoolean(namespaceCode, componentCode, parameterName);
577            }
578        }
579        return false;
580    }
581
582    /**
583     * Gets the lookupService attribute.
584     *
585     * @return Returns the lookupService.
586     */
587    protected LookupService getLookupService() {
588        return lookupService != null ? lookupService : KRADServiceLocatorWeb.getLookupService();
589    }
590    
591    @Override
592    public boolean goToCentralRiceForInquiry() { 
593        return false;
594    }
595}