1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krad.service.impl;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.apache.commons.lang.time.StopWatch;
20 import org.kuali.rice.core.api.CoreApiServiceLocator;
21 import org.kuali.rice.core.api.config.ConfigurationException;
22 import org.kuali.rice.core.api.config.property.ConfigurationService;
23 import org.kuali.rice.core.api.datetime.DateTimeService;
24 import org.kuali.rice.core.api.util.RiceKeyConstants;
25 import org.kuali.rice.core.framework.persistence.jta.TransactionalNoValidationExceptionRollback;
26 import org.kuali.rice.kew.api.WorkflowDocument;
27 import org.kuali.rice.kew.api.exception.WorkflowException;
28 import org.kuali.rice.kim.api.identity.Person;
29 import org.kuali.rice.kim.api.identity.PersonService;
30 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
31 import org.kuali.rice.krad.UserSession;
32 import org.kuali.rice.krad.bo.AdHocRoutePerson;
33 import org.kuali.rice.krad.bo.AdHocRouteRecipient;
34 import org.kuali.rice.krad.bo.AdHocRouteWorkgroup;
35 import org.kuali.rice.krad.bo.BusinessObject;
36 import org.kuali.rice.krad.bo.DocumentHeader;
37 import org.kuali.rice.krad.bo.Note;
38 import org.kuali.rice.krad.bo.PersistableBusinessObject;
39 import org.kuali.rice.krad.dao.DocumentDao;
40 import org.kuali.rice.krad.datadictionary.exception.UnknownDocumentTypeException;
41 import org.kuali.rice.krad.document.Document;
42 import org.kuali.rice.krad.document.DocumentAuthorizer;
43 import org.kuali.rice.krad.document.DocumentPresentationController;
44 import org.kuali.rice.krad.maintenance.MaintenanceDocument;
45 import org.kuali.rice.krad.maintenance.MaintenanceDocumentBase;
46 import org.kuali.rice.krad.exception.DocumentAuthorizationException;
47 import org.kuali.rice.krad.exception.ValidationException;
48 import org.kuali.rice.krad.rules.rule.event.ApproveDocumentEvent;
49 import org.kuali.rice.krad.rules.rule.event.BlanketApproveDocumentEvent;
50 import org.kuali.rice.krad.rules.rule.event.KualiDocumentEvent;
51 import org.kuali.rice.krad.rules.rule.event.RouteDocumentEvent;
52 import org.kuali.rice.krad.rules.rule.event.SaveDocumentEvent;
53 import org.kuali.rice.krad.rules.rule.event.SaveEvent;
54 import org.kuali.rice.krad.service.BusinessObjectService;
55 import org.kuali.rice.krad.service.DataDictionaryService;
56 import org.kuali.rice.krad.service.DocumentDictionaryService;
57 import org.kuali.rice.krad.service.DocumentHeaderService;
58 import org.kuali.rice.krad.service.DocumentService;
59 import org.kuali.rice.krad.service.KRADServiceLocator;
60 import org.kuali.rice.krad.service.KRADServiceLocatorInternal;
61 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
62 import org.kuali.rice.krad.service.NoteService;
63 import org.kuali.rice.krad.util.GlobalVariables;
64 import org.kuali.rice.krad.util.KRADConstants;
65 import org.kuali.rice.krad.util.ObjectUtils;
66 import org.kuali.rice.krad.workflow.service.WorkflowDocumentService;
67 import org.springframework.dao.OptimisticLockingFailureException;
68
69 import java.lang.reflect.Constructor;
70 import java.lang.reflect.InvocationTargetException;
71 import java.text.MessageFormat;
72 import java.util.ArrayList;
73 import java.util.HashMap;
74 import java.util.List;
75 import java.util.Map;
76
77
78
79
80
81
82
83
84
85
86 @TransactionalNoValidationExceptionRollback
87 public class DocumentServiceImpl implements DocumentService {
88 private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(DocumentServiceImpl.class);
89
90 private DocumentDao documentDao;
91
92 private DateTimeService dateTimeService;
93 private NoteService noteService;
94 private WorkflowDocumentService workflowDocumentService;
95 private BusinessObjectService businessObjectService;
96 private DataDictionaryService dataDictionaryService;
97 private DocumentHeaderService documentHeaderService;
98 private DocumentDictionaryService documentDictionaryService;
99 private PersonService personService;
100 private ConfigurationService kualiConfigurationService;
101
102
103
104
105 @Override
106 public Document saveDocument(Document document) throws WorkflowException, ValidationException {
107 return saveDocument(document, SaveDocumentEvent.class);
108 }
109
110 @Override
111 public Document saveDocument(Document document,
112 Class<? extends KualiDocumentEvent> kualiDocumentEventClass) throws WorkflowException, ValidationException {
113 checkForNulls(document);
114 if (kualiDocumentEventClass == null) {
115 throw new IllegalArgumentException("invalid (null) kualiDocumentEventClass");
116 }
117
118 if (!SaveEvent.class.isAssignableFrom(kualiDocumentEventClass)) {
119 throw new ConfigurationException("The KualiDocumentEvent class '" + kualiDocumentEventClass.getName() +
120 "' does not implement the class '" + SaveEvent.class.getName() + "'");
121 }
122
123
124
125 document.prepareForSave();
126 Document savedDocument = validateAndPersistDocumentAndSaveAdHocRoutingRecipients(document,
127 generateKualiDocumentEvent(document, kualiDocumentEventClass));
128 prepareWorkflowDocument(savedDocument);
129 getWorkflowDocumentService().save(savedDocument.getDocumentHeader().getWorkflowDocument(), null);
130
131 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
132 savedDocument.getDocumentHeader().getWorkflowDocument());
133
134 return savedDocument;
135 }
136
137 private KualiDocumentEvent generateKualiDocumentEvent(Document document,
138 Class<? extends KualiDocumentEvent> eventClass) throws ConfigurationException {
139 String potentialErrorMessage =
140 "Found error trying to generate Kuali Document Event using event class '" + eventClass.getName() +
141 "' for document " + document.getDocumentNumber();
142
143 try {
144 Constructor<?> usableConstructor = null;
145 List<Object> paramList = new ArrayList<Object>();
146 for (Constructor<?> currentConstructor : eventClass.getConstructors()) {
147 for (Class<?> parameterClass : currentConstructor.getParameterTypes()) {
148 if (Document.class.isAssignableFrom(parameterClass)) {
149 usableConstructor = currentConstructor;
150 paramList.add(document);
151 } else {
152 paramList.add(null);
153 }
154 }
155 if (ObjectUtils.isNotNull(usableConstructor)) {
156 break;
157 }
158 }
159 if (usableConstructor == null) {
160 throw new RuntimeException("Cannot find a constructor for class '" + eventClass.getName() +
161 "' that takes in a document parameter");
162 }
163 return (KualiDocumentEvent) usableConstructor.newInstance(paramList.toArray());
164 } catch (SecurityException e) {
165 throw new ConfigurationException(potentialErrorMessage, e);
166 } catch (IllegalArgumentException e) {
167 throw new ConfigurationException(potentialErrorMessage, e);
168 } catch (InstantiationException e) {
169 throw new ConfigurationException(potentialErrorMessage, e);
170 } catch (IllegalAccessException e) {
171 throw new ConfigurationException(potentialErrorMessage, e);
172 } catch (InvocationTargetException e) {
173 throw new ConfigurationException(potentialErrorMessage, e);
174 }
175 }
176
177
178
179
180
181 @Override
182 public Document routeDocument(Document document, String annotation,
183 List<AdHocRouteRecipient> adHocRecipients) throws ValidationException, WorkflowException {
184 checkForNulls(document);
185
186
187
188 document.prepareForSave();
189 Document savedDocument = validateAndPersistDocument(document, new RouteDocumentEvent(document));
190 prepareWorkflowDocument(savedDocument);
191 getWorkflowDocumentService()
192 .route(savedDocument.getDocumentHeader().getWorkflowDocument(), annotation, adHocRecipients);
193 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
194 savedDocument.getDocumentHeader().getWorkflowDocument());
195 removeAdHocPersonsAndWorkgroups(savedDocument);
196 return savedDocument;
197 }
198
199
200
201
202
203
204 @Override
205 public Document approveDocument(Document document, String annotation,
206 List<AdHocRouteRecipient> adHocRecipients) throws ValidationException, WorkflowException {
207 checkForNulls(document);
208
209
210
211 document.prepareForSave();
212 Document savedDocument = validateAndPersistDocument(document, new ApproveDocumentEvent(document));
213 prepareWorkflowDocument(savedDocument);
214 getWorkflowDocumentService()
215 .approve(savedDocument.getDocumentHeader().getWorkflowDocument(), annotation, adHocRecipients);
216 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
217 savedDocument.getDocumentHeader().getWorkflowDocument());
218 removeAdHocPersonsAndWorkgroups(savedDocument);
219 return savedDocument;
220 }
221
222
223
224
225
226 @Override
227 public Document superUserApproveDocument(Document document, String annotation) throws WorkflowException {
228 getDocumentDao().save(document);
229 prepareWorkflowDocument(document);
230 getWorkflowDocumentService().superUserApprove(document.getDocumentHeader().getWorkflowDocument(), annotation);
231 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
232 document.getDocumentHeader().getWorkflowDocument());
233 removeAdHocPersonsAndWorkgroups(document);
234 return document;
235 }
236
237
238
239
240
241 @Override
242 public Document superUserCancelDocument(Document document, String annotation) throws WorkflowException {
243 getDocumentDao().save(document);
244 prepareWorkflowDocument(document);
245 getWorkflowDocumentService().superUserCancel(document.getDocumentHeader().getWorkflowDocument(), annotation);
246 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
247 document.getDocumentHeader().getWorkflowDocument());
248 removeAdHocPersonsAndWorkgroups(document);
249 return document;
250 }
251
252
253
254
255
256 @Override
257 public Document superUserDisapproveDocument(Document document, String annotation) throws WorkflowException {
258 getDocumentDao().save(document);
259 prepareWorkflowDocument(document);
260 getWorkflowDocumentService()
261 .superUserDisapprove(document.getDocumentHeader().getWorkflowDocument(), annotation);
262 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
263 document.getDocumentHeader().getWorkflowDocument());
264 removeAdHocPersonsAndWorkgroups(document);
265 return document;
266 }
267
268
269
270
271
272 @Override
273 public Document disapproveDocument(Document document, String annotation) throws Exception {
274 checkForNulls(document);
275
276 Note note = createNoteFromDocument(document, annotation);
277 document.addNote(note);
278
279
280
281
282 getNoteService().save(note);
283
284 prepareWorkflowDocument(document);
285 getWorkflowDocumentService().disapprove(document.getDocumentHeader().getWorkflowDocument(), annotation);
286 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
287 document.getDocumentHeader().getWorkflowDocument());
288 removeAdHocPersonsAndWorkgroups(document);
289 return document;
290 }
291
292
293
294
295
296 @Override
297 public Document cancelDocument(Document document, String annotation) throws WorkflowException {
298 checkForNulls(document);
299
300
301
302 if (document instanceof MaintenanceDocument) {
303 MaintenanceDocument maintDoc = ((MaintenanceDocument) document);
304 if (maintDoc.getOldMaintainableObject() != null &&
305 (maintDoc.getOldMaintainableObject().getDataObject() instanceof BusinessObject)) {
306 ((BusinessObject) maintDoc.getOldMaintainableObject().getDataObject()).refresh();
307 }
308
309 if (maintDoc.getNewMaintainableObject().getDataObject() instanceof BusinessObject) {
310 ((BusinessObject) maintDoc.getNewMaintainableObject().getDataObject()).refresh();
311 }
312 }
313 prepareWorkflowDocument(document);
314 getWorkflowDocumentService().cancel(document.getDocumentHeader().getWorkflowDocument(), annotation);
315 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
316 document.getDocumentHeader().getWorkflowDocument());
317
318
319 removeAdHocPersonsAndWorkgroups(document);
320 return document;
321 }
322
323 @Override
324 public Document recallDocument(Document document, String annotation, boolean cancel) throws WorkflowException {
325 checkForNulls(document);
326
327 Note note = createNoteFromDocument(document, annotation);
328 document.addNote(note);
329 getNoteService().save(note);
330
331 prepareWorkflowDocument(document);
332 getWorkflowDocumentService().recall(document.getDocumentHeader().getWorkflowDocument(), annotation, cancel);
333 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
334 document.getDocumentHeader().getWorkflowDocument());
335 removeAdHocPersonsAndWorkgroups(document);
336 return document;
337 }
338
339
340
341
342
343
344 @Override
345 public Document acknowledgeDocument(Document document, String annotation,
346 List<AdHocRouteRecipient> adHocRecipients) throws WorkflowException {
347 checkForNulls(document);
348
349
350
351 prepareWorkflowDocument(document);
352 getWorkflowDocumentService()
353 .acknowledge(document.getDocumentHeader().getWorkflowDocument(), annotation, adHocRecipients);
354 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
355 document.getDocumentHeader().getWorkflowDocument());
356 removeAdHocPersonsAndWorkgroups(document);
357 return document;
358 }
359
360
361
362
363
364
365 @Override
366 public Document blanketApproveDocument(Document document, String annotation,
367 List<AdHocRouteRecipient> adHocRecipients) throws ValidationException, WorkflowException {
368 checkForNulls(document);
369
370
371
372 document.prepareForSave();
373 Document savedDocument = validateAndPersistDocument(document, new BlanketApproveDocumentEvent(document));
374 prepareWorkflowDocument(savedDocument);
375 getWorkflowDocumentService()
376 .blanketApprove(savedDocument.getDocumentHeader().getWorkflowDocument(), annotation, adHocRecipients);
377 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
378 savedDocument.getDocumentHeader().getWorkflowDocument());
379 removeAdHocPersonsAndWorkgroups(savedDocument);
380 return savedDocument;
381 }
382
383
384
385
386
387 @Override
388 public Document clearDocumentFyi(Document document,
389 List<AdHocRouteRecipient> adHocRecipients) throws WorkflowException {
390 checkForNulls(document);
391
392 document.populateDocumentForRouting();
393 getWorkflowDocumentService().clearFyi(document.getDocumentHeader().getWorkflowDocument(), adHocRecipients);
394 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
395 document.getDocumentHeader().getWorkflowDocument());
396 removeAdHocPersonsAndWorkgroups(document);
397 return document;
398 }
399
400 protected void checkForNulls(Document document) {
401 if (document == null) {
402 throw new IllegalArgumentException("invalid (null) document");
403 }
404 if (document.getDocumentNumber() == null) {
405 throw new IllegalStateException("invalid (null) documentHeaderId");
406 }
407 }
408
409 private Document validateAndPersistDocumentAndSaveAdHocRoutingRecipients(Document document,
410 KualiDocumentEvent event) {
411
412
413
414
415 List<AdHocRouteRecipient> adHocRoutingRecipients = new ArrayList<AdHocRouteRecipient>();
416 adHocRoutingRecipients.addAll(document.getAdHocRoutePersons());
417 adHocRoutingRecipients.addAll(document.getAdHocRouteWorkgroups());
418
419 for (AdHocRouteRecipient recipient : adHocRoutingRecipients) {
420 recipient.setdocumentNumber(document.getDocumentNumber());
421 }
422 Map<String, String> criteria = new HashMap<String, String>();
423 criteria.put("documentNumber", document.getDocumentNumber());
424 getBusinessObjectService().deleteMatching(AdHocRouteRecipient.class, criteria);
425
426 getBusinessObjectService().save(adHocRoutingRecipients);
427 return validateAndPersistDocument(document, event);
428 }
429
430
431
432
433 @Override
434 public boolean documentExists(String documentHeaderId) {
435
436 if (StringUtils.isBlank(documentHeaderId)) {
437 throw new IllegalArgumentException("invalid (blank) documentHeaderId");
438 }
439
440 boolean internalUserSession = false;
441 try {
442
443
444 if (GlobalVariables.getUserSession() == null) {
445 internalUserSession = true;
446 GlobalVariables.setUserSession(new UserSession(KRADConstants.SYSTEM_USER));
447 GlobalVariables.clear();
448 }
449
450
451 if (getWorkflowDocumentService().workflowDocumentExists(documentHeaderId)) {
452
453 return getDocumentHeaderService().getDocumentHeaderById(documentHeaderId) != null;
454 }
455
456 return false;
457 } finally {
458
459 if (internalUserSession) {
460 GlobalVariables.clear();
461 GlobalVariables.setUserSession(null);
462 }
463 }
464 }
465
466
467
468
469
470
471 @Override
472 public Document getNewDocument(Class<? extends Document> documentClass) throws WorkflowException {
473 if (documentClass == null) {
474 throw new IllegalArgumentException("invalid (null) documentClass");
475 }
476 if (!Document.class.isAssignableFrom(documentClass)) {
477 throw new IllegalArgumentException("invalid (non-Document) documentClass");
478 }
479
480 String documentTypeName = getDataDictionaryService().getDocumentTypeNameByClass(documentClass);
481 if (StringUtils.isBlank(documentTypeName)) {
482 throw new UnknownDocumentTypeException(
483 "unable to get documentTypeName for unknown documentClass '" + documentClass.getName() + "'");
484 }
485 return getNewDocument(documentTypeName);
486 }
487
488
489
490
491
492
493 @Override
494 public Document getNewDocument(String documentTypeName) throws WorkflowException {
495
496 String watchName = "DocumentServiceImpl.getNewDocument";
497 StopWatch watch = new StopWatch();
498 watch.start();
499 if (LOG.isDebugEnabled()) {
500 LOG.debug(watchName + ": started");
501 }
502 if (StringUtils.isBlank(documentTypeName)) {
503 throw new IllegalArgumentException("invalid (blank) documentTypeName");
504 }
505 if (GlobalVariables.getUserSession() == null) {
506 throw new IllegalStateException(
507 "GlobalVariables must be populated with a valid UserSession before a new document can be created");
508 }
509
510
511 Class<? extends Document> documentClass = getDocumentClassByTypeName(documentTypeName);
512
513
514 Person currentUser = GlobalVariables.getUserSession().getPerson();
515
516
517 DocumentAuthorizer documentAuthorizer = getDocumentDictionaryService().getDocumentAuthorizer(documentTypeName);
518 DocumentPresentationController documentPresentationController =
519 getDocumentDictionaryService().getDocumentPresentationController(documentTypeName);
520
521 LOG.debug("calling canInitiate from getNewDocument()");
522 if (!documentPresentationController.canInitiate(documentTypeName) ||
523 !documentAuthorizer.canInitiate(documentTypeName, currentUser)) {
524 throw new DocumentAuthorizationException(currentUser.getPrincipalName(), "initiate", documentTypeName);
525 }
526
527
528 WorkflowDocument workflowDocument = getWorkflowDocumentService().createWorkflowDocument(documentTypeName, GlobalVariables.getUserSession().getPerson());
529 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),workflowDocument);
530
531
532 DocumentHeader documentHeader = null;
533 try {
534
535 Class<? extends DocumentHeader> documentHeaderClass =
536 getDocumentHeaderService().getDocumentHeaderBaseClass();
537 documentHeader = documentHeaderClass.newInstance();
538 documentHeader.setWorkflowDocument(workflowDocument);
539 documentHeader.setDocumentNumber(workflowDocument.getDocumentId());
540
541 } catch (IllegalAccessException e) {
542 throw new RuntimeException("Error instantiating DocumentHeader", e);
543 } catch (InstantiationException e) {
544 throw new RuntimeException("Error instantiating DocumentHeader", e);
545 }
546
547
548 Document document = null;
549 try {
550
551 if (MaintenanceDocumentBase.class.isAssignableFrom(documentClass)) {
552 Class<?>[] defaultConstructor = new Class[]{String.class};
553 Constructor<? extends Document> cons = documentClass.getConstructor(defaultConstructor);
554 if (ObjectUtils.isNull(cons)) {
555 throw new ConfigurationException(
556 "Could not find constructor with document type name parameter needed for Maintenance Document Base class");
557 }
558 document = cons.newInstance(documentTypeName);
559 } else {
560
561 document = documentClass.newInstance();
562 }
563 } catch (IllegalAccessException e) {
564 throw new RuntimeException("Error instantiating Document", e);
565 } catch (InstantiationException e) {
566 throw new RuntimeException("Error instantiating Document", e);
567 } catch (SecurityException e) {
568 throw new RuntimeException("Error instantiating Maintenance Document", e);
569 } catch (NoSuchMethodException e) {
570 throw new RuntimeException(
571 "Error instantiating Maintenance Document: No constructor with String parameter found", e);
572 } catch (IllegalArgumentException e) {
573 throw new RuntimeException("Error instantiating Maintenance Document", e);
574 } catch (InvocationTargetException e) {
575 throw new RuntimeException("Error instantiating Maintenance Document", e);
576 }
577
578 document.setDocumentHeader(documentHeader);
579 document.setDocumentNumber(documentHeader.getDocumentNumber());
580
581 watch.stop();
582 if (LOG.isDebugEnabled()) {
583 LOG.debug(watchName + ": " + watch.toString());
584 }
585
586 return document;
587 }
588
589
590
591
592
593
594
595
596
597
598 @Override
599 public Document getByDocumentHeaderId(String documentHeaderId) throws WorkflowException {
600 if (documentHeaderId == null) {
601 throw new IllegalArgumentException("invalid (null) documentHeaderId");
602 }
603 boolean internalUserSession = false;
604 try {
605
606
607 if (GlobalVariables.getUserSession() == null) {
608 internalUserSession = true;
609 GlobalVariables.setUserSession(new UserSession(KRADConstants.SYSTEM_USER));
610 GlobalVariables.clear();
611 }
612
613 WorkflowDocument workflowDocument = null;
614
615 if (LOG.isDebugEnabled()) {
616 LOG.debug("Retrieving doc id: " + documentHeaderId + " from workflow service.");
617 }
618 workflowDocument = getWorkflowDocumentService()
619 .loadWorkflowDocument(documentHeaderId, GlobalVariables.getUserSession().getPerson());
620 KRADServiceLocatorWeb.getSessionDocumentService()
621 .addDocumentToUserSession(GlobalVariables.getUserSession(), workflowDocument);
622
623 Class<? extends Document> documentClass = getDocumentClassByTypeName(workflowDocument.getDocumentTypeName());
624
625
626 Document document = getDocumentDao().findByDocumentHeaderId(documentClass, documentHeaderId);
627
628 return postProcessDocument(documentHeaderId, workflowDocument, document);
629 } finally {
630
631 if (internalUserSession) {
632 GlobalVariables.clear();
633 GlobalVariables.setUserSession(null);
634 }
635 }
636 }
637
638
639
640
641 @Override
642 public Document getByDocumentHeaderIdSessionless(String documentHeaderId) throws WorkflowException {
643 if (documentHeaderId == null) {
644 throw new IllegalArgumentException("invalid (null) documentHeaderId");
645 }
646
647 WorkflowDocument workflowDocument = null;
648
649 if (LOG.isDebugEnabled()) {
650 LOG.debug("Retrieving doc id: " + documentHeaderId + " from workflow service.");
651 }
652
653 Person person = getPersonService().getPersonByPrincipalName(KRADConstants.SYSTEM_USER);
654 workflowDocument = workflowDocumentService.loadWorkflowDocument(documentHeaderId, person);
655
656 Class<? extends Document> documentClass = getDocumentClassByTypeName(workflowDocument.getDocumentTypeName());
657
658
659 Document document = getDocumentDao().findByDocumentHeaderId(documentClass, documentHeaderId);
660
661 return postProcessDocument(documentHeaderId, workflowDocument, document);
662 }
663
664 private Class<? extends Document> getDocumentClassByTypeName(String documentTypeName) {
665 if (StringUtils.isBlank(documentTypeName)) {
666 throw new IllegalArgumentException("invalid (blank) documentTypeName");
667 }
668
669 Class<? extends Document> clazz = getDataDictionaryService().getDocumentClassByTypeName(documentTypeName);
670 if (clazz == null) {
671 throw new UnknownDocumentTypeException(
672 "unable to get class for unknown documentTypeName '" + documentTypeName + "'");
673 }
674 return clazz;
675 }
676
677
678
679
680
681
682 protected void loadNotes(Document document) {
683 if (isNoteTargetReady(document)) {
684 List<Note> notes = getNoteService().getByRemoteObjectId(document.getNoteTarget().getObjectId());
685
686
687 for (Note note : notes) {
688 note.refreshReferenceObject("attachment");
689 }
690 document.setNotes(notes);
691 }
692 }
693
694
695
696
697
698
699
700
701 private Document postProcessDocument(String documentHeaderId, WorkflowDocument workflowDocument, Document document) {
702 if (document != null) {
703 document.getDocumentHeader().setWorkflowDocument(workflowDocument);
704 document.processAfterRetrieve();
705 loadNotes(document);
706 }
707 return document;
708 }
709
710
711
712
713
714
715
716 @Override
717 public List<Document> getDocumentsByListOfDocumentHeaderIds(Class<? extends Document> documentClass,
718 List<String> documentHeaderIds) throws WorkflowException {
719
720 if (documentHeaderIds == null) {
721 throw new IllegalArgumentException("invalid (null) documentHeaderId list");
722 }
723 int index = 0;
724 for (String documentHeaderId : documentHeaderIds) {
725 if (StringUtils.isBlank(documentHeaderId)) {
726 throw new IllegalArgumentException("invalid (blank) documentHeaderId at list index " + index);
727 }
728 index++;
729 }
730
731 boolean internalUserSession = false;
732 try {
733
734
735 if (GlobalVariables.getUserSession() == null) {
736 internalUserSession = true;
737 GlobalVariables.setUserSession(new UserSession(KRADConstants.SYSTEM_USER));
738 GlobalVariables.clear();
739 }
740
741
742 List<? extends Document> rawDocuments =
743 getDocumentDao().findByDocumentHeaderIds(documentClass, documentHeaderIds);
744
745
746 List<Document> documents = new ArrayList<Document>();
747 for (Document document : rawDocuments) {
748 WorkflowDocument workflowDocument = getWorkflowDocumentService().loadWorkflowDocument(document.getDocumentNumber(), GlobalVariables.getUserSession().getPerson());
749
750 document = postProcessDocument(document.getDocumentNumber(), workflowDocument, document);
751 documents.add(document);
752 }
753 return documents;
754 } finally {
755
756 if (internalUserSession) {
757 GlobalVariables.clear();
758 GlobalVariables.setUserSession(null);
759 }
760 }
761 }
762
763
764
765
766
767
768 public Document validateAndPersistDocument(Document document, KualiDocumentEvent event) throws ValidationException {
769 if (document == null) {
770 LOG.error("document passed to validateAndPersist was null");
771 throw new IllegalArgumentException("invalid (null) document");
772 }
773 if (LOG.isDebugEnabled()) {
774 LOG.debug("validating and preparing to persist document " + document.getDocumentNumber());
775 }
776
777 document.validateBusinessRules(event);
778 document.prepareForSave(event);
779
780
781 Document savedDocument = null;
782 try {
783 if (LOG.isInfoEnabled()) {
784 LOG.info("storing document " + document.getDocumentNumber());
785 }
786 savedDocument = getDocumentDao().save(document);
787 } catch (OptimisticLockingFailureException e) {
788 LOG.error("exception encountered on store of document " + e.getMessage());
789 throw e;
790 }
791
792 boolean notesSaved = saveDocumentNotes(document);
793 if (!notesSaved) {
794 if (LOG.isInfoEnabled()) {
795 LOG.info(
796 "Notes not saved during validateAndPersistDocument, likely means that note save needs to be deferred because note target is not ready.");
797 }
798 }
799
800 savedDocument.postProcessSave(event);
801
802 return savedDocument;
803 }
804
805
806
807
808
809
810
811 @Override
812 public void prepareWorkflowDocument(Document document) throws WorkflowException {
813
814 document.populateDocumentForRouting();
815
816
817 populateDocumentTitle(document);
818
819
820 populateApplicationDocumentId(document);
821 }
822
823
824
825
826
827
828
829
830
831 private void populateDocumentTitle(Document document) throws WorkflowException {
832 String documentTitle = document.getDocumentTitle();
833 if (StringUtils.isNotBlank(documentTitle)) {
834 document.getDocumentHeader().getWorkflowDocument().setTitle(documentTitle);
835 }
836 }
837
838
839
840
841
842
843
844
845 private void populateApplicationDocumentId(Document document) {
846 String organizationDocumentNumber = document.getDocumentHeader().getOrganizationDocumentNumber();
847 if (StringUtils.isNotBlank(organizationDocumentNumber)) {
848 document.getDocumentHeader().getWorkflowDocument().setApplicationDocumentId(organizationDocumentNumber);
849 }
850 }
851
852
853
854
855
856
857 @Override
858 public Document updateDocument(Document document) {
859 checkForNulls(document);
860 return getDocumentDao().save(document);
861 }
862
863
864
865
866
867 @Override
868 public Note createNoteFromDocument(Document document, String text) {
869 Note note = new Note();
870
871 note.setNotePostedTimestamp(getDateTimeService().getCurrentTimestamp());
872 note.setVersionNumber(Long.valueOf(1));
873 note.setNoteText(text);
874 note.setNoteTypeCode(document.getNoteType().getCode());
875
876 PersistableBusinessObject bo = document.getNoteTarget();
877
878 Person kualiUser = GlobalVariables.getUserSession().getPerson();
879 if (kualiUser == null) {
880 throw new IllegalStateException("Current UserSession has a null Person.");
881 }
882 return bo == null ? null : getNoteService().createNote(note, bo, kualiUser.getPrincipalId());
883 }
884
885
886
887
888 @Override
889 public boolean saveDocumentNotes(Document document) {
890 if (isNoteTargetReady(document)) {
891 List<Note> notes = document.getNotes();
892 for (Note note : document.getNotes()) {
893 linkNoteRemoteObjectId(note, document.getNoteTarget());
894 }
895 getNoteService().saveNoteList(notes);
896 return true;
897 }
898 return false;
899 }
900
901
902
903
904 @Override
905 public void sendNoteRouteNotification(Document document, Note note, Person sender) throws WorkflowException {
906 AdHocRouteRecipient routeRecipient = note.getAdHocRouteRecipient();
907
908
909 Person requestedUser = this.getPersonService().getPersonByPrincipalName(routeRecipient.getId());
910 String senderName = sender.getFirstName() + " " + sender.getLastName();
911 String requestedName = requestedUser.getFirstName() + " " + requestedUser.getLastName();
912
913 String notificationText =
914 kualiConfigurationService.getPropertyValueAsString(
915 RiceKeyConstants.MESSAGE_NOTE_NOTIFICATION_ANNOTATION);
916 if (StringUtils.isBlank(notificationText)) {
917 throw new RuntimeException(
918 "No annotation message found for note notification. Message needs added to application resources with key:" +
919 RiceKeyConstants.MESSAGE_NOTE_NOTIFICATION_ANNOTATION);
920 }
921 notificationText =
922 MessageFormat.format(notificationText, new Object[]{senderName, requestedName, note.getNoteText()});
923
924 List<AdHocRouteRecipient> routeRecipients = new ArrayList<AdHocRouteRecipient>();
925 routeRecipients.add(routeRecipient);
926
927 workflowDocumentService
928 .sendWorkflowNotification(document.getDocumentHeader().getWorkflowDocument(), notificationText,
929 routeRecipients, KRADConstants.NOTE_WORKFLOW_NOTIFICATION_REQUEST_LABEL);
930
931
932 note.setAdHocRouteRecipient(new AdHocRoutePerson());
933 }
934
935
936
937
938
939
940
941
942
943 protected boolean isNoteTargetReady(Document document) {
944 PersistableBusinessObject noteTarget = document.getNoteTarget();
945 if (noteTarget == null || StringUtils.isBlank(noteTarget.getObjectId())) {
946 return false;
947 }
948 return true;
949 }
950
951 private void linkNoteRemoteObjectId(Note note, PersistableBusinessObject noteTarget) {
952 String objectId = noteTarget.getObjectId();
953 if (StringUtils.isBlank(objectId)) {
954 throw new IllegalStateException(
955 "Attempted to link a Note with a PersistableBusinessObject with no object id");
956 }
957 note.setRemoteObjectIdentifier(noteTarget.getObjectId());
958 }
959
960
961
962
963 @Override
964 public void sendAdHocRequests(Document document, String annotation,
965 List<AdHocRouteRecipient> adHocRecipients) throws WorkflowException {
966 prepareWorkflowDocument(document);
967 getWorkflowDocumentService()
968 .sendWorkflowNotification(document.getDocumentHeader().getWorkflowDocument(), annotation,
969 adHocRecipients);
970 KRADServiceLocatorWeb.getSessionDocumentService().addDocumentToUserSession(GlobalVariables.getUserSession(),
971 document.getDocumentHeader().getWorkflowDocument());
972
973
974 removeAdHocPersonsAndWorkgroups(document);
975 }
976
977 private void removeAdHocPersonsAndWorkgroups(Document document) {
978 List<AdHocRoutePerson> adHocRoutePersons = new ArrayList<AdHocRoutePerson>();
979 List<AdHocRouteWorkgroup> adHocRouteWorkgroups = new ArrayList<AdHocRouteWorkgroup>();
980 getBusinessObjectService().delete(document.getAdHocRoutePersons());
981 getBusinessObjectService().delete(document.getAdHocRouteWorkgroups());
982 document.setAdHocRoutePersons(adHocRoutePersons);
983 document.setAdHocRouteWorkgroups(adHocRouteWorkgroups);
984 }
985
986 public void setDateTimeService(DateTimeService dateTimeService) {
987 this.dateTimeService = dateTimeService;
988 }
989
990 protected DateTimeService getDateTimeService() {
991 if (this.dateTimeService == null) {
992 this.dateTimeService = CoreApiServiceLocator.getDateTimeService();
993 }
994 return this.dateTimeService;
995 }
996
997 public void setNoteService(NoteService noteService) {
998 this.noteService = noteService;
999 }
1000
1001 protected NoteService getNoteService() {
1002 if (this.noteService == null) {
1003 this.noteService = KRADServiceLocator.getNoteService();
1004 }
1005 return this.noteService;
1006 }
1007
1008 public void setBusinessObjectService(BusinessObjectService businessObjectService) {
1009 this.businessObjectService = businessObjectService;
1010 }
1011
1012 protected BusinessObjectService getBusinessObjectService() {
1013 if (this.businessObjectService == null) {
1014 this.businessObjectService = KRADServiceLocator.getBusinessObjectService();
1015 }
1016 return this.businessObjectService;
1017 }
1018
1019 public void setWorkflowDocumentService(WorkflowDocumentService workflowDocumentService) {
1020 this.workflowDocumentService = workflowDocumentService;
1021 }
1022
1023 protected WorkflowDocumentService getWorkflowDocumentService() {
1024 if (this.workflowDocumentService == null) {
1025 this.workflowDocumentService = KRADServiceLocatorWeb.getWorkflowDocumentService();
1026 }
1027 return this.workflowDocumentService;
1028 }
1029
1030 public void setDocumentDao(DocumentDao documentDao) {
1031 this.documentDao = documentDao;
1032 }
1033
1034 protected DocumentDao getDocumentDao() {
1035 if (this.documentDao == null) {
1036 this.documentDao = KRADServiceLocatorInternal.getDocumentDao();
1037 }
1038 return documentDao;
1039 }
1040
1041 public void setDataDictionaryService(DataDictionaryService dataDictionaryService) {
1042 this.dataDictionaryService = dataDictionaryService;
1043 }
1044
1045 protected DataDictionaryService getDataDictionaryService() {
1046 if (this.dataDictionaryService == null) {
1047 this.dataDictionaryService = KRADServiceLocatorWeb.getDataDictionaryService();
1048 }
1049 return this.dataDictionaryService;
1050 }
1051
1052 public void setDocumentHeaderService(DocumentHeaderService documentHeaderService) {
1053 this.documentHeaderService = documentHeaderService;
1054 }
1055
1056 protected DocumentHeaderService getDocumentHeaderService() {
1057 if (this.documentHeaderService == null) {
1058 this.documentHeaderService = KRADServiceLocatorWeb.getDocumentHeaderService();
1059 }
1060 return this.documentHeaderService;
1061 }
1062
1063 protected DocumentDictionaryService getDocumentDictionaryService() {
1064 if (documentDictionaryService == null) {
1065 documentDictionaryService = KRADServiceLocatorWeb.getDocumentDictionaryService();
1066 }
1067 return documentDictionaryService;
1068 }
1069
1070 public void setDocumentDictionaryService(DocumentDictionaryService documentDictionaryService) {
1071 this.documentDictionaryService = documentDictionaryService;
1072 }
1073
1074 public PersonService getPersonService() {
1075 if (personService == null) {
1076 personService = KimApiServiceLocator.getPersonService();
1077 }
1078 return personService;
1079 }
1080
1081 public void setKualiConfigurationService(ConfigurationService kualiConfigurationService) {
1082 this.kualiConfigurationService = kualiConfigurationService;
1083 }
1084
1085 protected ConfigurationService getKualiConfigurationService() {
1086 return kualiConfigurationService;
1087 }
1088 }