1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krad.document;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.apache.log4j.Logger;
20 import org.kuali.rice.kew.api.KewApiConstants;
21 import org.kuali.rice.kew.api.KewApiServiceLocator;
22 import org.kuali.rice.kew.api.action.ActionType;
23 import org.kuali.rice.kew.api.exception.WorkflowException;
24 import org.kuali.rice.kew.framework.postprocessor.ActionTakenEvent;
25 import org.kuali.rice.kew.framework.postprocessor.DocumentRouteLevelChange;
26 import org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange;
27 import org.kuali.rice.kim.api.identity.Person;
28 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
29 import org.kuali.rice.krad.bo.AdHocRoutePerson;
30 import org.kuali.rice.krad.bo.AdHocRouteWorkgroup;
31 import org.kuali.rice.krad.bo.DocumentHeader;
32 import org.kuali.rice.krad.bo.Note;
33 import org.kuali.rice.krad.bo.PersistableBusinessObject;
34 import org.kuali.rice.krad.bo.PersistableBusinessObjectBase;
35 import org.kuali.rice.krad.datadictionary.DocumentEntry;
36 import org.kuali.rice.krad.datadictionary.WorkflowAttributes;
37 import org.kuali.rice.krad.datadictionary.WorkflowProperties;
38 import org.kuali.rice.krad.document.authorization.PessimisticLock;
39 import org.kuali.rice.krad.exception.PessimisticLockingException;
40 import org.kuali.rice.krad.exception.ValidationException;
41 import org.kuali.rice.krad.rules.rule.event.KualiDocumentEvent;
42 import org.kuali.rice.krad.service.AttachmentService;
43 import org.kuali.rice.krad.service.DocumentSerializerService;
44 import org.kuali.rice.krad.service.KRADServiceLocator;
45 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
46 import org.kuali.rice.krad.service.NoteService;
47 import org.kuali.rice.krad.util.ErrorMessage;
48 import org.kuali.rice.krad.util.GlobalVariables;
49 import org.kuali.rice.krad.util.KRADConstants;
50 import org.kuali.rice.krad.util.KRADPropertyConstants;
51 import org.kuali.rice.krad.util.NoteType;
52 import org.kuali.rice.krad.util.ObjectUtils;
53 import org.kuali.rice.krad.util.documentserializer.AlwaysFalsePropertySerializabilityEvaluator;
54 import org.kuali.rice.krad.util.documentserializer.AlwaysTruePropertySerializibilityEvaluator;
55 import org.kuali.rice.krad.util.documentserializer.BusinessObjectPropertySerializibilityEvaluator;
56 import org.kuali.rice.krad.util.documentserializer.PropertySerializabilityEvaluator;
57 import org.kuali.rice.krad.workflow.DocumentInitiator;
58 import org.kuali.rice.krad.workflow.KualiDocumentXmlMaterializer;
59 import org.kuali.rice.krad.workflow.KualiTransactionalDocumentInformation;
60 import org.springframework.util.AutoPopulatingList;
61 import org.springframework.util.CollectionUtils;
62
63 import javax.persistence.CascadeType;
64 import javax.persistence.Column;
65 import javax.persistence.FetchType;
66 import javax.persistence.Id;
67 import javax.persistence.JoinColumn;
68 import javax.persistence.MappedSuperclass;
69 import javax.persistence.OneToMany;
70 import javax.persistence.OneToOne;
71 import javax.persistence.Transient;
72 import java.util.ArrayList;
73 import java.util.Iterator;
74 import java.util.List;
75 import java.util.Map;
76
77
78
79
80 @MappedSuperclass
81 public abstract class DocumentBase extends PersistableBusinessObjectBase implements Document {
82 private static final Logger LOG = Logger.getLogger(DocumentBase.class);
83
84 @Id @Column(name = "DOC_HDR_ID")
85 protected String documentNumber;
86 @OneToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinColumn(
87 name = "DOC_HDR_ID", insertable = false, updatable = false)
88 protected DocumentHeader documentHeader;
89
90 @OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinColumn(
91 name = "DOC_HDR_ID", insertable = false, updatable = false)
92 private List<PessimisticLock> pessimisticLocks;
93
94 @Transient
95 private List<AdHocRoutePerson> adHocRoutePersons;
96 @Transient
97 private List<AdHocRouteWorkgroup> adHocRouteWorkgroups;
98 @Transient
99 private List<Note> notes;
100
101 private transient NoteService noteService;
102 private transient AttachmentService attachmentService;
103
104
105
106
107 public DocumentBase() {
108 try {
109
110 Class<? extends DocumentHeader> documentHeaderClass =
111 KRADServiceLocatorWeb.getDocumentHeaderService().getDocumentHeaderBaseClass();
112 setDocumentHeader(documentHeaderClass.newInstance());
113 pessimisticLocks = new ArrayList<PessimisticLock>();
114 adHocRoutePersons = new ArrayList<AdHocRoutePerson>();
115 adHocRouteWorkgroups = new ArrayList<AdHocRouteWorkgroup>();
116 notes = new ArrayList<Note>();
117 } catch (IllegalAccessException e) {
118 throw new RuntimeException("Error instantiating DocumentHeader", e);
119 } catch (InstantiationException e) {
120 throw new RuntimeException("Error instantiating DocumentHeader", e);
121 }
122 }
123
124
125
126
127 public boolean getAllowsCopy() {
128
129 return false;
130 }
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147 public String getDocumentTitle() {
148 String documentTypeLabel = KewApiServiceLocator.getDocumentTypeService().getDocumentTypeByName(
149 this.getDocumentHeader().getWorkflowDocument().getDocumentTypeName()).getLabel();
150 if (null == documentTypeLabel) {
151 documentTypeLabel = "";
152 }
153
154 String description = this.getDocumentHeader().getDocumentDescription();
155 if (null == description) {
156 description = "";
157 }
158
159 return documentTypeLabel + " - " + description;
160 }
161
162
163
164
165
166
167 @Override
168 public void refresh() {
169 KRADServiceLocator.getPersistenceService().retrieveNonKeyFields(this);
170 }
171
172
173
174
175
176
177 public void refreshIfEmpty() {
178 if (null == this.getDocumentHeader()) {
179 this.refresh();
180 } else if (StringUtils.isEmpty(this.getDocumentHeader().getObjectId())) {
181 this.refresh();
182 }
183 }
184
185
186
187
188
189
190 @Override
191 public void refreshReferenceObject(String referenceObjectName) {
192 KRADServiceLocator.getPersistenceService().retrieveReferenceObject(this, referenceObjectName);
193 }
194
195
196
197
198 public void prepareForSave() {
199
200 }
201
202
203
204
205 public void processAfterRetrieve() {
206
207 }
208
209
210
211
212
213
214
215
216 public void doRouteLevelChange(DocumentRouteLevelChange levelChangeEvent) {
217
218 }
219
220
221
222
223 public void doActionTaken(ActionTakenEvent event) {
224 if ((KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getDocumentEntry(
225 this.getClass().getName()).getUseWorkflowPessimisticLocking()) && (!getNonLockingActionTakenCodes()
226 .contains(event.getActionTaken().getActionTaken().getCode()))) {
227
228
229 KRADServiceLocatorWeb.getPessimisticLockService().establishWorkflowPessimisticLocking(this);
230 }
231 }
232
233
234
235
236 public void afterActionTaken(ActionType performed, ActionTakenEvent event) {
237
238 }
239
240 protected List<String> getNonLockingActionTakenCodes() {
241 List<String> actionTakenStatusCodes = new ArrayList<String>();
242 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_SAVED_CD);
243 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_ACKNOWLEDGED_CD);
244 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_FYI_CD);
245 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_DENIED_CD);
246 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_CANCELED_CD);
247 actionTakenStatusCodes.add(KewApiConstants.ACTION_TAKEN_LOG_DOCUMENT_ACTION_CD);
248 return actionTakenStatusCodes;
249 }
250
251
252
253
254
255
256
257 public void afterWorkflowEngineProcess(boolean successfullyProcessed) {
258 if (KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getDocumentEntry(
259 this.getClass().getName()).getUseWorkflowPessimisticLocking()) {
260 if (successfullyProcessed) {
261
262
263 KRADServiceLocatorWeb.getPessimisticLockService().releaseWorkflowPessimisticLocking(this);
264 }
265 }
266 }
267
268
269
270
271
272
273
274 public void beforeWorkflowEngineProcess() {
275
276 }
277
278
279
280
281
282
283 public List<String> getWorkflowEngineDocumentIdsToLock() {
284 return null;
285 }
286
287
288
289
290 public void toCopy() throws WorkflowException, IllegalStateException {
291 if (!this.getAllowsCopy()) {
292 throw new IllegalStateException(this.getClass().getName() + " does not support document-level copying");
293 }
294 String sourceDocumentHeaderId = getDocumentNumber();
295 setNewDocumentHeader();
296
297 getDocumentHeader().setDocumentTemplateNumber(sourceDocumentHeaderId);
298
299
300 this.notes.clear();
301 addCopyErrorDocumentNote("copied from document " + sourceDocumentHeaderId);
302 }
303
304
305
306
307
308
309 protected void setNewDocumentHeader() throws WorkflowException {
310 TransactionalDocument newDoc =
311 (TransactionalDocument) KRADServiceLocatorWeb.getDocumentService().getNewDocument(
312 getDocumentHeader().getWorkflowDocument().getDocumentTypeName());
313 newDoc.getDocumentHeader().setDocumentDescription(getDocumentHeader().getDocumentDescription());
314 newDoc.getDocumentHeader().setOrganizationDocumentNumber(getDocumentHeader().getOrganizationDocumentNumber());
315
316 try {
317 ObjectUtils.setObjectPropertyDeep(this, KRADPropertyConstants.DOCUMENT_NUMBER, documentNumber.getClass(),
318 newDoc.getDocumentNumber());
319 } catch (Exception e) {
320 LOG.error("Unable to set document number property in copied document " + e.getMessage(), e);
321 throw new RuntimeException("Unable to set document number property in copied document " + e.getMessage(),
322 e);
323 }
324
325
326 setDocumentHeader(newDoc.getDocumentHeader());
327 }
328
329
330
331
332
333
334 protected void addCopyErrorDocumentNote(String noteText) {
335 Note note = null;
336 try {
337 note = KRADServiceLocatorWeb.getDocumentService().createNoteFromDocument(this, noteText);
338 } catch (Exception e) {
339 logErrors();
340 throw new RuntimeException("Couldn't create note on copy or error", e);
341 }
342 addNote(note);
343 }
344
345
346
347
348 public String getXmlForRouteReport() {
349 prepareForSave();
350 populateDocumentForRouting();
351 return getDocumentHeader().getWorkflowDocument().getApplicationContent();
352 }
353
354
355
356
357 public void populateDocumentForRouting() {
358 getDocumentHeader().getWorkflowDocument().setApplicationContent(serializeDocumentToXml());
359 }
360
361
362
363
364 public String serializeDocumentToXml() {
365 DocumentSerializerService documentSerializerService = KRADServiceLocatorWeb.getDocumentSerializerService();
366 String xml = documentSerializerService.serializeDocumentToXmlForRouting(this);
367 return xml;
368 }
369
370
371
372
373
374
375
376 public KualiDocumentXmlMaterializer wrapDocumentWithMetadataForXmlSerialization() {
377 KualiTransactionalDocumentInformation transInfo = new KualiTransactionalDocumentInformation();
378 DocumentInitiator initiator = new DocumentInitiator();
379 String initiatorPrincipalId = getDocumentHeader().getWorkflowDocument().getDocument().getInitiatorPrincipalId();
380 Person initiatorUser = KimApiServiceLocator.getPersonService().getPerson(initiatorPrincipalId);
381 initiator.setPerson(initiatorUser);
382 transInfo.setDocumentInitiator(initiator);
383 KualiDocumentXmlMaterializer xmlWrapper = new KualiDocumentXmlMaterializer();
384 xmlWrapper.setDocument(this);
385 xmlWrapper.setKualiTransactionalDocumentInformation(transInfo);
386 return xmlWrapper;
387 }
388
389
390
391
392
393
394
395
396
397
398 public PropertySerializabilityEvaluator getDocumentPropertySerizabilityEvaluator() {
399 String docTypeName = getDocumentHeader().getWorkflowDocument().getDocumentTypeName();
400 DocumentEntry documentEntry =
401 KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().getDocumentEntry(docTypeName);
402 WorkflowProperties workflowProperties = documentEntry.getWorkflowProperties();
403 WorkflowAttributes workflowAttributes = documentEntry.getWorkflowAttributes();
404 return createPropertySerializabilityEvaluator(workflowProperties, workflowAttributes);
405 }
406
407 protected PropertySerializabilityEvaluator createPropertySerializabilityEvaluator(
408 WorkflowProperties workflowProperties, WorkflowAttributes workflowAttributes) {
409 if (workflowAttributes != null) {
410 return new AlwaysFalsePropertySerializabilityEvaluator();
411 }
412 if (workflowProperties == null) {
413 return new AlwaysTruePropertySerializibilityEvaluator();
414 }
415 PropertySerializabilityEvaluator evaluator = new BusinessObjectPropertySerializibilityEvaluator();
416 evaluator.initializeEvaluatorForDocument(this);
417 return evaluator;
418 }
419
420
421
422
423
424
425
426 public String getBasePathToDocumentDuringSerialization() {
427 return "document";
428 }
429
430
431
432
433 public DocumentHeader getDocumentHeader() {
434 return this.documentHeader;
435 }
436
437
438
439
440 public void setDocumentHeader(DocumentHeader documentHeader) {
441 this.documentHeader = documentHeader;
442 }
443
444
445
446
447 public String getDocumentNumber() {
448 return documentNumber;
449 }
450
451
452
453
454 public void setDocumentNumber(String documentNumber) {
455 this.documentNumber = documentNumber;
456 }
457
458
459
460
461 public List<AdHocRoutePerson> getAdHocRoutePersons() {
462 return adHocRoutePersons;
463 }
464
465
466
467
468 public void setAdHocRoutePersons(List<AdHocRoutePerson> adHocRoutePersons) {
469 this.adHocRoutePersons = adHocRoutePersons;
470 }
471
472
473
474
475 public List<AdHocRouteWorkgroup> getAdHocRouteWorkgroups() {
476 return adHocRouteWorkgroups;
477 }
478
479
480
481
482 public void setAdHocRouteWorkgroups(List<AdHocRouteWorkgroup> adHocRouteWorkgroups) {
483 this.adHocRouteWorkgroups = adHocRouteWorkgroups;
484 }
485
486 public void postProcessSave(KualiDocumentEvent event) {
487
488
489 }
490
491
492
493
494
495
496 public void prepareForSave(KualiDocumentEvent event) {
497
498 }
499
500 public void validateBusinessRules(KualiDocumentEvent event) {
501 if (GlobalVariables.getMessageMap().hasErrors()) {
502 logErrors();
503 throw new ValidationException("errors occured before business rule");
504 }
505
506
507 LOG.info("invoking rules engine on document " + getDocumentNumber());
508 boolean isValid = true;
509 isValid = KRADServiceLocatorWeb.getKualiRuleService().applyRules(event);
510
511
512 if (!isValid) {
513 logErrors();
514
515
516 throw new ValidationException("business rule evaluation failed");
517 } else if (GlobalVariables.getMessageMap().hasErrors()) {
518 logErrors();
519 throw new ValidationException(
520 "Unreported errors occured during business rule evaluation (rule developer needs to put meaningful error messages into global ErrorMap)");
521 }
522 LOG.debug("validation completed");
523
524 }
525
526
527
528
529 protected void logErrors() {
530 if (LOG.isInfoEnabled()) {
531 if (GlobalVariables.getMessageMap().hasErrors()) {
532
533 for (Iterator<Map.Entry<String, AutoPopulatingList<ErrorMessage>>> i =
534 GlobalVariables.getMessageMap().getAllPropertiesAndErrors().iterator(); i.hasNext(); ) {
535 Map.Entry<String, AutoPopulatingList<ErrorMessage>> e = i.next();
536
537 StringBuffer logMessage = new StringBuffer();
538 logMessage.append("[" + e.getKey() + "] ");
539 boolean first = true;
540
541 AutoPopulatingList<ErrorMessage> errorList = e.getValue();
542 for (Iterator<ErrorMessage> j = errorList.iterator(); j.hasNext(); ) {
543 ErrorMessage em = j.next();
544
545 if (first) {
546 first = false;
547 } else {
548 logMessage.append(";");
549 }
550 logMessage.append(em);
551 }
552
553 LOG.info(logMessage);
554 }
555 }
556 }
557 }
558
559
560
561
562
563
564 public List<KualiDocumentEvent> generateSaveEvents() {
565 return new ArrayList<KualiDocumentEvent>();
566 }
567
568
569
570
571 public void doRouteStatusChange(DocumentRouteStatusChange statusChangeEvent) {
572
573 }
574
575
576
577
578
579
580
581
582
583
584
585 @Override
586 public PersistableBusinessObject getNoteTarget() {
587 return getDocumentHeader();
588 }
589
590
591
592
593
594
595
596
597
598
599
600
601 @Override
602 public NoteType getNoteType() {
603 return NoteType.DOCUMENT_HEADER;
604 }
605
606
607
608
609 @Override
610 public void addNote(Note note) {
611 if (note == null) {
612 throw new IllegalArgumentException("Note cannot be null.");
613 }
614 notes.add(note);
615 }
616
617
618
619
620 @Override
621 public boolean removeNote(Note note) {
622 if (note == null) {
623 throw new IllegalArgumentException("Note cannot be null.");
624 }
625 return notes.remove(note);
626 }
627
628
629
630
631 @Override
632 public Note getNote(int index) {
633 return notes.get(index);
634 }
635
636
637
638
639 @Override
640 public List<Note> getNotes() {
641 if (CollectionUtils.isEmpty(notes) && getNoteType().equals(NoteType.BUSINESS_OBJECT) && StringUtils.isNotBlank(
642 getNoteTarget().getObjectId())) {
643 notes = getNoteService().getByRemoteObjectId(getNoteTarget().getObjectId());
644 }
645
646 return notes;
647 }
648
649
650
651
652 @Override
653 public void setNotes(List<Note> notes) {
654 if (notes == null) {
655 throw new IllegalArgumentException("List of notes must be non-null.");
656 }
657 this.notes = notes;
658 }
659
660 @Override
661 protected void postLoad() {
662 super.postLoad();
663 refreshPessimisticLocks();
664 }
665
666
667
668
669 public List<PessimisticLock> getPessimisticLocks() {
670 return this.pessimisticLocks;
671 }
672
673
674
675
676
677 @Deprecated
678 public void refreshPessimisticLocks() {
679 this.pessimisticLocks.clear();
680 this.pessimisticLocks = KRADServiceLocatorWeb.getPessimisticLockService().getPessimisticLocksForDocument(
681 this.documentNumber);
682 }
683
684
685
686
687 public void setPessimisticLocks(List<PessimisticLock> pessimisticLocks) {
688 this.pessimisticLocks = pessimisticLocks;
689 }
690
691
692
693
694 public void addPessimisticLock(PessimisticLock lock) {
695 this.pessimisticLocks.add(lock);
696 }
697
698
699
700
701 public List<String> getLockClearningMethodNames() {
702 List<String> methodToCalls = new ArrayList<String>();
703 methodToCalls.add(KRADConstants.CLOSE_METHOD);
704 methodToCalls.add(KRADConstants.CANCEL_METHOD);
705
706 methodToCalls.add(KRADConstants.ROUTE_METHOD);
707 methodToCalls.add(KRADConstants.APPROVE_METHOD);
708 methodToCalls.add(KRADConstants.DISAPPROVE_METHOD);
709 return methodToCalls;
710 }
711
712
713
714
715
716
717
718
719 public boolean useCustomLockDescriptors() {
720 return false;
721 }
722
723
724
725
726
727
728
729
730 public String getCustomLockDescriptor(Person user) {
731 throw new PessimisticLockingException("Document " + getDocumentNumber() +
732 " is using pessimistic locking with custom lock descriptors, but the document class has not overriden the getCustomLockDescriptor method");
733 }
734
735 protected AttachmentService getAttachmentService() {
736 if (attachmentService == null) {
737 attachmentService = KRADServiceLocator.getAttachmentService();
738 }
739 return attachmentService;
740 }
741
742 protected NoteService getNoteService() {
743 if (noteService == null) {
744 noteService = KRADServiceLocator.getNoteService();
745 }
746 return noteService;
747 }
748 }