001 /*
002 * Copyright 2011 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 */
016 package org.kuali.kfs.sec.businessobject.lookup;
017
018 import java.beans.PropertyDescriptor;
019 import java.sql.Date;
020 import java.util.Collection;
021 import java.util.HashMap;
022 import java.util.Iterator;
023 import java.util.List;
024 import java.util.Map;
025 import java.util.Set;
026
027 import org.apache.commons.beanutils.PropertyUtils;
028 import org.apache.commons.lang.StringUtils;
029 import org.kuali.kfs.integration.ld.SegmentedBusinessObject;
030 import org.kuali.kfs.sec.SecKeyConstants;
031 import org.kuali.kfs.sec.service.AccessSecurityService;
032 import org.kuali.kfs.sec.util.SecUtil;
033 import org.kuali.kfs.sys.KFSConstants;
034 import org.kuali.rice.kim.bo.Person;
035 import org.kuali.rice.kns.authorization.BusinessObjectRestrictions;
036 import org.kuali.rice.kns.authorization.FieldRestriction;
037 import org.kuali.rice.kns.bo.BusinessObject;
038 import org.kuali.rice.kns.bo.PersistableBusinessObject;
039 import org.kuali.rice.kns.lookup.AbstractLookupableHelperServiceImpl;
040 import org.kuali.rice.kns.lookup.HtmlData;
041 import org.kuali.rice.kns.lookup.LookupableHelperService;
042 import org.kuali.rice.kns.service.BusinessObjectAuthorizationService;
043 import org.kuali.rice.kns.service.BusinessObjectDictionaryService;
044 import org.kuali.rice.kns.service.BusinessObjectMetaDataService;
045 import org.kuali.rice.kns.service.DataDictionaryService;
046 import org.kuali.rice.kns.service.PersistenceStructureService;
047 import org.kuali.rice.kns.util.GlobalVariables;
048 import org.kuali.rice.kns.util.KNSConstants;
049 import org.kuali.rice.kns.util.ObjectUtils;
050 import org.kuali.rice.kns.web.comparator.CellComparatorHelper;
051 import org.kuali.rice.kns.web.format.BooleanFormatter;
052 import org.kuali.rice.kns.web.format.CollectionFormatter;
053 import org.kuali.rice.kns.web.format.DateFormatter;
054 import org.kuali.rice.kns.web.format.Formatter;
055 import org.kuali.rice.kns.web.struts.form.LookupForm;
056 import org.kuali.rice.kns.web.ui.Column;
057 import org.kuali.rice.kns.web.ui.Field;
058 import org.kuali.rice.kns.web.ui.ResultRow;
059 import org.kuali.rice.kns.web.ui.Row;
060
061
062 /**
063 * Wraps balance inquiry lookupables so that access security can be applied to the results
064 */
065 public class AccessSecurityBalanceLookupableHelperServiceImpl implements LookupableHelperService {
066 protected static final String ACTION_URLS_EMPTY = " ";
067
068 protected AccessSecurityService accessSecurityService;
069 protected LookupableHelperService lookupableHelperService;
070 protected BusinessObjectMetaDataService businessObjectMetaDataService;
071 protected BusinessObjectAuthorizationService businessObjectAuthorizationService;
072 protected PersistenceStructureService persistenceStructureService;
073
074 protected boolean glInquiry;
075 protected boolean laborInquiry;
076
077 public AccessSecurityBalanceLookupableHelperServiceImpl() {
078 glInquiry = false;
079 laborInquiry = false;
080 }
081
082 public boolean allowsMaintenanceNewOrCopyAction() {
083 return lookupableHelperService.allowsMaintenanceNewOrCopyAction();
084 }
085
086 public boolean allowsNewOrCopyAction(String documentTypeName) {
087 return lookupableHelperService.allowsNewOrCopyAction(documentTypeName);
088 }
089
090 public void applyFieldAuthorizationsFromNestedLookups(Field field) {
091 lookupableHelperService.applyFieldAuthorizationsFromNestedLookups(field);
092 }
093
094 public boolean checkForAdditionalFields(Map fieldValues) {
095 return lookupableHelperService.checkForAdditionalFields(fieldValues);
096 }
097
098 public String getActionUrls(BusinessObject businessObject, List pkNames, BusinessObjectRestrictions businessObjectRestrictions) {
099 return lookupableHelperService.getActionUrls(businessObject, pkNames, businessObjectRestrictions);
100 }
101
102 public String getBackLocation() {
103 return lookupableHelperService.getBackLocation();
104 }
105
106 public Class getBusinessObjectClass() {
107 return lookupableHelperService.getBusinessObjectClass();
108 }
109
110 public BusinessObjectDictionaryService getBusinessObjectDictionaryService() {
111 return lookupableHelperService.getBusinessObjectDictionaryService();
112 }
113
114 public List getColumns() {
115 return lookupableHelperService.getColumns();
116 }
117
118 public List<HtmlData> getCustomActionUrls(BusinessObject businessObject, List pkNames) {
119 return lookupableHelperService.getCustomActionUrls(businessObject, pkNames);
120 }
121
122 public DataDictionaryService getDataDictionaryService() {
123 return lookupableHelperService.getDataDictionaryService();
124 }
125
126 public List getDefaultSortColumns() {
127 return lookupableHelperService.getDefaultSortColumns();
128 }
129
130 public String getDocFormKey() {
131 return lookupableHelperService.getDocFormKey();
132 }
133
134 public String getDocNum() {
135 return lookupableHelperService.getDocNum();
136 }
137
138 public Field getExtraField() {
139 return lookupableHelperService.getExtraField();
140 }
141
142 public HtmlData getInquiryUrl(BusinessObject businessObject, String propertyName) {
143 return lookupableHelperService.getInquiryUrl(businessObject, propertyName);
144 }
145
146 public String getMaintenanceUrl(BusinessObject businessObject, HtmlData htmlData, List pkNames, BusinessObjectRestrictions businessObjectRestrictions) {
147 return lookupableHelperService.getMaintenanceUrl(businessObject, htmlData, pkNames, businessObjectRestrictions);
148 }
149
150 public Map getParameters() {
151 return lookupableHelperService.getParameters();
152 }
153
154 public String getPrimaryKeyFieldLabels() {
155 return lookupableHelperService.getPrimaryKeyFieldLabels();
156 }
157
158 public List<String> getReadOnlyFieldsList() {
159 return lookupableHelperService.getReadOnlyFieldsList();
160 }
161
162 public List getReturnKeys() {
163 return lookupableHelperService.getReturnKeys();
164 }
165
166 public String getReturnLocation() {
167 return lookupableHelperService.getReturnLocation();
168 }
169
170 public HtmlData getReturnUrl(BusinessObject businessObject, LookupForm lookupForm, List returnKeys, BusinessObjectRestrictions businessObjectRestrictions) {
171 return lookupableHelperService.getReturnUrl(businessObject, lookupForm, returnKeys, businessObjectRestrictions);
172 }
173
174 public HtmlData getReturnUrl(BusinessObject businessObject, Map fieldConversions, String lookupImpl, List returnKeys, BusinessObjectRestrictions businessObjectRestrictions) {
175 return lookupableHelperService.getReturnUrl(businessObject, fieldConversions, lookupImpl, returnKeys, businessObjectRestrictions);
176 }
177
178 public List<Row> getRows() {
179 return lookupableHelperService.getRows();
180 }
181
182 /**
183 * Gets search results and passes to access security service to apply access restrictions
184 *
185 * @see org.kuali.rice.kns.lookup.LookupableHelperService#getSearchResults(java.util.Map)
186 */
187 public List getSearchResults(Map<String, String> fieldValues) {
188 List results = lookupableHelperService.getSearchResults(fieldValues);
189
190 int resultSizeBeforeRestrictions = results.size();
191 if (glInquiry) {
192 accessSecurityService.applySecurityRestrictionsForGLInquiry(results, GlobalVariables.getUserSession().getPerson());
193 }
194 if (laborInquiry) {
195 accessSecurityService.applySecurityRestrictionsForLaborInquiry(results, GlobalVariables.getUserSession().getPerson());
196 }
197
198
199 SecUtil.compareListSizeAndAddMessageIfChanged(resultSizeBeforeRestrictions, results, SecKeyConstants.MESSAGE_BALANCE_INQUIRY_RESULTS_RESTRICTED);
200
201 return results;
202 }
203
204 /**
205 * Gets search results and passes to access security service to apply access restrictions
206 *
207 * @see org.kuali.rice.kns.lookup.LookupableHelperService#getSearchResultsUnbounded(java.util.Map)
208 */
209 public List getSearchResultsUnbounded(Map<String, String> fieldValues) {
210 List results = lookupableHelperService.getSearchResultsUnbounded(fieldValues);
211
212 int resultSizeBeforeRestrictions = results.size();
213 if (glInquiry) {
214 accessSecurityService.applySecurityRestrictionsForGLInquiry(results, GlobalVariables.getUserSession().getPerson());
215 }
216 if (laborInquiry) {
217 accessSecurityService.applySecurityRestrictionsForLaborInquiry(results, GlobalVariables.getUserSession().getPerson());
218 }
219
220 SecUtil.compareListSizeAndAddMessageIfChanged(resultSizeBeforeRestrictions, results, SecKeyConstants.MESSAGE_BALANCE_INQUIRY_RESULTS_RESTRICTED);
221
222 return results;
223 }
224
225 public String getSupplementalMenuBar() {
226 return lookupableHelperService.getSupplementalMenuBar();
227 }
228
229 public String getTitle() {
230 return lookupableHelperService.getTitle();
231 }
232
233 public boolean isResultReturnable(BusinessObject object) {
234 return lookupableHelperService.isResultReturnable(object);
235 }
236
237 public boolean isSearchUsingOnlyPrimaryKeyValues() {
238 return lookupableHelperService.isSearchUsingOnlyPrimaryKeyValues();
239 }
240
241 public void performClear(LookupForm lookupForm) {
242 lookupableHelperService.performClear(lookupForm);
243 }
244
245 public boolean performCustomAction(boolean ignoreErrors) {
246 return lookupableHelperService.performCustomAction(ignoreErrors);
247 }
248
249 /**
250 * Need to duplicate the logic of performLookup so that getSearchResults will be called on this class and not the nested lookup helper service
251 *
252 * @see org.kuali.rice.kns.lookup.LookupableHelperService#performLookup(org.kuali.rice.kns.web.struts.form.LookupForm, java.util.Collection, boolean)
253 */
254 public Collection performLookup(LookupForm lookupForm, Collection resultTable, boolean bounded) {
255 Map lookupFormFields = lookupForm.getFieldsForLookup();
256
257 setBackLocation((String) lookupForm.getFieldsForLookup().get(KNSConstants.BACK_LOCATION));
258 setDocFormKey((String) lookupForm.getFieldsForLookup().get(KNSConstants.DOC_FORM_KEY));
259 Collection displayList;
260
261
262 preprocessDateFields(lookupFormFields);
263
264 Map fieldsForLookup = new HashMap(lookupForm.getFieldsForLookup());
265 // call search method to get results
266 if (bounded) {
267 displayList = getSearchResults(lookupForm.getFieldsForLookup());
268 }
269 else {
270 displayList = getSearchResultsUnbounded(lookupForm.getFieldsForLookup());
271 }
272
273 HashMap<String, Class> propertyTypes = new HashMap<String, Class>();
274
275 boolean hasReturnableRow = false;
276
277 List returnKeys = getReturnKeys();
278 List pkNames = businessObjectMetaDataService.listPrimaryKeyFieldNames(getBusinessObjectClass());
279 Person user = GlobalVariables.getUserSession().getPerson();
280
281 // iterate through result list and wrap rows with return url and action urls
282 for (Iterator iter = displayList.iterator(); iter.hasNext();) {
283 BusinessObject element = (BusinessObject) iter.next();
284 if (element instanceof PersistableBusinessObject) {
285 lookupForm.setLookupObjectId(((PersistableBusinessObject) element).getObjectId());
286 }
287
288 BusinessObjectRestrictions businessObjectRestrictions = businessObjectAuthorizationService.getLookupResultRestrictions(element, user);
289
290 HtmlData returnUrl = getReturnUrl(element, lookupForm, returnKeys, businessObjectRestrictions);
291
292 String actionUrls = getActionUrls(element, pkNames, businessObjectRestrictions);
293 // Fix for JIRA - KFSMI-2417
294 if ("".equals(actionUrls)) {
295 actionUrls = ACTION_URLS_EMPTY;
296 }
297
298 List<Column> columns = getColumns();
299 for (Iterator iterator = columns.iterator(); iterator.hasNext();) {
300
301 Column col = (Column) iterator.next();
302 Formatter formatter = col.getFormatter();
303
304 // pick off result column from result list, do formatting
305 String propValue = KNSConstants.EMPTY_STRING;
306 Object prop = ObjectUtils.getPropertyValue(element, col.getPropertyName());
307
308 // set comparator and formatter based on property type
309 Class propClass = propertyTypes.get(col.getPropertyName());
310 if (propClass == null) {
311 try {
312 propClass = ObjectUtils.getPropertyType(element, col.getPropertyName(), persistenceStructureService);
313 propertyTypes.put(col.getPropertyName(), propClass);
314 }
315 catch (Exception e) {
316 throw new RuntimeException("Cannot access PropertyType for property " + "'" + col.getPropertyName() + "' " + " on an instance of '" + element.getClass().getName() + "'.", e);
317 }
318 }
319
320 // formatters
321 if (prop != null) {
322 // for Booleans, always use BooleanFormatter
323 if (prop instanceof Boolean) {
324 formatter = new BooleanFormatter();
325 }
326
327 // for Dates, always use DateFormatter
328 if (prop instanceof Date) {
329 formatter = new DateFormatter();
330 }
331
332 // for collection, use the list formatter if a formatter hasn't been defined yet
333 if (prop instanceof Collection && formatter == null) {
334 formatter = new CollectionFormatter();
335 }
336
337 if (formatter != null) {
338 propValue = (String) formatter.format(prop);
339 }
340 else {
341 propValue = prop.toString();
342 }
343 }
344
345 // comparator
346 col.setComparator(CellComparatorHelper.getAppropriateComparatorForPropertyClass(propClass));
347 col.setValueComparator(CellComparatorHelper.getAppropriateValueComparatorForPropertyClass(propClass));
348
349 propValue = maskValueIfNecessary(element.getClass(), col.getPropertyName(), propValue, businessObjectRestrictions);
350
351 col.setPropertyValue(propValue);
352
353 if (StringUtils.isNotBlank(propValue)) {
354 col.setColumnAnchor(getInquiryUrl(element, col.getPropertyName()));
355
356 }
357 }
358
359 ResultRow row = new ResultRow(columns, returnUrl.constructCompleteHtmlTag(), actionUrls);
360 row.setRowId(returnUrl.getName());
361 row.setReturnUrlHtmlData(returnUrl);
362 // because of concerns of the BO being cached in session on the ResultRow,
363 // let's only attach it when needed (currently in the case of export)
364 if (getBusinessObjectDictionaryService().isExportable(getBusinessObjectClass())) {
365 row.setBusinessObject(element);
366 }
367
368 if(element instanceof SegmentedBusinessObject) {
369 for (String propertyName : ((SegmentedBusinessObject) element).getSegmentedPropertyNames()) {
370 columns.add(setupResultsColumn(element, propertyName, businessObjectRestrictions));
371 }
372 }
373
374 if (element instanceof PersistableBusinessObject) {
375 row.setObjectId((((PersistableBusinessObject) element).getObjectId()));
376 }
377
378
379 boolean rowReturnable = isResultReturnable(element);
380 row.setRowReturnable(rowReturnable);
381 if (rowReturnable) {
382 hasReturnableRow = true;
383 }
384 resultTable.add(row);
385 }
386
387 lookupForm.setHasReturnableRow(hasReturnableRow);
388
389 return displayList;
390 }
391
392 /**
393 * @param element
394 * @param attributeName
395 * @return Column
396 */
397 protected Column setupResultsColumn(BusinessObject element, String attributeName, BusinessObjectRestrictions businessObjectRestrictions) {
398 Column col = new Column();
399
400 col.setPropertyName(attributeName);
401
402 String columnTitle = getDataDictionaryService().getAttributeLabel(getBusinessObjectClass(), attributeName);
403 if (StringUtils.isBlank(columnTitle)) {
404 columnTitle = getDataDictionaryService().getCollectionLabel(getBusinessObjectClass(), attributeName);
405 }
406 col.setColumnTitle(columnTitle);
407 col.setMaxLength(getDataDictionaryService().getAttributeMaxLength(getBusinessObjectClass(), attributeName));
408
409 Class formatterClass = getDataDictionaryService().getAttributeFormatter(getBusinessObjectClass(), attributeName);
410 Formatter formatter = null;
411 if (formatterClass != null) {
412 try {
413 formatter = (Formatter) formatterClass.newInstance();
414 col.setFormatter(formatter);
415 }
416 catch (InstantiationException e) {
417 throw new RuntimeException("Unable to get new instance of formatter class: " + formatterClass.getName());
418 }
419 catch (IllegalAccessException e) {
420 throw new RuntimeException("Unable to get new instance of formatter class: " + formatterClass.getName());
421 }
422 }
423
424 // pick off result column from result list, do formatting
425 String propValue = KFSConstants.EMPTY_STRING;
426 Object prop = ObjectUtils.getPropertyValue(element, attributeName);
427
428 // set comparator and formatter based on property type
429 Class propClass = null;
430 try {
431 PropertyDescriptor propDescriptor = PropertyUtils.getPropertyDescriptor(element, col.getPropertyName());
432 if (propDescriptor != null) {
433 propClass = propDescriptor.getPropertyType();
434 }
435 }
436 catch (Exception e) {
437 throw new RuntimeException("Cannot access PropertyType for property " + "'" + col.getPropertyName() + "' " + " on an instance of '" + element.getClass().getName() + "'.", e);
438 }
439
440 // formatters
441 if (prop != null) {
442 // for Booleans, always use BooleanFormatter
443 if (prop instanceof Boolean) {
444 formatter = new BooleanFormatter();
445 }
446
447 if (formatter != null) {
448 propValue = (String) formatter.format(prop);
449 }
450 else {
451 propValue = prop.toString();
452 }
453 }
454
455 // comparator
456 col.setComparator(CellComparatorHelper.getAppropriateComparatorForPropertyClass(propClass));
457 col.setValueComparator(CellComparatorHelper.getAppropriateValueComparatorForPropertyClass(propClass));
458
459 propValue = maskValueIfNecessary(element.getClass(), col.getPropertyName(), propValue, businessObjectRestrictions);
460 col.setPropertyValue(propValue);
461
462
463 if (StringUtils.isNotBlank(propValue)) {
464 col.setColumnAnchor(getInquiryUrl(element, col.getPropertyName()));
465 }
466 return col;
467 }
468
469 /**
470 * changes from/to dates into the range operators the lookupable dao expects ("..",">" etc) this method modifies the passed in map and returns a list containing only the
471 * modified fields
472 *
473 * @param lookupFormFields
474 */
475 protected Map<String, String> preprocessDateFields(Map lookupFormFields) {
476 Map<String, String> fieldsToUpdate = new HashMap<String, String>();
477 Set<String> fieldsForLookup = lookupFormFields.keySet();
478 for (String propName : fieldsForLookup) {
479 if (propName.startsWith(KNSConstants.LOOKUP_RANGE_LOWER_BOUND_PROPERTY_PREFIX)) {
480 String fromDateValue = (String) lookupFormFields.get(propName);
481 String dateFieldName = StringUtils.remove(propName, KNSConstants.LOOKUP_RANGE_LOWER_BOUND_PROPERTY_PREFIX);
482 String dateValue = (String) lookupFormFields.get(dateFieldName);
483 String newPropValue = dateValue;// maybe clean above with ObjectUtils.clean(propertyValue)
484 if (StringUtils.isNotEmpty(fromDateValue) && StringUtils.isNotEmpty(dateValue)) {
485 newPropValue = fromDateValue + KNSConstants.BETWEEN_OPERATOR + dateValue;
486 }
487 else if (StringUtils.isNotEmpty(fromDateValue) && StringUtils.isEmpty(dateValue)) {
488 newPropValue = ">=" + fromDateValue;
489 }
490 else if (StringUtils.isNotEmpty(dateValue) && StringUtils.isEmpty(fromDateValue)) {
491 newPropValue = "<=" + dateValue;
492 } // could optionally continue on else here
493
494 fieldsToUpdate.put(dateFieldName, newPropValue);
495 }
496 }
497 // update lookup values from found date values to update
498 Set<String> keysToUpdate = fieldsToUpdate.keySet();
499 for (String updateKey : keysToUpdate) {
500 lookupFormFields.put(updateKey, fieldsToUpdate.get(updateKey));
501 }
502 return fieldsToUpdate;
503 }
504
505 protected String maskValueIfNecessary(Class businessObjectClass, String propertyName, String propertyValue, BusinessObjectRestrictions businessObjectRestrictions) {
506 String maskedPropertyValue = propertyValue;
507 if (businessObjectRestrictions != null) {
508 FieldRestriction fieldRestriction = businessObjectRestrictions.getFieldRestriction(propertyName);
509 if (fieldRestriction != null && (fieldRestriction.isMasked() || fieldRestriction.isPartiallyMasked())) {
510 maskedPropertyValue = fieldRestriction.getMaskFormatter().maskValue(propertyValue);
511 }
512 }
513 return maskedPropertyValue;
514 }
515
516 public void setBackLocation(String backLocation) {
517 lookupableHelperService.setBackLocation(backLocation);
518 }
519
520 public void setBusinessObjectClass(Class businessObjectClass) {
521 lookupableHelperService.setBusinessObjectClass(businessObjectClass);
522 }
523
524 public void setDocFormKey(String docFormKey) {
525 lookupableHelperService.setDocFormKey(docFormKey);
526 }
527
528 public void setDocNum(String docNum) {
529 lookupableHelperService.setDocNum(docNum);
530 }
531
532 public void setFieldConversions(Map fieldConversions) {
533 lookupableHelperService.setFieldConversions(fieldConversions);
534 }
535
536 public void setParameters(Map parameters) {
537 lookupableHelperService.setParameters(parameters);
538 }
539
540 public void setReadOnlyFieldsList(List<String> readOnlyFieldsList) {
541 lookupableHelperService.setReadOnlyFieldsList(readOnlyFieldsList);
542 }
543
544 public boolean shouldDisplayHeaderNonMaintActions() {
545 return lookupableHelperService.shouldDisplayHeaderNonMaintActions();
546 }
547
548 public boolean shouldDisplayLookupCriteria() {
549 return lookupableHelperService.shouldDisplayLookupCriteria();
550 }
551
552 public void validateSearchParameters(Map fieldValues) {
553 lookupableHelperService.validateSearchParameters(fieldValues);
554 }
555
556 /**
557 * Sets the accessSecurityService attribute value.
558 *
559 * @param accessSecurityService The accessSecurityService to set.
560 */
561 public void setAccessSecurityService(AccessSecurityService accessSecurityService) {
562 this.accessSecurityService = accessSecurityService;
563 }
564
565 /**
566 * Sets the lookupableHelperService attribute value.
567 *
568 * @param lookupableHelperService The lookupableHelperService to set.
569 */
570 public void setLookupableHelperService(LookupableHelperService lookupableHelperService) {
571 this.lookupableHelperService = lookupableHelperService;
572 }
573
574 /**
575 * Sets the businessObjectMetaDataService attribute value.
576 *
577 * @param businessObjectMetaDataService The businessObjectMetaDataService to set.
578 */
579 public void setBusinessObjectMetaDataService(BusinessObjectMetaDataService businessObjectMetaDataService) {
580 this.businessObjectMetaDataService = businessObjectMetaDataService;
581 }
582
583 /**
584 * Sets the businessObjectAuthorizationService attribute value.
585 *
586 * @param businessObjectAuthorizationService The businessObjectAuthorizationService to set.
587 */
588 public void setBusinessObjectAuthorizationService(BusinessObjectAuthorizationService businessObjectAuthorizationService) {
589 this.businessObjectAuthorizationService = businessObjectAuthorizationService;
590 }
591
592 /**
593 * Sets the persistenceStructureService attribute value.
594 *
595 * @param persistenceStructureService The persistenceStructureService to set.
596 */
597 public void setPersistenceStructureService(PersistenceStructureService persistenceStructureService) {
598 this.persistenceStructureService = persistenceStructureService;
599 }
600
601 /**
602 * Sets the glInquiry attribute value.
603 *
604 * @param glInquiry The glInquiry to set.
605 */
606 public void setGlInquiry(boolean glInquiry) {
607 this.glInquiry = glInquiry;
608 }
609
610 /**
611 * Sets the laborInquiry attribute value.
612 *
613 * @param laborInquiry The laborInquiry to set.
614 */
615 public void setLaborInquiry(boolean laborInquiry) {
616 this.laborInquiry = laborInquiry;
617 }
618
619 //@Override
620 public void applyConditionalLogicForFieldDisplay() {
621 // TODO Auto-generated method stub
622 }
623
624 }