1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kns.web.struts.action;
17
18 import org.apache.commons.lang.ObjectUtils;
19 import org.apache.commons.lang.StringUtils;
20 import org.apache.struts.action.ActionForm;
21 import org.apache.struts.action.ActionForward;
22 import org.apache.struts.action.ActionMapping;
23 import org.apache.struts.actions.DispatchAction;
24 import org.kuali.rice.coreservice.framework.CoreFrameworkServiceLocator;
25 import org.kuali.rice.coreservice.framework.parameter.ParameterService;
26 import org.kuali.rice.core.api.CoreApiServiceLocator;
27 import org.kuali.rice.core.api.encryption.EncryptionService;
28 import org.kuali.rice.core.api.util.RiceConstants;
29 import org.kuali.rice.kew.api.KewApiConstants;
30 import org.kuali.rice.kim.api.KimConstants;
31 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
32 import org.kuali.rice.kns.document.authorization.DocumentAuthorizerBase;
33 import org.kuali.rice.kns.lookup.LookupUtils;
34 import org.kuali.rice.kns.service.BusinessObjectAuthorizationService;
35 import org.kuali.rice.kns.service.KNSServiceLocator;
36 import org.kuali.rice.kns.util.KNSGlobalVariables;
37 import org.kuali.rice.kns.util.WebUtils;
38 import org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase;
39 import org.kuali.rice.kns.web.struts.form.KualiForm;
40 import org.kuali.rice.kns.web.struts.form.LookupForm;
41 import org.kuali.rice.kns.web.struts.form.pojo.PojoForm;
42 import org.kuali.rice.kns.web.struts.form.pojo.PojoFormBase;
43 import org.kuali.rice.krad.bo.BusinessObject;
44 import org.kuali.rice.krad.exception.AuthorizationException;
45 import org.kuali.rice.krad.service.KRADServiceLocator;
46 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
47 import org.kuali.rice.krad.service.KualiModuleService;
48 import org.kuali.rice.krad.service.ModuleService;
49 import org.kuali.rice.krad.util.GlobalVariables;
50 import org.kuali.rice.krad.util.KRADConstants;
51 import org.kuali.rice.krad.util.KRADUtils;
52 import org.kuali.rice.krad.util.UrlFactory;
53
54 import javax.servlet.http.HttpServletRequest;
55 import javax.servlet.http.HttpServletResponse;
56 import java.util.Arrays;
57 import java.util.Enumeration;
58 import java.util.HashMap;
59 import java.util.HashSet;
60 import java.util.Map;
61 import java.util.Properties;
62 import java.util.Set;
63
64
65
66
67
68
69
70
71
72
73
74 public abstract class KualiAction extends DispatchAction {
75 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(KualiAction.class);
76
77 private static KualiModuleService kualiModuleService = null;
78 private static BusinessObjectAuthorizationService businessObjectAuthorizationService = null;
79 private static EncryptionService encryptionService = null;
80 private static Boolean OUTPUT_ENCRYPTION_WARNING = null;
81 private static String applicationBaseUrl = null;
82
83 private Set<String> methodToCallsToNotCheckAuthorization = new HashSet<String>();
84
85 {
86 methodToCallsToNotCheckAuthorization.add( "performLookup" );
87 methodToCallsToNotCheckAuthorization.add( "performQuestion" );
88 methodToCallsToNotCheckAuthorization.add( "performQuestionWithInput" );
89 methodToCallsToNotCheckAuthorization.add( "performQuestionWithInputAgainBecauseOfErrors" );
90 methodToCallsToNotCheckAuthorization.add( "performQuestionWithoutInput" );
91 methodToCallsToNotCheckAuthorization.add( "performWorkgroupLookup" );
92 }
93
94
95
96
97
98
99
100
101
102
103
104 public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
105 ActionForward returnForward = null;
106
107 String methodToCall = findMethodToCall(form, request);
108
109 if(isModuleLocked(form, methodToCall, request)) {
110 return mapping.findForward(RiceConstants.MODULE_LOCKED_MAPPING);
111 }
112
113 if (form instanceof KualiForm && StringUtils.isNotEmpty(((KualiForm) form).getMethodToCall())) {
114 if (StringUtils.isNotBlank(getImageContext(request, KRADConstants.ANCHOR))) {
115 ((KualiForm) form).setAnchor(getImageContext(request, KRADConstants.ANCHOR));
116 }
117 else if (StringUtils.isNotBlank(request.getParameter(KRADConstants.ANCHOR))) {
118 ((KualiForm) form).setAnchor(request.getParameter(KRADConstants.ANCHOR));
119 }
120 else {
121 ((KualiForm) form).setAnchor(KRADConstants.ANCHOR_TOP_OF_FORM);
122 }
123 }
124
125 if (StringUtils.isNotBlank(methodToCall)) {
126 if ( LOG.isDebugEnabled() ) {
127 LOG.debug("methodToCall: '" + methodToCall+"'");
128 }
129 returnForward = dispatchMethod(mapping, form, request, response, methodToCall);
130 }
131 else {
132 returnForward = defaultDispatch(mapping, form, request, response);
133 }
134
135
136 if ( !methodToCallsToNotCheckAuthorization.contains(methodToCall) ) {
137 if ( LOG.isDebugEnabled() ) {
138 LOG.debug( "'" + methodToCall + "' not in set of excempt methods: " + methodToCallsToNotCheckAuthorization);
139 }
140 checkAuthorization(form, methodToCall);
141 } else {
142 if ( LOG.isDebugEnabled() ) {
143 LOG.debug("'" + methodToCall + "' is exempt from auth checks." );
144 }
145 }
146
147
148
149
150 if(KNSGlobalVariables.getKualiForm() == null) {
151 KNSGlobalVariables.setKualiForm((KualiForm)form);
152 }
153
154 return returnForward;
155 }
156
157
158
159
160
161 protected ActionForward defaultDispatch(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
162 return mapping.findForward(RiceConstants.MAPPING_BASIC);
163 }
164
165 @Override
166 protected ActionForward dispatchMethod(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String methodToCall) throws Exception {
167 GlobalVariables.getUserSession().addObject(DocumentAuthorizerBase.USER_SESSION_METHOD_TO_CALL_OBJECT_KEY, methodToCall);
168 return super.dispatchMethod(mapping, form, request, response, methodToCall);
169 }
170
171 protected String findMethodToCall(ActionForm form, HttpServletRequest request) throws Exception {
172 String methodToCall;
173 if (form instanceof KualiForm && StringUtils.isNotEmpty(((KualiForm) form).getMethodToCall())) {
174 methodToCall = ((KualiForm) form).getMethodToCall();
175 }
176 else {
177
178 methodToCall = WebUtils.parseMethodToCall(form, request);
179 }
180 return methodToCall;
181 }
182
183
184
185
186
187
188
189
190
191
192
193 public ActionForward toggleTab(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
194 KualiForm kualiForm = (KualiForm) form;
195 String tabToToggle = getTabToToggle(request);
196 if (StringUtils.isNotBlank(tabToToggle)) {
197 if (kualiForm.getTabState(tabToToggle).equals("OPEN")) {
198 kualiForm.getTabStates().remove(tabToToggle);
199 kualiForm.getTabStates().put(tabToToggle, "CLOSE");
200 }
201 else {
202 kualiForm.getTabStates().remove(tabToToggle);
203 kualiForm.getTabStates().put(tabToToggle, "OPEN");
204 }
205 }
206
207 doProcessingAfterPost( kualiForm, request );
208 return mapping.findForward(RiceConstants.MAPPING_BASIC);
209 }
210
211
212
213
214
215
216
217
218
219
220
221 public ActionForward showAllTabs(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
222 return this.doTabOpenOrClose(mapping, form, request, response, true);
223 }
224
225
226
227
228
229
230
231
232
233
234
235 public ActionForward hideAllTabs(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
236 return this.doTabOpenOrClose(mapping, form, request, response, false);
237 }
238
239
240
241
242
243
244
245
246
247
248
249
250 private ActionForward doTabOpenOrClose(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, boolean open) {
251 KualiForm kualiForm = (KualiForm) form;
252
253 Map<String, String> tabStates = kualiForm.getTabStates();
254 Map<String, String> newTabStates = new HashMap<String, String>();
255 for (String tabKey: tabStates.keySet()) {
256 newTabStates.put(tabKey, open ? "OPEN" : "CLOSE");
257 }
258 kualiForm.setTabStates(newTabStates);
259 doProcessingAfterPost( kualiForm, request );
260 return mapping.findForward(RiceConstants.MAPPING_BASIC);
261 }
262
263
264
265
266
267
268
269
270
271
272
273 public ActionForward refresh(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
274 return mapping.findForward(RiceConstants.MAPPING_BASIC);
275 }
276
277
278
279
280
281
282
283
284 protected int getLineToDelete(HttpServletRequest request) {
285 return getSelectedLine(request);
286 }
287
288
289
290
291
292
293
294 protected int getSelectedLine(HttpServletRequest request) {
295 int selectedLine = -1;
296 String parameterName = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
297 if (StringUtils.isNotBlank(parameterName)) {
298 String lineNumber = StringUtils.substringBetween(parameterName, ".line", ".");
299 if (StringUtils.isEmpty(lineNumber)) {
300 return selectedLine;
301 }
302 selectedLine = Integer.parseInt(lineNumber);
303 }
304
305 return selectedLine;
306 }
307
308
309
310
311
312
313
314 protected String getTabToToggle(HttpServletRequest request) {
315 String tabToToggle = "";
316 String parameterName = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
317 if (StringUtils.isNotBlank(parameterName)) {
318 tabToToggle = StringUtils.substringBetween(parameterName, ".tab", ".");
319 }
320
321 return tabToToggle;
322 }
323
324
325
326
327
328
329
330 protected String getHeaderTabNavigateTo(HttpServletRequest request) {
331 String headerTabNavigateTo = RiceConstants.MAPPING_BASIC;
332 String imageContext = getImageContext(request, KRADConstants.NAVIGATE_TO);
333 if (StringUtils.isNotBlank(imageContext)) {
334 headerTabNavigateTo = imageContext;
335 }
336 return headerTabNavigateTo;
337 }
338
339
340
341
342
343
344
345 protected String getHeaderTabDispatch(HttpServletRequest request) {
346 String headerTabDispatch = null;
347 String imageContext = getImageContext(request, KRADConstants.HEADER_DISPATCH);
348 if (StringUtils.isNotBlank(imageContext)) {
349 headerTabDispatch = imageContext;
350 }
351 else {
352
353 headerTabDispatch = request.getParameter(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
354 }
355 return headerTabDispatch;
356 }
357
358
359
360
361
362
363
364
365 protected String getImageContext(HttpServletRequest request, String contextKey) {
366 String imageContext = "";
367 String parameterName = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
368 if (StringUtils.isBlank(parameterName)) {
369 parameterName = request.getParameter("methodToCallPath");
370 }
371 if (StringUtils.isNotBlank(parameterName)) {
372 imageContext = StringUtils.substringBetween(parameterName, contextKey, ".");
373 }
374 return imageContext;
375 }
376
377 protected String getReturnLocation(HttpServletRequest request, ActionMapping mapping) {
378 String mappingPath = mapping.getPath();
379 String basePath = getApplicationBaseUrl();
380 return basePath + ("/lookup".equals(mappingPath) || "/maintenance".equals(mappingPath) || "/multipleValueLookup".equals(mappingPath) ? "/kr" : "") + mappingPath + ".do";
381 }
382
383
384
385
386
387
388
389
390
391
392
393
394
395 protected String retrieveLookupParameterValue(Class<? extends BusinessObject> boClass, String parameterName, String parameterValuePropertyName, ActionForm form, HttpServletRequest request) throws Exception {
396 String value;
397 if (StringUtils.contains(parameterValuePropertyName, "'")) {
398 value = StringUtils.replace(parameterValuePropertyName, "'", "");
399 } else if (request.getParameterMap().containsKey(parameterValuePropertyName)) {
400 value = request.getParameter(parameterValuePropertyName);
401 } else if (request.getParameterMap().containsKey(KewApiConstants.DOCUMENT_ATTRIBUTE_FIELD_PREFIX + parameterValuePropertyName)) {
402 value = request.getParameter(KewApiConstants.DOCUMENT_ATTRIBUTE_FIELD_PREFIX + parameterValuePropertyName);
403 } else {
404 if (form instanceof KualiForm) {
405 value = ((KualiForm) form).retrieveFormValueForLookupInquiryParameters(parameterName, parameterValuePropertyName);
406 } else {
407 if (LOG.isDebugEnabled()) {
408 LOG.debug("Unable to retrieve lookup/inquiry parameter value for parameter name " + parameterName + " parameter value property " + parameterValuePropertyName);
409 }
410 value = null;
411 }
412 }
413
414 if (value != null && boClass != null && getBusinessObjectAuthorizationService().attributeValueNeedsToBeEncryptedOnFormsAndLinks(boClass, parameterName)) {
415 value = getEncryptionService().encrypt(value) + EncryptionService.ENCRYPTION_POST_PREFIX;
416 }
417 return value;
418 }
419
420
421
422
423
424
425
426
427
428
429
430 @SuppressWarnings("unchecked")
431 public ActionForward performLookup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
432
433 String fullParameter = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
434 validateLookupInquiryFullParameter(request, form, fullParameter);
435
436 KualiForm kualiForm = (KualiForm) form;
437
438
439 kualiForm.registerEditableProperty(KRADConstants.DISPATCH_REQUEST_PARAMETER);
440
441
442 String baseLookupUrl = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM14_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM14_RIGHT_DEL);
443
444
445 String boClassName = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_BOPARM_LEFT_DEL, KRADConstants.METHOD_TO_CALL_BOPARM_RIGHT_DEL);
446 if (StringUtils.isBlank(boClassName)) {
447 throw new RuntimeException("Illegal call to perform lookup, no business object class name specified.");
448 }
449 Class boClass = null;
450 try{
451 boClass = Class.forName(boClassName);
452 } catch(ClassNotFoundException cnfex){
453 throw new IllegalArgumentException("The classname (" + boClassName + ") does not represent a valid class which this application understands.");
454 }
455
456
457 Properties parameters = new Properties();
458 String conversionFields = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
459 if (StringUtils.isNotBlank(conversionFields)) {
460 parameters.put(KRADConstants.CONVERSION_FIELDS_PARAMETER, conversionFields);
461
462
463 String[] fieldConversions = conversionFields.split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR);
464 for (String fieldConversion : fieldConversions) {
465 String destination = fieldConversion.split(KRADConstants.FIELD_CONVERSION_PAIR_SEPARATOR, 2)[1];
466 kualiForm.registerEditableProperty(destination);
467 }
468 }
469
470
471 String parameterFields = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
472 if ( LOG.isDebugEnabled() ) {
473 LOG.debug( "fullParameter: " + fullParameter );
474 LOG.debug( "parameterFields: " + parameterFields );
475 }
476 if (StringUtils.isNotBlank(parameterFields)) {
477 String[] lookupParams = parameterFields.split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR);
478 if ( LOG.isDebugEnabled() ) {
479 LOG.debug( "lookupParams: " + Arrays.toString(lookupParams) );
480 }
481 for (String lookupParam : lookupParams) {
482 String[] keyValue = lookupParam.split(KRADConstants.FIELD_CONVERSION_PAIR_SEPARATOR, 2);
483 if (keyValue.length != 2) {
484 throw new RuntimeException("malformed field conversion pair: " + Arrays.toString(keyValue));
485 }
486
487 String lookupParameterValue = retrieveLookupParameterValue(boClass, keyValue[1], keyValue[0], form, request);
488 if (StringUtils.isNotBlank(lookupParameterValue)) {
489 parameters.put(keyValue[1], lookupParameterValue);
490 }
491
492 if ( LOG.isDebugEnabled() ) {
493 LOG.debug( "keyValue[0]: " + keyValue[0] );
494 LOG.debug( "keyValue[1]: " + keyValue[1] );
495 }
496 }
497 }
498
499
500 String readOnlyFields = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM8_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM8_RIGHT_DEL);
501 if (StringUtils.isNotBlank(readOnlyFields)) {
502 parameters.put(KRADConstants.LOOKUP_READ_ONLY_FIELDS, readOnlyFields);
503 }
504
505 if ( LOG.isDebugEnabled() ) {
506 LOG.debug( "fullParameter: " + fullParameter );
507 LOG.debug( "readOnlyFields: " + readOnlyFields );
508 }
509
510
511 String hideReturnLink = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM3_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM3_RIGHT_DEL);
512 if (StringUtils.isNotBlank(hideReturnLink)) {
513 parameters.put(KRADConstants.HIDE_LOOKUP_RETURN_LINK, hideReturnLink);
514 }
515
516
517 String extraButtonSource = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM4_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM4_RIGHT_DEL);
518 if (StringUtils.isNotBlank(extraButtonSource)) {
519 parameters.put(KRADConstants.EXTRA_BUTTON_SOURCE, extraButtonSource);
520 }
521 String extraButtonParams = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM5_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM5_RIGHT_DEL);
522 if (StringUtils.isNotBlank(extraButtonParams)) {
523 parameters.put(KRADConstants.EXTRA_BUTTON_PARAMS, extraButtonParams);
524 }
525
526 String lookupAction = KRADConstants.LOOKUP_ACTION;
527
528
529 boolean isMultipleValue = false;
530 String multipleValues = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM6_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM6_RIGHT_DEL);
531 if ((new Boolean(multipleValues).booleanValue())) {
532 parameters.put(KRADConstants.MULTIPLE_VALUE, multipleValues);
533 lookupAction = KRADConstants.MULTIPLE_VALUE_LOOKUP_ACTION;
534 isMultipleValue = true;
535 }
536
537
538 String lookedUpCollectionName = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM11_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM11_RIGHT_DEL);
539 if (StringUtils.isNotBlank(lookedUpCollectionName)) {
540 parameters.put(KRADConstants.LOOKED_UP_COLLECTION_NAME, lookedUpCollectionName);
541 }
542
543
544 String supressActions = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM7_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM7_RIGHT_DEL);
545 if (StringUtils.isNotBlank(supressActions)) {
546 parameters.put(KRADConstants.SUPPRESS_ACTIONS, supressActions);
547 }
548
549
550 String referencesToRefresh = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM10_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM10_RIGHT_DEL);
551 if (StringUtils.isNotBlank(referencesToRefresh)) {
552 parameters.put(KRADConstants.REFERENCES_TO_REFRESH, referencesToRefresh);
553 }
554
555
556 if (form instanceof KualiForm && StringUtils.isNotEmpty(((KualiForm) form).getAnchor())) {
557 parameters.put(KRADConstants.LOOKUP_ANCHOR, ((KualiForm) form).getAnchor());
558 }
559
560
561 parameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, "start");
562
563
564 String autoSearch = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM9_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM9_RIGHT_DEL);
565
566 if (StringUtils.isNotBlank(autoSearch)) {
567 parameters.put(KRADConstants.LOOKUP_AUTO_SEARCH, autoSearch);
568 if ("YES".equalsIgnoreCase(autoSearch)){
569 parameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, "search");
570 }
571 }
572
573 parameters.put(KRADConstants.DOC_FORM_KEY, GlobalVariables.getUserSession().addObjectWithGeneratedKey(form));
574 parameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, boClassName);
575
576 parameters.put(KRADConstants.RETURN_LOCATION_PARAMETER, getReturnLocation(request, mapping));
577
578 if (form instanceof KualiDocumentFormBase) {
579 String docNum = ((KualiDocumentFormBase) form).getDocument().getDocumentNumber();
580 if(docNum != null){
581 parameters.put(KRADConstants.DOC_NUM, docNum);
582 }
583 }else if(form instanceof LookupForm){
584 String docNum = ((LookupForm) form).getDocNum();
585 if(docNum != null){
586 parameters.put(KRADConstants.DOC_NUM, ((LookupForm) form).getDocNum());
587 }
588 }
589
590 if (boClass != null) {
591 ModuleService responsibleModuleService = getKualiModuleService().getResponsibleModuleService(boClass);
592 if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)){
593 Map<String, String> parameterMap = new HashMap<String, String>();
594 Enumeration<Object> e = parameters.keys();
595 while (e.hasMoreElements()) {
596 String paramName = (String) e.nextElement();
597 parameterMap.put(paramName, parameters.getProperty(paramName));
598 }
599 return new ActionForward(responsibleModuleService.getExternalizableBusinessObjectLookupUrl(boClass, parameterMap), true);
600 }
601 }
602
603 if (StringUtils.isBlank(baseLookupUrl)) {
604 baseLookupUrl = getApplicationBaseUrl() + "/kr/" + lookupAction;
605 } else {
606 if (isMultipleValue) {
607 LookupUtils.transformLookupUrlToMultiple(baseLookupUrl);
608 }
609 }
610 String lookupUrl = UrlFactory.parameterizeUrl(baseLookupUrl, parameters);
611 return new ActionForward(lookupUrl, true);
612 }
613
614 protected void validateLookupInquiryFullParameter(HttpServletRequest request, ActionForm form, String fullParameter){
615 PojoFormBase pojoFormBase = (PojoFormBase) form;
616 if(WebUtils.isFormSessionDocument((PojoFormBase) form)){
617 if(!pojoFormBase.isPropertyEditable(fullParameter)) {
618 throw new RuntimeException("The methodToCallAttribute is not registered as an editable property.");
619 }
620 }
621 }
622
623 @SuppressWarnings("unchecked")
624 public ActionForward performInquiry(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
625
626 String fullParameter = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
627 validateLookupInquiryFullParameter(request, form, fullParameter);
628
629
630
631 KualiForm kualiForm = (KualiForm) form;
632 kualiForm.registerEditableProperty(KRADConstants.DISPATCH_REQUEST_PARAMETER);
633
634
635 String boClassName = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_BOPARM_LEFT_DEL, KRADConstants.METHOD_TO_CALL_BOPARM_RIGHT_DEL);
636 if (StringUtils.isBlank(boClassName)) {
637 throw new RuntimeException("Illegal call to perform inquiry, no business object class name specified.");
638 }
639
640
641 Properties parameters = new Properties();
642 parameters.put(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, boClassName);
643
644 parameters.put(KRADConstants.RETURN_LOCATION_PARAMETER, getReturnLocation(request, mapping));
645
646
647 String parameterFields = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM2_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
648 if ( LOG.isDebugEnabled() ) {
649 LOG.debug( "fullParameter: " + fullParameter );
650 LOG.debug( "parameterFields: " + parameterFields );
651 }
652 if (StringUtils.isNotBlank(parameterFields)) {
653
654 String[] inquiryParams = parameterFields.split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR);
655 if ( LOG.isDebugEnabled() ) {
656 LOG.debug( "inquiryParams: " + inquiryParams );
657 }
658 Class<? extends BusinessObject> boClass = (Class<? extends BusinessObject>) Class.forName(boClassName);
659 for (String inquiryParam : inquiryParams) {
660 String[] keyValue = inquiryParam.split(KRADConstants.FIELD_CONVERSION_PAIR_SEPARATOR, 2);
661
662 String inquiryParameterValue = retrieveLookupParameterValue(boClass, keyValue[1], keyValue[0], form, request);
663 if (inquiryParameterValue == null) {
664 parameters.put(keyValue[1], "directInquiryKeyNotSpecified");
665 }
666 else {
667 parameters.put(keyValue[1], inquiryParameterValue);
668 }
669
670 if ( LOG.isDebugEnabled() ) {
671 LOG.debug( "keyValue[0]: " + keyValue[0] );
672 LOG.debug( "keyValue[1]: " + keyValue[1] );
673 }
674 }
675 }
676 parameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, "start");
677 parameters.put(KRADConstants.DOC_FORM_KEY, GlobalVariables.getUserSession().addObjectWithGeneratedKey(form));
678 String inquiryUrl = null;
679 try {
680 Class.forName(boClassName);
681 inquiryUrl = getApplicationBaseUrl() + "/kr/" + KRADConstants.DIRECT_INQUIRY_ACTION;
682 } catch ( ClassNotFoundException ex ) {
683
684 LOG.warn("Class name does not represent a valid class which this application understands: " + boClassName);
685 }
686 inquiryUrl = UrlFactory.parameterizeUrl(inquiryUrl, parameters);
687 return new ActionForward(inquiryUrl, true);
688
689 }
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706 protected ActionForward performQuestionWithoutInput(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String questionId, String questionText, String questionType, String caller, String context) throws Exception {
707 return performQuestion(mapping, form, request, response, questionId, questionText, questionType, caller, context, false, "", "", "", "");
708 }
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725 protected ActionForward performQuestionWithInput(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String questionId, String questionText, String questionType, String caller, String context) throws Exception {
726 return performQuestion(mapping, form, request, response, questionId, questionText, questionType, caller, context, true, "", "", "", "");
727 }
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748 protected ActionForward performQuestionWithInputAgainBecauseOfErrors(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String questionId, String questionText, String questionType, String caller, String context, String reason, String errorKey, String errorPropertyName, String errorParameter) throws Exception {
749 return performQuestion(mapping, form, request, response, questionId, questionText, questionType, caller, context, true, reason, errorKey, errorPropertyName, errorParameter);
750 }
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772 private ActionForward performQuestion(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response, String questionId, String questionText, String questionType, String caller, String context, boolean showReasonField, String reason, String errorKey, String errorPropertyName, String errorParameter) throws Exception {
773 Properties parameters = new Properties();
774
775 parameters.put(KRADConstants.DISPATCH_REQUEST_PARAMETER, "start");
776 parameters.put(KRADConstants.DOC_FORM_KEY, GlobalVariables.getUserSession().addObjectWithGeneratedKey(form));
777 parameters.put(KRADConstants.CALLING_METHOD, caller);
778 parameters.put(KRADConstants.QUESTION_INST_ATTRIBUTE_NAME, questionId);
779 parameters.put(KRADConstants.QUESTION_IMPL_ATTRIBUTE_NAME, questionType);
780 parameters.put(KRADConstants.QUESTION_TEXT_ATTRIBUTE_NAME, questionText);
781 parameters.put(KRADConstants.RETURN_LOCATION_PARAMETER, getReturnLocation(request, mapping));
782 parameters.put(KRADConstants.QUESTION_CONTEXT, context);
783 parameters.put(KRADConstants.QUESTION_SHOW_REASON_FIELD, Boolean.toString(showReasonField));
784 parameters.put(KRADConstants.QUESTION_REASON_ATTRIBUTE_NAME, reason);
785 parameters.put(KRADConstants.QUESTION_ERROR_KEY, errorKey);
786 parameters.put(KRADConstants.QUESTION_ERROR_PROPERTY_NAME, errorPropertyName);
787 parameters.put(KRADConstants.QUESTION_ERROR_PARAMETER, errorParameter);
788 parameters.put(KRADConstants.QUESTION_ANCHOR, form instanceof KualiForm ? ObjectUtils.toString(((KualiForm) form).getAnchor()) : "");
789 Object methodToCallAttribute = request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
790 if (methodToCallAttribute != null) {
791 parameters.put(KRADConstants.METHOD_TO_CALL_PATH, methodToCallAttribute);
792 ((PojoForm) form).registerEditableProperty(String.valueOf(methodToCallAttribute));
793 }
794
795 if (form instanceof KualiDocumentFormBase) {
796 String docNum = ((KualiDocumentFormBase) form).getDocument().getDocumentNumber();
797 if(docNum != null){
798 parameters.put(KRADConstants.DOC_NUM, ((KualiDocumentFormBase) form)
799 .getDocument().getDocumentNumber());
800 }
801 }
802
803 String questionUrl = UrlFactory.parameterizeUrl(getApplicationBaseUrl() + "/kr/" + KRADConstants.QUESTION_ACTION, parameters);
804 return new ActionForward(questionUrl, true);
805 }
806
807
808
809
810
811
812
813
814
815
816
817
818 public ActionForward performWorkgroupLookup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
819 String returnUrl = null;
820 if ("/kr".equals(mapping.getModuleConfig().getPrefix())) {
821 returnUrl = getApplicationBaseUrl() + mapping.getModuleConfig().getPrefix() + mapping.getPath() + ".do";
822 } else {
823 returnUrl = getApplicationBaseUrl() + mapping.getPath() + ".do";
824 }
825
826
827 String fullParameter = (String) request.getAttribute(KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
828 String conversionFields = StringUtils.substringBetween(fullParameter, KRADConstants.METHOD_TO_CALL_PARM1_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM1_RIGHT_DEL);
829
830 String deploymentBaseUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(
831 KRADConstants.WORKFLOW_URL_KEY);
832 String workgroupLookupUrl = deploymentBaseUrl + "/Lookup.do?lookupableImplServiceName=WorkGroupLookupableImplService&methodToCall=start&docFormKey=" + GlobalVariables.getUserSession().addObjectWithGeneratedKey(form);
833
834 if (conversionFields != null) {
835 workgroupLookupUrl += "&conversionFields=" + conversionFields;
836 }
837 if (form instanceof KualiDocumentFormBase) {
838 workgroupLookupUrl +="&docNum="+ ((KualiDocumentFormBase) form).getDocument().getDocumentNumber();
839 }
840
841 workgroupLookupUrl += "&returnLocation=" + returnUrl;
842
843 return new ActionForward(workgroupLookupUrl, true);
844 }
845
846
847
848
849
850
851
852
853
854
855
856 public ActionForward headerTab(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
857
858
859 String headerTabDispatch = getHeaderTabDispatch(request);
860 if (StringUtils.isNotEmpty(headerTabDispatch)) {
861 ActionForward forward = dispatchMethod(mapping, form, request, response, headerTabDispatch);
862 if (GlobalVariables.getMessageMap().getNumberOfPropertiesWithErrors() > 0) {
863 return mapping.findForward(RiceConstants.MAPPING_BASIC);
864 }
865 this.doTabOpenOrClose(mapping, form, request, response, false);
866 if (forward.getRedirect()) {
867 return forward;
868 }
869 }
870 return dispatchMethod(mapping, form, request, response, getHeaderTabNavigateTo(request));
871 }
872
873
874
875
876
877
878
879 protected void checkAuthorization( ActionForm form, String methodToCall) throws AuthorizationException
880 {
881 String principalId = GlobalVariables.getUserSession().getPrincipalId();
882 Map<String, String> roleQualifier = new HashMap<String, String>(getRoleQualification(form, methodToCall));
883 Map<String, String> permissionDetails = KRADUtils.getNamespaceAndActionClass(this.getClass());
884
885 if (!KimApiServiceLocator.getPermissionService().isAuthorizedByTemplate(principalId,
886 KRADConstants.KNS_NAMESPACE, KimConstants.PermissionTemplateNames.USE_SCREEN, permissionDetails,
887 roleQualifier))
888 {
889 throw new AuthorizationException(GlobalVariables.getUserSession().getPerson().getPrincipalName(),
890 methodToCall,
891 this.getClass().getSimpleName());
892 }
893 }
894
895
896
897
898 protected Map<String,String> getRoleQualification(ActionForm form, String methodToCall) {
899 return new HashMap<String,String>();
900 }
901
902 protected static KualiModuleService getKualiModuleService() {
903 if ( kualiModuleService == null ) {
904 kualiModuleService = KRADServiceLocatorWeb.getKualiModuleService();
905 }
906 return kualiModuleService;
907 }
908
909
910
911
912
913 public static final String TEXT_AREA_FIELD_NAME="textAreaFieldName";
914
915
916
917
918 public static final String TEXT_AREA_FIELD_LABEL="textAreaFieldLabel";
919
920
921
922
923 public static final String TEXT_AREA_READ_ONLY="textAreaReadOnly";
924
925
926
927
928 public static final String TEXT_AREA_FIELD_ANCHOR="textAreaFieldAnchor";
929
930
931
932
933 public static final String TEXT_AREA_MAX_LENGTH="textAreaMaxLength";
934
935
936
937
938 public static final String FORM_ACTION="htmlFormAction";
939
940
941
942
943 public static final String METHOD_TO_CALL="methodToCall";
944
945
946
947
948
949 public static final String FORWARD_TEXT_AREA_UPDATE="updateTextArea";
950
951
952
953
954 public static final String POST_TEXT_AREA_TO_PARENT="postTextAreaToParent";
955
956
957
958
959
960 public static final String FORWARD_NEXT="forwardNext";
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975 public ActionForward updateTextArea(ActionMapping mapping,
976 ActionForm form,
977 HttpServletRequest request,
978 HttpServletResponse response) {
979 if (LOG.isTraceEnabled()) {
980 String lm=String.format("ENTRY %s%n%s", form.getClass().getSimpleName(),
981 request.getRequestURI());
982 LOG.trace(lm);
983 }
984
985 final String[] keyValue = getTextAreaParams(request);
986
987 request.setAttribute(TEXT_AREA_FIELD_NAME, keyValue[0]);
988 request.setAttribute(FORM_ACTION,keyValue[1]);
989 request.setAttribute(TEXT_AREA_FIELD_LABEL,keyValue[2]);
990 request.setAttribute(TEXT_AREA_READ_ONLY,keyValue[3]);
991 request.setAttribute(TEXT_AREA_MAX_LENGTH,keyValue[4]);
992 if (form instanceof KualiForm && StringUtils.isNotEmpty(((KualiForm) form).getAnchor())) {
993 request.setAttribute(TEXT_AREA_FIELD_ANCHOR,((KualiForm) form).getAnchor());
994 }
995
996
997 String docWebScope=(String)request.getAttribute(KRADConstants.DOCUMENT_WEB_SCOPE);
998 if (docWebScope != null && docWebScope.trim().length() >= 0) {
999 request.setAttribute(KRADConstants.DOCUMENT_WEB_SCOPE, docWebScope);
1000 }
1001
1002 request.setAttribute(KRADConstants.DOC_FORM_KEY, GlobalVariables.getUserSession().addObjectWithGeneratedKey(form));
1003
1004 ActionForward forward=mapping.findForward(FORWARD_TEXT_AREA_UPDATE);
1005
1006 if (LOG.isTraceEnabled()) {
1007 String lm=String.format("EXIT %s", (forward==null)?"null":forward.getPath());
1008 LOG.trace(lm);
1009 }
1010
1011 return forward;
1012 }
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029 private String[] getTextAreaParams(HttpServletRequest request) {
1030
1031 String fullParameter = (String) request.getAttribute(
1032 KRADConstants.METHOD_TO_CALL_ATTRIBUTE);
1033
1034
1035 String parameterFields = StringUtils.substringBetween(fullParameter,
1036 KRADConstants.METHOD_TO_CALL_PARM2_LEFT_DEL,
1037 KRADConstants.METHOD_TO_CALL_PARM2_RIGHT_DEL);
1038 if ( LOG.isDebugEnabled() ) {
1039 LOG.debug( "fullParameter: " + fullParameter );
1040 LOG.debug( "parameterFields: " + parameterFields );
1041 }
1042 String[] keyValue = null;
1043 if (StringUtils.isNotBlank(parameterFields)) {
1044 String[] textAreaParams = parameterFields.split(
1045 KRADConstants.FIELD_CONVERSIONS_SEPARATOR);
1046 if ( LOG.isDebugEnabled() ) {
1047 LOG.debug( "lookupParams: " + textAreaParams );
1048 }
1049 for (final String textAreaParam : textAreaParams) {
1050 keyValue = textAreaParam.split(KRADConstants.FIELD_CONVERSION_PAIR_SEPARATOR, 2);
1051
1052 if ( LOG.isDebugEnabled() ) {
1053 LOG.debug( "keyValue[0]: " + keyValue[0] );
1054 LOG.debug( "keyValue[1]: " + keyValue[1] );
1055 LOG.debug( "keyValue[2]: " + keyValue[2] );
1056 LOG.debug( "keyValue[3]: " + keyValue[3] );
1057 LOG.debug( "keyValue[4]: " + keyValue[4] );
1058 }
1059 }
1060 }
1061
1062 return keyValue;
1063 }
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077 public ActionForward postTextAreaToParent(ActionMapping mapping,
1078 ActionForm form,
1079 HttpServletRequest request,
1080 HttpServletResponse response) {
1081
1082 if (LOG.isTraceEnabled()) {
1083 String lm=String.format("ENTRY %s%n%s", form.getClass().getSimpleName(),
1084 request.getRequestURI());
1085 LOG.trace(lm);
1086 }
1087
1088 String forwardingId=request.getParameter(FORWARD_NEXT);
1089 if (forwardingId == null) {
1090 forwardingId=RiceConstants.MAPPING_BASIC;
1091 }
1092 ActionForward forward=mapping.findForward(forwardingId);
1093
1094 if (LOG.isTraceEnabled()) {
1095 String lm=String.format("EXIT %s", (forward==null)?"null":forward.getPath());
1096 LOG.trace(lm);
1097 }
1098
1099 return forward;
1100 }
1101
1102
1103
1104
1105
1106
1107 protected final void addMethodToCallToUncheckedList( String methodToCall ) {
1108 methodToCallsToNotCheckAuthorization.add(methodToCall);
1109 }
1110
1111
1112
1113
1114 protected void doProcessingAfterPost( KualiForm form, HttpServletRequest request ) {
1115
1116 }
1117
1118 protected BusinessObjectAuthorizationService getBusinessObjectAuthorizationService() {
1119 if (businessObjectAuthorizationService == null) {
1120 businessObjectAuthorizationService = KNSServiceLocator.getBusinessObjectAuthorizationService();
1121 }
1122 return businessObjectAuthorizationService;
1123 }
1124
1125 protected EncryptionService getEncryptionService() {
1126 if (encryptionService == null) {
1127 encryptionService = CoreApiServiceLocator.getEncryptionService();
1128 }
1129 return encryptionService;
1130 }
1131
1132 public static String getApplicationBaseUrl() {
1133 if ( applicationBaseUrl == null ) {
1134 applicationBaseUrl = KRADServiceLocator.getKualiConfigurationService().getPropertyValueAsString(
1135 KRADConstants.APPLICATION_URL_KEY);
1136 }
1137 return applicationBaseUrl;
1138 }
1139
1140 protected boolean isModuleLocked(ActionForm form, String methodToCall, HttpServletRequest request) {
1141 String boClass = request.getParameter(KRADConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE);
1142 ModuleService moduleService = null;
1143 if(StringUtils.isNotBlank(boClass)) {
1144 try {
1145 moduleService = getKualiModuleService().getResponsibleModuleService(Class.forName(boClass));
1146 } catch (ClassNotFoundException classNotFoundException) {
1147 LOG.warn("BO class not found: " + boClass, classNotFoundException);
1148 }
1149 } else {
1150 moduleService = getKualiModuleService().getResponsibleModuleService(this.getClass());
1151 }
1152 if(moduleService != null && moduleService.isLocked()) {
1153 String principalId = GlobalVariables.getUserSession().getPrincipalId();
1154 String namespaceCode = KRADConstants.KUALI_RICE_SYSTEM_NAMESPACE;
1155 String permissionName = KimConstants.PermissionNames.ACCESS_LOCKED_MODULE;
1156 Map<String, String> qualification = getRoleQualification(form, methodToCall);
1157 if(!KimApiServiceLocator.getPermissionService().isAuthorized(principalId, namespaceCode, permissionName, qualification)) {
1158 ParameterService parameterSerivce = CoreFrameworkServiceLocator.getParameterService();
1159 String messageParamNamespaceCode = moduleService.getModuleConfiguration().getNamespaceCode();
1160 String messageParamComponentCode = KRADConstants.DetailTypes.ALL_DETAIL_TYPE;
1161 String messageParamName = KRADConstants.SystemGroupParameterNames.OLTP_LOCKOUT_MESSAGE_PARM;
1162 String lockoutMessage = parameterSerivce.getParameterValueAsString(messageParamNamespaceCode, messageParamComponentCode, messageParamName);
1163
1164 if(StringUtils.isBlank(lockoutMessage)) {
1165 String defaultMessageParamName = KRADConstants.SystemGroupParameterNames.OLTP_LOCKOUT_DEFAULT_MESSAGE;
1166 lockoutMessage = parameterSerivce.getParameterValueAsString(KRADConstants.KNS_NAMESPACE, messageParamComponentCode, defaultMessageParamName);
1167 }
1168 request.setAttribute(KRADConstants.MODULE_LOCKED_MESSAGE_REQUEST_PARAMETER, lockoutMessage);
1169 return true;
1170 }
1171 }
1172 return false;
1173 }
1174 }