001 /**
002 * Copyright 2005-2011 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.kuali.rice.edl.impl.components;
017
018 import org.apache.commons.fileupload.FileItem;
019 import org.apache.commons.lang.StringUtils;
020 import org.apache.log4j.Logger;
021 import org.kuali.rice.core.api.CoreApiServiceLocator;
022 import org.kuali.rice.core.api.config.property.ConfigContext;
023 import org.kuali.rice.core.api.util.RiceConstants;
024 import org.kuali.rice.core.api.util.xml.XmlHelper;
025 import org.kuali.rice.core.api.util.xml.XmlJotter;
026 import org.kuali.rice.core.framework.services.CoreFrameworkServiceLocator;
027 import org.kuali.rice.core.mail.EmailBcList;
028 import org.kuali.rice.core.mail.EmailBody;
029 import org.kuali.rice.core.mail.EmailCcList;
030 import org.kuali.rice.core.mail.EmailContent;
031 import org.kuali.rice.core.mail.EmailFrom;
032 import org.kuali.rice.core.mail.EmailSubject;
033 import org.kuali.rice.core.mail.EmailToList;
034 import org.kuali.rice.edl.impl.EDLContext;
035 import org.kuali.rice.edl.impl.EDLModelComponent;
036 import org.kuali.rice.edl.impl.EDLXmlUtils;
037 import org.kuali.rice.edl.impl.RequestParser;
038 import org.kuali.rice.edl.impl.service.EdlServiceLocator;
039 import org.kuali.rice.kew.api.WorkflowDocument;
040 import org.kuali.rice.kew.api.WorkflowRuntimeException;
041 import org.kuali.rice.kew.mail.EmailStyleHelper;
042 import org.kuali.rice.kew.notes.Attachment;
043 import org.kuali.rice.kew.notes.CustomNoteAttribute;
044 import org.kuali.rice.kew.notes.Note;
045 import org.kuali.rice.kew.notes.service.NoteService;
046 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
047 import org.kuali.rice.kew.routeheader.service.RouteHeaderService;
048 import org.kuali.rice.kew.service.KEWServiceLocator;
049 import org.kuali.rice.kew.api.KewApiConstants;
050 import org.kuali.rice.kim.api.identity.Person;
051 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
052 import org.w3c.dom.Document;
053 import org.w3c.dom.Element;
054
055 import javax.xml.bind.JAXBContext;
056 import javax.xml.bind.Marshaller;
057 import javax.xml.parsers.DocumentBuilder;
058 import javax.xml.parsers.DocumentBuilderFactory;
059 import javax.xml.transform.Templates;
060 import javax.xml.transform.TransformerConfigurationException;
061 import javax.xml.xpath.XPath;
062 import javax.xml.xpath.XPathConstants;
063 import javax.xml.xpath.XPathExpressionException;
064 import javax.xml.xpath.XPathFactory;
065 import java.sql.Timestamp;
066 import java.text.DateFormat;
067 import java.util.ArrayList;
068 import java.util.Collections;
069 import java.util.Comparator;
070 import java.util.Date;
071 import java.util.Iterator;
072 import java.util.List;
073 import java.util.StringTokenizer;
074 import java.util.regex.Matcher;
075 import java.util.regex.Pattern;
076
077 /**
078 * Adds notes support to EDL
079 *
080 * @author Kuali Rice Team (rice.collab@kuali.org)
081 *
082 */
083 public class NoteConfigComponent implements EDLModelComponent {
084
085 private static final Logger LOG = Logger.getLogger(NoteConfigComponent.class);
086
087 private EmailStyleHelper emailStyleHelper = new EmailStyleHelper();
088 private String styleName;
089 private String from;
090 private List<String> to;
091 private List<String> cc = new ArrayList<String>();
092 private List<String> bc = new ArrayList<String>();
093 private static final String DEFAULT_EMAIL_FROM_ADDRESS = CoreFrameworkServiceLocator.getParameterService()
094 .getParameterValueAsString(KewApiConstants.KEW_NAMESPACE, "Mailer", "FROM_ADDRESS");//"workflow@indiana.edu";
095
096 public void updateDOM(Document dom, Element configElement, EDLContext edlContext) {
097 NoteForm noteForm = new NoteForm(edlContext.getRequestParser());
098 WorkflowDocument document = (WorkflowDocument) edlContext.getRequestParser().getAttribute(
099 RequestParser.WORKFLOW_DOCUMENT_SESSION_KEY);
100 try {
101 //establish notes depends on a document id being set on noteform or nothing happens
102 if (document != null) {
103 noteForm.setDocId(document.getDocumentId());
104 }
105 establishNotes(noteForm, edlContext, dom);
106 addNotes(dom, noteForm);
107 } catch (Exception e) {
108 throw new WorkflowRuntimeException("Caught exception processing notes", e);
109 }
110
111 }
112
113 public void establishNotes(NoteForm form, EDLContext edlContext, Document dom) throws Exception {
114
115 form.setCurrentUserName(edlContext.getUserSession().getPerson().getName());
116 form.setCurrentDate(getCurrentDate());
117 String methodToCall = form.getMethodToCall();
118 if (!org.apache.commons.lang.StringUtils.isEmpty(methodToCall)) {
119 if ("save".equalsIgnoreCase(methodToCall)) {
120 this.saveNote(form, edlContext, dom);
121 } else if ("edit".equalsIgnoreCase(methodToCall)) {
122 this.editNote(form);
123 } else if ("add".equalsIgnoreCase(methodToCall)) {
124 this.addNote(form);
125 } else if ("cancel".equalsIgnoreCase(methodToCall)) {
126 this.cancelEdit(form);
127 } else if ("delete".equalsIgnoreCase(methodToCall)) {
128 this.deleteNote(form);
129 } else if ("sort".equalsIgnoreCase(methodToCall)) {
130 this.sortNotes(form);
131 } else if ("deleteAttachment".equalsIgnoreCase(methodToCall)) {
132 this.deleteAttachment(form);
133 }
134 }
135 retrieveNoteList(form, edlContext);
136
137 }
138
139 /**
140 * Method added for notes editing function. Retrieve Note Listing from Route Header and put that
141 * in EdocLiteForm.
142 * @param request
143 * @param noteForm
144 * @throws Exception
145 */
146
147 private void retrieveNoteList(NoteForm form, EDLContext edlContext) throws Exception {
148 if (form.getDocId() != null) {
149 List allNotes = getNoteService().getNotesByDocumentId(form.getDocId());
150 CustomNoteAttribute customNoteAttribute = null;
151 DocumentRouteHeaderValue routeHeader = getRouteHeaderService().getRouteHeader(form.getDocId());
152 boolean canAddNotes = false;
153 if (routeHeader != null) {
154 customNoteAttribute = routeHeader.getCustomNoteAttribute();
155 if (customNoteAttribute != null) {
156 customNoteAttribute.setUserSession(edlContext.getUserSession());
157 canAddNotes = customNoteAttribute.isAuthorizedToAddNotes();
158 }
159 }
160 Iterator notesIter = allNotes.iterator();
161 while (notesIter.hasNext()) {
162 Note singleNote = (Note) notesIter.next();
163 singleNote.setNoteCreateLongDate(new Long(singleNote.getNoteCreateDate().getTime()));
164 getAuthorData(singleNote);
165 boolean canEditNote = false;
166 if (customNoteAttribute != null) {
167 canEditNote = customNoteAttribute.isAuthorizedToEditNote(singleNote);
168 }
169 singleNote.setAuthorizedToEdit(Boolean.valueOf(canEditNote));
170 if (form.getNoteIdNumber() != null
171 && (StringUtils.equals(form.getNoteIdNumber(), singleNote.getNoteId()))) {
172 singleNote.setEditingNote(Boolean.TRUE);
173 }
174 }
175 if (form.getSortNotes() != null && form.getSortNotes().booleanValue()) {
176 if (KewApiConstants.Sorting.SORT_SEQUENCE_DSC.equalsIgnoreCase(form.getSortOrder())) {
177 form.setSortOrder(KewApiConstants.Sorting.SORT_SEQUENCE_ASC);
178 form.setSortNotes(Boolean.FALSE);
179 } else {
180 form.setSortOrder(KewApiConstants.Sorting.SORT_SEQUENCE_DSC);
181 form.setSortNotes(Boolean.FALSE);
182 }
183 } else {
184 form.setSortOrder(form.getSortOrder());
185 }
186 form.setNoteList(sortNotes(allNotes, form.getSortOrder()));
187 form.setNumberOfNotes(new Integer(allNotes.size()));
188 form.setAuthorizedToAdd(new Boolean(canAddNotes));
189 form.setShowAdd(Boolean.TRUE);
190 if (!canAddNotes) {
191 form.setShowAdd(Boolean.FALSE);
192 } else if (form.getNoteList().size() == 0) {
193 //form.setShowAdd(Boolean.TRUE);
194 }
195 }
196 }
197
198 public void editNote(NoteForm form) throws Exception {
199 form.setShowEdit("yes");
200 // Note noteToEdit =
201 // getNoteService().getNoteByNoteId(form.getNoteIdNumber());
202 //form.setNote(noteToEdit);
203 form.getNote().setNoteCreateLongDate(new Long(form.getNote().getNoteCreateDate().getTime()));
204 form.getNote().setNoteText(form.getNoteText());
205 //retrieveNoteList(request, form);
206 }
207
208 public void addNote(NoteForm form) throws Exception {
209 form.setShowEdit("no");
210 form.setNoteIdNumber(null);
211 form.setShowAdd(Boolean.TRUE);
212 //retrieveNoteList(request,form);
213
214 }
215
216 public void cancelEdit(NoteForm form) throws Exception {
217 form.setShowEdit("no");
218 form.setNote(new Note());
219 form.setNoteIdNumber(null);
220 //retrieveNoteList(request, form);
221 }
222
223 public void deleteNote(NoteForm form) throws Exception {
224 Note noteToDelete = getNoteService().getNoteByNoteId(form.getNoteIdNumber());
225 getNoteService().deleteNote(noteToDelete);
226 form.setShowEdit("no");
227 //retrieveNoteList(request, form);
228 form.setNote(new Note());
229 form.setNoteIdNumber(null);
230 }
231
232 public void sortNotes(NoteForm form) throws Exception {
233 form.setShowEdit("no");
234 }
235
236 public void deleteAttachment(NoteForm form) throws Exception {
237 Note note = getNoteService().getNoteByNoteId(form.getNoteIdNumber());
238 getNoteService().deleteAttachment((Attachment) note.getAttachments().remove(0));
239 }
240
241 public void saveNote(NoteForm form, EDLContext edlContext, Document dom) throws Exception {
242 Note noteToSave = null;
243 if (form.getShowEdit() != null && form.getShowEdit().equals("yes")) {
244 //LOG.debug(form.getNoteIdNumber());
245 noteToSave = getNoteService().getNoteByNoteId(form.getNoteIdNumber());
246 String noteText = form.getNoteText();
247 if (noteText != null) {
248 noteToSave.setNoteText(noteText);
249 }
250 //LOG.debug(noteToSave);
251 //LOG.debug(noteToSave.getNoteCreateDate());
252 //noteToSave.setNoteCreateDate(new Timestamp(noteToSave.getNoteCreateLongDate().longValue()));
253 } else {
254 noteToSave = new Note();
255 noteToSave.setNoteId(null);
256 noteToSave.setDocumentId(form.getDocId());
257 noteToSave.setNoteCreateDate(new Timestamp((new Date()).getTime()));
258 noteToSave.setNoteAuthorWorkflowId(edlContext.getUserSession().getPrincipalId());
259 noteToSave.setNoteText(form.getAddText());
260 }
261 CustomNoteAttribute customNoteAttribute = null;
262 DocumentRouteHeaderValue routeHeader = getRouteHeaderService().getRouteHeader(noteToSave.getDocumentId());
263 boolean canEditNote = false;
264 boolean canAddNotes = false;
265 if (routeHeader != null) {
266 customNoteAttribute = routeHeader.getCustomNoteAttribute();
267 if (customNoteAttribute != null) {
268 customNoteAttribute.setUserSession(edlContext.getUserSession());
269 canAddNotes = customNoteAttribute.isAuthorizedToAddNotes();
270 canEditNote = customNoteAttribute.isAuthorizedToEditNote(noteToSave);
271 }
272 }
273 if ((form.getShowEdit() != null && form.getShowEdit().equals("yes") && canEditNote) ||
274 ((form.getShowEdit() == null || !form.getShowEdit().equals("yes")) && canAddNotes)) {
275 FileItem uploadedFile = (FileItem) form.getFile();
276 if (uploadedFile != null && org.apache.commons.lang.StringUtils.isNotBlank(uploadedFile.getName())) {
277 Attachment attachment = new Attachment();
278 attachment.setAttachedObject(uploadedFile.getInputStream());
279 String internalFileIndicator = uploadedFile.getName();
280 int indexOfSlash = internalFileIndicator.lastIndexOf("/");
281 int indexOfBackSlash = internalFileIndicator.lastIndexOf("\\");
282 if (indexOfSlash >= 0) {
283 internalFileIndicator = internalFileIndicator.substring(indexOfSlash + 1);
284 } else {
285 if (indexOfBackSlash >= 0) {
286 internalFileIndicator = internalFileIndicator.substring(indexOfBackSlash + 1);
287 }
288 }
289 attachment.setFileName(internalFileIndicator);
290 LOG.debug(internalFileIndicator);
291 attachment.setMimeType(uploadedFile.getContentType());
292 attachment.setNote(noteToSave);
293 noteToSave.getAttachments().add(attachment);
294 }
295 if (org.apache.commons.lang.StringUtils.isEmpty(noteToSave.getNoteText())
296 && noteToSave.getAttachments().size() == 0) {
297 if (form.getShowEdit() != null && form.getShowEdit().equals("yes")) {
298 form.setNote(new Note());
299 } else {
300 form.setAddText(null);
301 }
302 form.setShowEdit("no");
303 form.setNoteIdNumber(null);
304 // throw new Exception("Note has empty content");
305 EDLXmlUtils.addGlobalErrorMessage(dom, "Note has empty content");
306 return;
307 }
308 getNoteService().saveNote(noteToSave);
309
310 // add ability to send emails when a note is saved.
311 boolean sendEmailOnNoteSave = false;
312 // Check if edoclite specifies <param name="sendEmailOnNoteSave">
313 Document edlDom = EdlServiceLocator.getEDocLiteService()
314 .getDefinitionXml(edlContext.getEdocLiteAssociation());
315 XPath xpath = XPathFactory.newInstance().newXPath();
316 String xpathExpression = "//config/param[@name='sendEmailOnNoteSave']";
317 try {
318 String match = (String) xpath.evaluate(xpathExpression, edlDom, XPathConstants.STRING);
319 if (!StringUtils.isBlank(match) && match.equals("true")) {
320 sendEmailOnNoteSave = true;
321 }
322 } catch (XPathExpressionException e) {
323 throw new WorkflowRuntimeException(
324 "Unable to evaluate sendEmailOnNoteSave xpath expression in NoteConfigComponent saveNote method"
325 + xpathExpression, e);
326 }
327
328 if (sendEmailOnNoteSave) {
329 xpathExpression = "//data/version[@current='true']/field[@name='emailTo']/value";
330 String emailTo = xpath.evaluate(xpathExpression, dom);
331 if (StringUtils.isBlank(emailTo)) {
332 EDLXmlUtils.addGlobalErrorMessage(dom,
333 "No email notifications were sent because EmailTo field was empty.");
334 return;
335 }
336 // Actually send the emails.
337 if (isProduction()) {
338 this.to = stringToList(emailTo);
339 } else {
340 String testAddress = getTestAddress(edlDom);
341 if (StringUtils.isBlank(testAddress)) {
342 EDLXmlUtils
343 .addGlobalErrorMessage(
344 dom,
345 "No email notifications were sent because testAddress edl param was empty or not specified in a non production environment");
346 return;
347 }
348 this.to = stringToList(getTestAddress(edlDom));
349 }
350 if (!isEmailListValid(this.to)) {
351 EDLXmlUtils
352 .addGlobalErrorMessage(
353 dom,
354 "No email notifications were sent because emailTo field contains invalid email address.");
355 return;
356 }
357 String noteEmailStylesheet = "";
358 xpathExpression = "//config/param[@name='noteEmailStylesheet']";
359 try {
360 noteEmailStylesheet = (String) xpath.evaluate(
361 xpathExpression, edlDom, XPathConstants.STRING);
362 if (StringUtils.isBlank(noteEmailStylesheet)) {
363 EDLXmlUtils
364 .addGlobalErrorMessage(
365 dom,
366 "No email notifications were sent because noteEmailStylesheet edl param was empty or not specified.");
367 return;
368 }
369 } catch (XPathExpressionException e) {
370 throw new WorkflowRuntimeException(
371 "Unable to evaluate noteEmailStylesheet xpath expression in NoteConfigComponent method"
372 + xpathExpression, e);
373 }
374 this.styleName = noteEmailStylesheet;
375 this.from = DEFAULT_EMAIL_FROM_ADDRESS;
376 Document document = generateXmlInput(form, edlContext, edlDom);
377 if (LOG.isDebugEnabled()) {
378 LOG.debug("XML input for email tranformation:\n" + XmlJotter.jotNode(document));
379 }
380 Templates style = loadStyleSheet(styleName);
381 EmailContent emailContent = emailStyleHelper
382 .generateEmailContent(style, document);
383 if (!this.to.isEmpty()) {
384 KEWServiceLocator.getMailer().sendEmail(
385 new EmailFrom(from), new EmailToList(this.to),
386 new EmailSubject(emailContent.getSubject()),
387 new EmailBody(emailContent.getBody()),
388 new EmailCcList(this.cc), new EmailBcList(this.bc),
389 emailContent.isHtml());
390 }
391 }
392
393 }
394 if (form.getShowEdit() != null && form.getShowEdit().equals("yes")) {
395 form.setNote(new Note());
396 } else {
397 form.setAddText(null);
398 }
399 form.setShowEdit("no");
400 form.setNoteIdNumber(null);
401 }
402
403 protected String getTestAddress(Document edlDom) {
404 String testAddress = "";
405 XPath xpath = XPathFactory.newInstance().newXPath();
406 String xpathExpression = "//config/param[@name='testAddress']";
407 try {
408 testAddress = (String) xpath.evaluate(xpathExpression, edlDom, XPathConstants.STRING);
409 } catch (XPathExpressionException e) {
410 throw new WorkflowRuntimeException(
411 "Unable to evaluate testAddressAttributeFound xpath expression in NoteConfigComponent getTestAddress method"
412 + xpathExpression, e);
413 }
414 return testAddress;
415 }
416
417 protected Document generateXmlInput(NoteForm form, EDLContext edlContext, Document dom) throws Exception {
418 DocumentBuilder db = getDocumentBuilder(true);
419 Document doc = db.newDocument();
420 Element emailNodeElem = doc.createElement("emailNode");
421 doc.appendChild(emailNodeElem);
422 WorkflowDocument document = (WorkflowDocument) edlContext.getRequestParser().getAttribute(
423 RequestParser.WORKFLOW_DOCUMENT_SESSION_KEY);
424
425 /* Upgrade Changes 0914 to 1011 */
426 //RouteHeaderVO routeHeaderVO = document.getRouteHeader();
427 JAXBContext jaxb = JAXBContext.newInstance(org.kuali.rice.kew.api.document.Document.class);
428 Marshaller marshaller = jaxb.createMarshaller();
429 marshaller.marshal(document.getDocument(), emailNodeElem);
430 emailNodeElem.appendChild(doc.importNode(dom.getDocumentElement(), true));
431 Element dConElem = XmlHelper.readXml(document.getDocumentContent().getApplicationContent())
432 .getDocumentElement(); //Add document Content element for
433 emailNodeElem.appendChild(doc.importNode(dConElem, true)); //access by the stylesheet when creating the email
434 return doc;
435 }
436
437 protected DocumentBuilder getDocumentBuilder(boolean coalesce) throws Exception {
438 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
439 dbf.setCoalescing(coalesce);
440 return dbf.newDocumentBuilder();
441 }
442
443 /* Upgrade Changes 0914 to 1011 */
444 /*
445 protected boolean isProduction() {
446 return EdenConstants.PROD_DEPLOYMENT_CODE.equalsIgnoreCase(Core.getCurrentContextConfig().getEnvironment());
447 }
448 */
449 protected boolean isProduction() {
450 return ConfigContext.getCurrentContextConfig().isProductionEnvironment();
451 }
452
453 protected boolean isEmailListValid(List<String> emailList) {
454 Pattern p = Pattern.compile("^\\.|^\\@");
455 Matcher m = null;
456 for (String emailAddress : emailList) {
457 m = p.matcher(emailAddress);
458 if (m.find()) {
459 //System.err.println("Email addresses don't start with dots or @ signs.");
460 return false;
461 }
462 }
463 p = Pattern.compile("^www\\.");
464 for (String emailAddress : emailList) {
465 m = p.matcher(emailAddress);
466 if (m.find()) {
467 //System.err.println("Email addresses don't start with \"www.\", only web pages do.");
468 return false;
469 }
470 }
471 // find illegal characters.
472 p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
473 for (String emailAddress : emailList) {
474 // strip comma at end if there is one.
475 String e2 = stripComma(emailAddress);
476 m = p.matcher(e2);
477 if (m.find()) {
478 //System.err.println("Email address contains illegal character(s).");
479 return false;
480 }
481 }
482 // email address should match this pattern.
483 p = Pattern.compile("^([a-zA-Z0-9_\\-\\.]+)\\@([a-zA-Z0-9_\\-\\.]+)\\.([a-zA-Z]{2,5})$");
484 for (String emailAddress : emailList) {
485 String e2 = stripComma(emailAddress);
486 m = p.matcher(e2);
487 if (!m.find()) {
488 //System.err.println("Illegal Email address format.");
489 return false;
490 }
491 }
492 return true;
493 }
494
495 protected String stripComma(String s) {
496 String sNew = "";
497 if (s.endsWith(",")) {
498 int x = s.length() - 1;
499 sNew = s.substring(0, x);
500 } else {
501 sNew = s;
502 }
503 return sNew;
504 }
505
506 protected List<String> stringToList(String to) {
507 List<String> recipientAddresses = new ArrayList<String>();
508 StringTokenizer st = new StringTokenizer(to, " ", false);
509 while (st.hasMoreTokens()) {
510 recipientAddresses.add(st.nextToken());
511 }
512 return recipientAddresses;
513 }
514
515 protected Templates loadStyleSheet(String styleName) {
516 try {
517 Templates style = CoreApiServiceLocator.getStyleService().getStyleAsTranslet(styleName);
518 if (style == null) {
519 throw new WorkflowRuntimeException("Failed to locate stylesheet with name '" + styleName + "'");
520 }
521 return style;
522 } catch (TransformerConfigurationException tce) {
523 throw new WorkflowRuntimeException("Failed to load stylesheet with name '" + styleName + "'");
524 }
525 }
526
527 public static void addNotes(Document doc, NoteForm form) {
528 Element noteForm = EDLXmlUtils.getOrCreateChildElement(doc.getDocumentElement(), "NoteForm", true);
529 if (form.getShowEdit() != null) {
530 Element showEdit = EDLXmlUtils.getOrCreateChildElement(noteForm, "showEdit", true);
531 showEdit.appendChild(doc.createTextNode(form.getShowEdit().toLowerCase()));
532 } else {
533 Element showEdit = EDLXmlUtils.getOrCreateChildElement(noteForm, "showEdit", true);
534 showEdit.appendChild(doc.createTextNode("no"));
535 }
536 if (form.getShowAdd() != null) {
537 Element showAdd = EDLXmlUtils.getOrCreateChildElement(noteForm, "showAdd", true);
538 showAdd.appendChild(doc.createTextNode(form.getShowAdd().toString().toLowerCase()));
539 }
540 if (form.getCurrentUserName() != null) {
541 Element currentUserName = EDLXmlUtils.getOrCreateChildElement(noteForm, "currentUserName", true);
542 currentUserName.appendChild(doc.createTextNode(form.getCurrentUserName()));
543 }
544 if (form.getCurrentDate() != null) {
545 Element currentDate = EDLXmlUtils.getOrCreateChildElement(noteForm, "currentDate", true);
546 currentDate.appendChild(doc.createTextNode(form.getCurrentDate()));
547 }
548 if (form.getNoteIdNumber() != null) {
549 Element noteIdNumber = EDLXmlUtils.getOrCreateChildElement(noteForm, "noteIdNumber", true);
550 noteIdNumber.appendChild(doc.createTextNode(form.getNoteIdNumber().toString()));
551 }
552 if (form.getDocId() != null) {
553 Element docId = EDLXmlUtils.getOrCreateChildElement(noteForm, "docId", true);
554 docId.appendChild(doc.createTextNode((form.getDocId().toString())));
555 }
556 if (form.getSortNotes() != null) {
557 Element sortNotes = EDLXmlUtils.getOrCreateChildElement(noteForm, "sortNotes", true);
558 sortNotes.appendChild(doc.createTextNode(form.getSortNotes().toString().toLowerCase()));
559 }
560 if (form.getSortOrder() != null) {
561 Element sortOrder = EDLXmlUtils.getOrCreateChildElement(noteForm, "sortOrder", true);
562 sortOrder.appendChild(doc.createTextNode(form.getSortOrder().toUpperCase()));
563 }
564 if (form.getNumberOfNotes() != null) {
565 Element numberOfNotes = EDLXmlUtils.getOrCreateChildElement(noteForm, "numberOfNotes", true);
566 numberOfNotes.appendChild(doc.createTextNode(form.getNumberOfNotes().toString()));
567 }
568 if (form.getAuthorizedToAdd() != null) {
569 Element authorizedToAdd = EDLXmlUtils.getOrCreateChildElement(noteForm, "authorizedToAdd", true);
570 authorizedToAdd.appendChild(doc.createTextNode(form.getAuthorizedToAdd().toString().toLowerCase()));
571 }
572 if (form.getNumberOfNotes().intValue() > 0) {
573 Element notes = EDLXmlUtils.getOrCreateChildElement(noteForm, "Notes", true);
574 for (Iterator i = form.getNoteList().iterator(); i.hasNext();) {
575 Note noteObj = (Note) i.next();
576 Element note = notes.getOwnerDocument().createElement("Note");
577 notes.appendChild(note);
578 // Element note = Util.getOrCreateChildElement(notes, "Note",
579 // true);
580 if (noteObj.getNoteId() != null) {
581 Element noteId = EDLXmlUtils.getOrCreateChildElement(note, "noteId", true);
582 noteId.appendChild(doc.createTextNode(noteObj.getNoteId().toString()));
583 }
584 if (noteObj.getFormattedCreateDate() != null) {
585 Element formattedCreateDate = EDLXmlUtils
586 .getOrCreateChildElement(note, "formattedCreateDate", true);
587 formattedCreateDate.appendChild(doc.createTextNode(noteObj.getFormattedCreateDate()));
588 }
589 if (noteObj.getFormattedCreateTime() != null) {
590 Element formattedCreateTime = EDLXmlUtils
591 .getOrCreateChildElement(note, "formattedCreateTime", true);
592 formattedCreateTime.appendChild(doc.createTextNode(noteObj.getFormattedCreateTime()));
593 }
594 if (noteObj.getNoteAuthorFullName() != null) {
595 Element noteAuthorFullName = EDLXmlUtils.getOrCreateChildElement(note, "noteAuthorFullName", true);
596 noteAuthorFullName.appendChild(doc.createTextNode(noteObj.getNoteAuthorFullName()));
597 }
598 if (noteObj.getNoteText() != null) {
599 Element noteText = EDLXmlUtils.getOrCreateChildElement(note, "noteText", true);
600 noteText.appendChild(doc.createTextNode(noteObj.getNoteText()));
601 }
602 if (noteObj.getEditingNote() != null) {
603 Element editingNote = EDLXmlUtils.getOrCreateChildElement(note, "editingNote", true);
604 editingNote.appendChild(doc.createTextNode(noteObj.getEditingNote().toString()));
605 }
606 if (noteObj.getAuthorizedToEdit() != null) {
607 Element authorizedToEdit = EDLXmlUtils.getOrCreateChildElement(note, "authorizedToEdit", true);
608 authorizedToEdit.appendChild(doc.createTextNode(noteObj.getAuthorizedToEdit().toString()));
609 }
610 if (!noteObj.getAttachments().isEmpty()) {
611 Element attachments = EDLXmlUtils.getOrCreateChildElement(note, "attachments", true);
612 for (Iterator j = noteObj.getAttachments().iterator(); j.hasNext();) {
613 Attachment attachmentObj = (Attachment) j.next();
614 Element attachment = EDLXmlUtils.getOrCreateChildElement(attachments, "attachment", true);
615 Element attachmentId = EDLXmlUtils.getOrCreateChildElement(attachment, "attachmentId", true);
616 attachmentId.appendChild(doc.createTextNode(attachmentObj.getAttachmentId().toString()));
617 Element fileName = EDLXmlUtils.getOrCreateChildElement(attachment, "fileName", true);
618 fileName.appendChild(doc.createTextNode(attachmentObj.getFileName()));
619 }
620 }
621 }
622 }
623
624 }
625
626 private static class NoteForm {
627 private String showEdit;
628 private Boolean showAdd;
629 private String noteIdNumber;
630 private Integer numberOfNotes = new Integer(0);
631 private String sortOrder = "DESCENDING";
632 private Boolean sortNotes;
633 private String currentUserName;
634 private String currentDate;
635 private Boolean authorizedToAdd;
636 private List noteList;
637 private String addText;
638 private Long idInEdit;
639 private Note note;
640 private String noteText;
641 private String docId;
642 private String methodToCall;
643 private FileItem file;
644
645 public NoteForm(RequestParser requestParser) {
646
647 showEdit = requestParser.getParameterValue("showEdit");
648 if (!org.apache.commons.lang.StringUtils.isEmpty(requestParser.getParameterValue("showAdd"))) {
649 showAdd = Boolean.valueOf(requestParser.getParameterValue("showAdd"));
650 }
651 if (!org.apache.commons.lang.StringUtils.isEmpty(requestParser.getParameterValue("noteIdNumber"))) {
652 noteIdNumber = requestParser.getParameterValue("noteIdNumber");
653 }
654 methodToCall = requestParser.getParameterValue("methodToCall");
655 sortOrder = "DESCENDING";
656 if (!org.apache.commons.lang.StringUtils.isEmpty(requestParser.getParameterValue("sortNotes"))) {
657 sortNotes = Boolean.valueOf(requestParser.getParameterValue("sortNotes"));
658 }
659 addText = requestParser.getParameterValue("addText");
660 noteText = requestParser.getParameterValue("noteText");
661 if (!org.apache.commons.lang.StringUtils.isEmpty(requestParser.getParameterValue("idInEdit"))) {
662 idInEdit = Long.valueOf(requestParser.getParameterValue("idInEdit"));
663 }
664 if (noteIdNumber != null) {
665 note = KEWServiceLocator.getNoteService().getNoteByNoteId(noteIdNumber);
666 }
667 if (requestParser.getUploadList() != null && !requestParser.getUploadList().isEmpty()) {
668 file = (FileItem) requestParser.getUploadList().get(0);
669 }
670 }
671
672 public String getAddText() {
673 return addText;
674 }
675
676 public void setAddText(String addText) {
677 this.addText = addText;
678 }
679
680 public Boolean getAuthorizedToAdd() {
681 return authorizedToAdd;
682 }
683
684 public void setAuthorizedToAdd(Boolean authorizedToAdd) {
685 this.authorizedToAdd = authorizedToAdd;
686 }
687
688 public String getCurrentDate() {
689 return currentDate;
690 }
691
692 public void setCurrentDate(String currentDate) {
693 this.currentDate = currentDate;
694 }
695
696 public String getCurrentUserName() {
697 return currentUserName;
698 }
699
700 public void setCurrentUserName(String currentUserName) {
701 this.currentUserName = currentUserName;
702 }
703
704 public Long getIdInEdit() {
705 return idInEdit;
706 }
707
708 public void setIdInEdit(Long idInEdit) {
709 this.idInEdit = idInEdit;
710 }
711
712 public Note getNote() {
713 return note;
714 }
715
716 public void setNote(Note note) {
717 this.note = note;
718 }
719
720 public String getNoteIdNumber() {
721 return noteIdNumber;
722 }
723
724 public void setNoteIdNumber(String noteIdNumber) {
725 this.noteIdNumber = noteIdNumber;
726 }
727
728 public List getNoteList() {
729 return noteList;
730 }
731
732 public void setNoteList(List noteList) {
733 this.noteList = noteList;
734 }
735
736 public String getNoteText() {
737 return noteText;
738 }
739
740 public void setNoteText(String noteText) {
741 this.noteText = noteText;
742 }
743
744 public Integer getNumberOfNotes() {
745 return numberOfNotes;
746 }
747
748 public void setNumberOfNotes(Integer numberOfNotes) {
749 this.numberOfNotes = numberOfNotes;
750 }
751
752 public Boolean getShowAdd() {
753 return showAdd;
754 }
755
756 public void setShowAdd(Boolean showAdd) {
757 this.showAdd = showAdd;
758 }
759
760 public String getShowEdit() {
761 return showEdit;
762 }
763
764 public void setShowEdit(String showEdit) {
765 this.showEdit = showEdit;
766 }
767
768 public Boolean getSortNotes() {
769 return sortNotes;
770 }
771
772 public void setSortNotes(Boolean sortNotes) {
773 this.sortNotes = sortNotes;
774 }
775
776 public String getSortOrder() {
777 return sortOrder;
778 }
779
780 public void setSortOrder(String sortOrder) {
781 this.sortOrder = sortOrder;
782 }
783
784 public String getDocId() {
785 return docId;
786 }
787
788 public void setDocId(String docId) {
789 this.docId = docId;
790 }
791
792 public String getMethodToCall() {
793 return methodToCall;
794 }
795
796 public void setMethodToCall(String methodToCall) {
797 this.methodToCall = methodToCall;
798 }
799
800 public FileItem getFile() {
801 return file;
802 }
803
804 public void setFile(FileItem file) {
805 this.file = file;
806 }
807 }
808
809 /**
810 * Method added for notes editing function. Called by retrieveNoteList method
811 * @param allNotes
812 * @param sortOrder
813 * @return
814 */
815
816 private List sortNotes(List allNotes, String sortOrder) {
817 final int returnCode = KewApiConstants.Sorting.SORT_SEQUENCE_DSC.equalsIgnoreCase(sortOrder) ? -1 : 1;
818
819 try {
820 Collections.sort(allNotes,
821 new Comparator() {
822 public int compare(Object o1, Object o2) {
823 Timestamp date1 = ((Note) o1).getNoteCreateDate();
824 Timestamp date2 = ((Note) o2).getNoteCreateDate();
825
826 if (date1.before(date2)) {
827 return returnCode * -1;
828 } else if (date1.after(date2)) {
829 return returnCode;
830 } else {
831 return 0;
832 }
833 }
834 });
835 } catch (Throwable e) {
836 LOG.error(e.getMessage(), e);
837 }
838 return allNotes;
839 }
840
841 /**
842 * Method added for notes editing function. Called by retrieveNoteList method
843 * @param note
844 * @throws Exception
845 */
846
847 private void getAuthorData(Note note) throws Exception {
848 Person workflowUser = null;
849 String id = "";
850 if (note != null && note.getNoteAuthorWorkflowId() != null
851 && !"".equalsIgnoreCase(note.getNoteAuthorWorkflowId())) {
852 workflowUser = KimApiServiceLocator.getPersonService().getPerson(note.getNoteAuthorWorkflowId());
853 id = note.getNoteAuthorWorkflowId();
854 }
855 if (workflowUser != null) {
856 note.setNoteAuthorFullName(workflowUser.getName());
857 note.setNoteAuthorEmailAddress(workflowUser.getEmailAddress());
858 note.setNoteAuthorNetworkId(workflowUser.getPrincipalName());
859 } else {
860 note.setNoteAuthorFullName(id + " (Name not Available)");
861 note.setNoteAuthorEmailAddress("Not Available");
862 note.setNoteAuthorNetworkId("Not Available");
863 }
864 }
865
866 public String getCurrentDate() {
867 Date currentDate = new Date();
868 DateFormat dateFormat = RiceConstants.getDefaultDateFormat();
869 return dateFormat.format(currentDate);
870 }
871
872 /**
873 * Method added for notes editing function.
874 * @return
875 */
876 private NoteService getNoteService() {
877 return (NoteService) KEWServiceLocator.getService(KEWServiceLocator.NOTE_SERVICE);
878 }
879
880 /**
881 * Method added for notes editing function.
882 * @return
883 */
884 private RouteHeaderService getRouteHeaderService() {
885 return (RouteHeaderService) KEWServiceLocator.getService(KEWServiceLocator.DOC_ROUTE_HEADER_SRV);
886 }
887 }