/*

  * Copyright 2005-2008 The Kuali Foundation

  *

  *

  * Licensed under the Educational Community License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.opensource.org/licenses/ecl2.php

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.kuali.rice.kew.edl.components;

 import java.sql.Timestamp;

 import java.text.DateFormat;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.Date;

 import java.util.Iterator;

 import java.util.List;

 import java.util.StringTokenizer;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.transform.Templates;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.xpath.XPath;

 import javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpressionException;

 import javax.xml.xpath.XPathFactory;

 import org.apache.commons.fileupload.FileItem;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

 import org.kuali.rice.core.config.ConfigContext;

 import org.kuali.rice.core.util.RiceConstants;

 import org.kuali.rice.kew.dto.RouteHeaderDTO;

 import org.kuali.rice.kew.edl.EDLContext;

 import org.kuali.rice.kew.edl.EDLModelComponent;

 import org.kuali.rice.kew.edl.EDLXmlUtils;

 import org.kuali.rice.kew.edl.RequestParser;

 import org.kuali.rice.kew.exception.WorkflowRuntimeException;

 import org.kuali.rice.kew.mail.EmailBody;

 import org.kuali.rice.kew.mail.EmailContent;

 import org.kuali.rice.kew.mail.EmailFrom;

 import org.kuali.rice.kew.mail.EmailStyleHelper;

 import org.kuali.rice.kew.mail.EmailSubject;

 import org.kuali.rice.kew.mail.service.impl.EmailBcList;

 import org.kuali.rice.kew.mail.service.impl.EmailCcList;

 import org.kuali.rice.kew.mail.service.impl.EmailToList;

 import org.kuali.rice.kew.notes.Attachment;

 import org.kuali.rice.kew.notes.CustomNoteAttribute;

 import org.kuali.rice.kew.notes.Note;

 import org.kuali.rice.kew.notes.service.NoteService;

 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;

 import org.kuali.rice.kew.routeheader.service.RouteHeaderService;

 import org.kuali.rice.kew.service.KEWServiceLocator;

 import org.kuali.rice.kew.service.WorkflowDocument;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.kew.util.Utilities;

 import org.kuali.rice.kew.util.XmlHelper;

 import org.kuali.rice.kim.bo.Person;

 import org.kuali.rice.kim.service.KIMServiceLocator;

 import org.kuali.rice.kns.service.KNSServiceLocator;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import com.thoughtworks.xstream.XStream;

 /**

  * Adds notes support to EDL

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  *

  */

 public class NoteConfigComponent implements EDLModelComponent {

         private static final Logger LOG = Logger.getLogger(NoteConfigComponent.class);

         private EmailStyleHelper emailStyleHelper = new EmailStyleHelper();

         private String styleName;

         private String from;

         private List<String> to;

         private List<String> cc = new ArrayList<String>();

         private List<String> bc = new ArrayList<String>();

         private static final String DEFAULT_EMAIL_FROM_ADDRESS = KNSServiceLocator.getParameterService().getParameterValue(KEWConstants.KEW_NAMESPACE, "Mailer", "FROM_ADDRESS");//"workflow@indiana.edu";

         public void updateDOM(Document dom, Element configElement, EDLContext edlContext) {

                 NoteForm noteForm = new NoteForm(edlContext.getRequestParser());

                 WorkflowDocument document = (WorkflowDocument)edlContext.getRequestParser().getAttribute(RequestParser.WORKFLOW_DOCUMENT_SESSION_KEY);

                 try {

                         //establish notes depends on a document id being set on noteform or nothing happens

                         if (document != null) {

                                 noteForm.setDocId(document.getRouteHeaderId());

                         }

                         establishNotes(noteForm, edlContext, dom);

                         addNotes(dom, noteForm);

                 } catch (Exception e) {

                         throw new WorkflowRuntimeException("Caught exception processing notes", e);

                 }

         }

         public void establishNotes(NoteForm form, EDLContext edlContext, Document dom) throws Exception {

                 form.setCurrentUserName(edlContext.getUserSession().getPerson().getName());

                 form.setCurrentDate(getCurrentDate());

                 String methodToCall = form.getMethodToCall();

                 if (!Utilities.isEmpty(methodToCall)) {

                         if ("save".equalsIgnoreCase(methodToCall)) {

                                 this.saveNote(form, edlContext, dom);

                         } else if ("edit".equalsIgnoreCase(methodToCall)) {

                                 this.editNote(form);

                         } else if ("add".equalsIgnoreCase(methodToCall)) {

                                 this.addNote(form);

                         } else if ("cancel".equalsIgnoreCase(methodToCall)) {

                                 this.cancelEdit(form);

                         } else if ("delete".equalsIgnoreCase(methodToCall)) {

                                 this.deleteNote(form);

                         } else if ("sort".equalsIgnoreCase(methodToCall)) {

                                 this.sortNotes(form);

                         } else if ("deleteAttachment".equalsIgnoreCase(methodToCall)) {

                                 this.deleteAttachment(form);

                         }

                 }

                 retrieveNoteList(form, edlContext);

         }

     /**

      * Method added for notes editing function. Retrieve Note Listing from Route Header and put that in EdocLiteForm.

      * @param request

      * @param noteForm

      * @throws Exception

      */

     private void retrieveNoteList(NoteForm form, EDLContext edlContext) throws Exception {

         if (form.getDocId() != null) {

             List allNotes = getNoteService().getNotesByRouteHeaderId(form.getDocId());

             CustomNoteAttribute customNoteAttribute = null;

             DocumentRouteHeaderValue routeHeader = getRouteHeaderService().getRouteHeader(form.getDocId());

             boolean canAddNotes = false;

             if (routeHeader != null) {

                 customNoteAttribute = routeHeader.getCustomNoteAttribute();

                 if (customNoteAttribute != null) {

                         customNoteAttribute.setUserSession(edlContext.getUserSession());

                     canAddNotes = customNoteAttribute.isAuthorizedToAddNotes();

                 }

             }

             Iterator notesIter = allNotes.iterator();

             while (notesIter.hasNext()) {

                 Note singleNote = (Note) notesIter.next();

                 singleNote.setNoteCreateLongDate(new Long(singleNote.getNoteCreateDate().getTime()));

                 getAuthorData(singleNote);

                 boolean canEditNote = false;

                 if (customNoteAttribute != null) {

                         canEditNote = customNoteAttribute.isAuthorizedToEditNote(singleNote);

                 }

                     singleNote.setAuthorizedToEdit(Boolean.valueOf(canEditNote));

                 if (form.getNoteIdNumber() != null && (form.getNoteIdNumber().intValue() == singleNote.getNoteId().intValue())) {

                     singleNote.setEditingNote(Boolean.TRUE);

                 }

             }

             if (form.getSortNotes() != null && form.getSortNotes().booleanValue()) {

                 if (KEWConstants.Sorting.SORT_SEQUENCE_DSC.equalsIgnoreCase(form.getSortOrder())) {

                     form.setSortOrder(KEWConstants.Sorting.SORT_SEQUENCE_ASC);

                     form.setSortNotes(Boolean.FALSE);

                 } else {

                     form.setSortOrder(KEWConstants.Sorting.SORT_SEQUENCE_DSC);

                     form.setSortNotes(Boolean.FALSE);

                 }

             } else {

                 form.setSortOrder(form.getSortOrder());

             }

             form.setNoteList(sortNotes(allNotes, form.getSortOrder()));

             form.setNumberOfNotes(new Integer(allNotes.size()));

             form.setAuthorizedToAdd(new Boolean(canAddNotes));

             form.setShowAdd(Boolean.TRUE);

             if (! canAddNotes) {

                 form.setShowAdd(Boolean.FALSE);

             } else if (form.getNoteList().size() == 0) {

                 //form.setShowAdd(Boolean.TRUE);

             }

         }

     }

     public void editNote(NoteForm form) throws Exception {

         form.setShowEdit("yes");

         // Note noteToEdit =

                 // getNoteService().getNoteByNoteId(form.getNoteIdNumber());

         //form.setNote(noteToEdit);

         form.getNote().setNoteCreateLongDate(new Long(form.getNote().getNoteCreateDate().getTime()));

         form.getNote().setNoteText(form.getNoteText());

         //retrieveNoteList(request, form);

     }

     public void addNote(NoteForm form) throws Exception {

             form.setShowEdit("no");

             form.setNoteIdNumber(null);

             form.setShowAdd(Boolean.TRUE);

             //retrieveNoteList(request,form);

     }

     public void cancelEdit(NoteForm form) throws Exception{

             form.setShowEdit("no");

         form.setNote(new Note());

         form.setNoteIdNumber(null);

         //retrieveNoteList(request, form);

     }

     public void deleteNote(NoteForm form) throws Exception{

             Note noteToDelete = getNoteService().getNoteByNoteId(form.getNoteIdNumber());

         getNoteService().deleteNote(noteToDelete);

             form.setShowEdit("no");

         //retrieveNoteList(request, form);

         form.setNote(new Note());

         form.setNoteIdNumber(null);

     }

     public void sortNotes(NoteForm form) throws Exception{

             form.setShowEdit("no");

     }

     public void deleteAttachment(NoteForm form) throws Exception{

             Note note = getNoteService().getNoteByNoteId(form.getNoteIdNumber());

             getNoteService().deleteAttachment((Attachment)note.getAttachments().remove(0));

         }

         public void saveNote(NoteForm form, EDLContext edlContext, Document dom) throws Exception {

         Note noteToSave = null;

         if (form.getShowEdit()!= null && form.getShowEdit().equals("yes")) {

                 //LOG.debug(form.getNoteIdNumber());

             noteToSave = getNoteService().getNoteByNoteId(form.getNoteIdNumber());

             String noteText = form.getNoteText();

             if (noteText != null){

                     noteToSave.setNoteText(noteText);

             }

             //LOG.debug(noteToSave);

             //LOG.debug(noteToSave.getNoteCreateDate());

             //noteToSave.setNoteCreateDate(new Timestamp(noteToSave.getNoteCreateLongDate().longValue()));

         } else {

             noteToSave = new Note();

             noteToSave.setNoteId(null);

             noteToSave.setRouteHeaderId(form.getDocId());

             noteToSave.setNoteCreateDate(new Timestamp((new Date()).getTime()));

             noteToSave.setNoteAuthorWorkflowId(edlContext.getUserSession().getPrincipalId());

             noteToSave.setNoteText(form.getAddText());

         }

         CustomNoteAttribute customNoteAttribute = null;

         DocumentRouteHeaderValue routeHeader = getRouteHeaderService().getRouteHeader(noteToSave.getRouteHeaderId());

         boolean canEditNote = false;

         boolean canAddNotes = false;

         if (routeHeader != null) {

             customNoteAttribute = routeHeader.getCustomNoteAttribute();

             if (customNoteAttribute != null) {

                 customNoteAttribute.setUserSession(edlContext.getUserSession());

                 canAddNotes = customNoteAttribute.isAuthorizedToAddNotes();

                 canEditNote = customNoteAttribute.isAuthorizedToEditNote(noteToSave);

             }

         }

         if ((form.getShowEdit()!=null && form.getShowEdit().equals("yes") && canEditNote) ||

                 ((form.getShowEdit() == null || ! form.getShowEdit().equals("yes")) && canAddNotes)) {

                                 FileItem uploadedFile = (FileItem)form.getFile();

                                 if (uploadedFile != null && org.apache.commons.lang.StringUtils.isNotBlank(uploadedFile.getName())) {

                                         Attachment attachment = new Attachment();

                                         attachment.setAttachedObject(uploadedFile.getInputStream());

                                         String internalFileIndicator=uploadedFile.getName();

                                         int indexOfSlash = internalFileIndicator.lastIndexOf("/");

                                         int indexOfBackSlash=internalFileIndicator.lastIndexOf("\\");

                                         if(indexOfSlash>=0){

                                                 internalFileIndicator=internalFileIndicator.substring(indexOfSlash+1);

                                         }else{

                                                 if (indexOfBackSlash>=0){

                                                         internalFileIndicator=internalFileIndicator.substring(indexOfBackSlash+1);

                                                 }

                                         }

                                         attachment.setFileName(internalFileIndicator);

                                         LOG.debug(internalFileIndicator);

                                         attachment.setMimeType(uploadedFile.getContentType());

                                         attachment.setNote(noteToSave);

                                         noteToSave.getAttachments().add(attachment);

                                 }

                 if(Utilities.isEmpty(noteToSave.getNoteText())&&noteToSave.getAttachments().size()==0){

                         if (form.getShowEdit()!=null && form.getShowEdit().equals("yes")) {

                     form.setNote(new Note());

                 } else {

                     form.setAddText(null);

                 }

                 form.setShowEdit("no");

                 form.setNoteIdNumber(null);

 //                        throw new Exception("Note has empty content");

                 EDLXmlUtils.addGlobalErrorMessage(dom, "Note has empty content");

                 return;

                 }

             getNoteService().saveNote(noteToSave);

             // add ability to send emails when a note is saved. 

             boolean sendEmailOnNoteSave = false;

                         // Check if edoclite specifies <param name="sendEmailOnNoteSave">

                         Document edlDom = KEWServiceLocator.getEDocLiteService()

                                         .getDefinitionXml(edlContext.getEdocLiteAssociation());

                         XPath xpath = XPathFactory.newInstance().newXPath();

                         String xpathExpression = "//config/param[@name='sendEmailOnNoteSave']";

                         try {

                                 String match = (String) xpath.evaluate(xpathExpression, edlDom,        XPathConstants.STRING);

                                 if (!StringUtils.isBlank(match) && match.equals("true")) {

                                         sendEmailOnNoteSave = true;

                                 }

                         } catch (XPathExpressionException e) {

                                 throw new WorkflowRuntimeException(

                                                 "Unable to evaluate sendEmailOnNoteSave xpath expression in NoteConfigComponent saveNote method"

                                                                 + xpathExpression, e);

                         }

                         if (sendEmailOnNoteSave) {

                                 xpathExpression = "//data/version[@current='true']/field[@name='emailTo']/value";

                                 String emailTo = xpath.evaluate(xpathExpression, dom);

                                 if (StringUtils.isBlank(emailTo)) {

                                         EDLXmlUtils.addGlobalErrorMessage(dom,"No email notifications were sent because EmailTo field was empty.");

                                         return;

                                 }

                                 // Actually send the emails.

                                 if (isProduction()) {

                                         this.to = stringToList(emailTo);

                                 } else {

                                         String testAddress = getTestAddress(edlDom);

                                         if (StringUtils.isBlank(testAddress)) {

                                                 EDLXmlUtils.addGlobalErrorMessage(

                                                                                 dom,

                                                                                 "No email notifications were sent because testAddress edl param was empty or not specified in a non production environment");

                                                 return;

                                         }

                                         this.to = stringToList(getTestAddress(edlDom));

         }

                                 if (!isEmailListValid(this.to)) {

                                         EDLXmlUtils.addGlobalErrorMessage(

                                                                         dom,

                                                                         "No email notifications were sent because emailTo field contains invalid email address.");

                                         return;

                                 }

                                 String noteEmailStylesheet = "";

                                 xpathExpression = "//config/param[@name='noteEmailStylesheet']";

                                 try {

                                         noteEmailStylesheet = (String) xpath.evaluate(

                                                         xpathExpression, edlDom, XPathConstants.STRING);

                                         if (StringUtils.isBlank(noteEmailStylesheet)) {

                                                 EDLXmlUtils.addGlobalErrorMessage(

                                                                                 dom,

                                                                                 "No email notifications were sent because noteEmailStylesheet edl param was empty or not specified.");

                                                 return;

                                         }

                                 } catch (XPathExpressionException e) {

                                         throw new WorkflowRuntimeException(

                                                         "Unable to evaluate noteEmailStylesheet xpath expression in NoteConfigComponent method"

                                                                         + xpathExpression, e);

                                 }

                                 this.styleName = noteEmailStylesheet;

                                 this.from = DEFAULT_EMAIL_FROM_ADDRESS;

                                 Document document = generateXmlInput(form, edlContext, edlDom);

                                 if (LOG.isDebugEnabled()) {

                                         LOG.debug("XML input for email tranformation:\n" + XmlHelper.jotNode(document));

                                 }

                                 Templates style = loadStyleSheet(styleName);

                                 EmailContent emailContent = emailStyleHelper

                                                 .generateEmailContent(style, document);

                                 if (!this.to.isEmpty()) {

                                         KEWServiceLocator.getEmailService().sendEmail(

                                                         new EmailFrom(from), new EmailToList(this.to),

                                                         new EmailSubject(emailContent.getSubject()),

                                                         new EmailBody(emailContent.getBody()),

                                                         new EmailCcList(this.cc), new EmailBcList(this.bc),

                                                         emailContent.isHtml());

                                 }

                         }

         }

         if (form.getShowEdit()!=null && form.getShowEdit().equals("yes")) {

             form.setNote(new Note());

         } else {

             form.setAddText(null);

         }

         form.setShowEdit("no");

         form.setNoteIdNumber(null);

     }

          protected String getTestAddress(Document edlDom) {

                         String testAddress = "";

                         XPath xpath = XPathFactory.newInstance().newXPath();

                         String xpathExpression = "//config/param[@name='testAddress']";

                         try {

                             testAddress = (String) xpath.evaluate(xpathExpression, edlDom, XPathConstants.STRING);

                         } catch (XPathExpressionException e) {

                             throw new WorkflowRuntimeException("Unable to evaluate testAddressAttributeFound xpath expression in NoteConfigComponent getTestAddress method" + xpathExpression, e);

                         }

                         return testAddress;

                     }

                     protected Document generateXmlInput(NoteForm form, EDLContext edlContext, Document dom) throws Exception {

                         DocumentBuilder db = getDocumentBuilder(true);

                         Document doc = db.newDocument();

                         Element emailNodeElem = doc.createElement("emailNode");

                         doc.appendChild(emailNodeElem);

                         WorkflowDocument document = (WorkflowDocument)edlContext.getRequestParser().getAttribute(RequestParser.WORKFLOW_DOCUMENT_SESSION_KEY);

                     /* Upgrade Changes 0914 to 1011 */

                         //RouteHeaderVO routeHeaderVO = document.getRouteHeader();

                         RouteHeaderDTO routeHeaderVO = document.getRouteHeader();

                         XStream xstream = new XStream();

                         Element docElem = XmlHelper.readXml(xstream.toXML(routeHeaderVO)).getDocumentElement();

                         emailNodeElem.appendChild(doc.importNode(docElem, true));

                         emailNodeElem.appendChild(doc.importNode(dom.getDocumentElement(), true));

                         Element dConElem = XmlHelper.readXml(document.getDocumentContent().getApplicationContent()).getDocumentElement(); //Add document Content element for

                         emailNodeElem.appendChild(doc.importNode(dConElem, true)); //access by the stylesheet when creating the email

                         return doc;

                     }

                     protected DocumentBuilder getDocumentBuilder(boolean coalesce) throws Exception {

                         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

                         dbf.setCoalescing(coalesce);

                         return dbf.newDocumentBuilder();

                     }

                     /* Upgrade Changes 0914 to 1011 */

                     /*

                     protected boolean isProduction() {

                         return EdenConstants.PROD_DEPLOYMENT_CODE.equalsIgnoreCase(Core.getCurrentContextConfig().getEnvironment());

                     }

                     */

                     protected boolean isProduction() {

                             return ConfigContext.getCurrentContextConfig().getProperty(KEWConstants.PROD_DEPLOYMENT_CODE).equalsIgnoreCase(

                                             ConfigContext.getCurrentContextConfig().getEnvironment());

                     }

                     protected boolean isEmailListValid(List<String> emailList) {

                         Pattern p = Pattern.compile("^\\.|^\\@");

                         Matcher m = null;

                         for (String emailAddress : emailList) {

                             m = p.matcher(emailAddress);

                             if (m.find()) {

                                  //System.err.println("Email addresses don't start with dots or @ signs.");

                                 return false;

                             }

                         }

                         p = Pattern.compile("^www\\.");

                         for (String emailAddress : emailList) {

                             m = p.matcher(emailAddress);

                             if (m.find()) {

                                  //System.err.println("Email addresses don't start with \"www.\", only web pages do.");

                                 return false;

                             }

                         }

                         // find illegal characters.

                         p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");

                         for (String emailAddress : emailList) {

                             // strip comma at end if there is one.

                             String e2 = stripComma(emailAddress);

                             m = p.matcher(e2);

                             if (m.find()) {

                                  //System.err.println("Email address contains illegal character(s).");

                                 return false;

                             }

                         }

                         // email address should match this pattern.

                         p = Pattern.compile("^([a-zA-Z0-9_\\-\\.]+)\\@([a-zA-Z0-9_\\-\\.]+)\\.([a-zA-Z]{2,5})$");

                         for (String emailAddress : emailList) {

                             String e2 = stripComma(emailAddress);

                             m = p.matcher(e2);

                             if (!m.find()) {

                                  //System.err.println("Illegal Email address format.");

                                 return false;

                             }

                         }

                         return true;

                     }

                     protected String stripComma(String s) {

                         String sNew = "";

                         if (s.endsWith(",")) {

                             int x = s.length() -1;

                             sNew = s.substring(0, x);

                         } else {

                             sNew = s;

                         }

                         return sNew;

                     }

                     protected List<String> stringToList(String to) {

                         List<String> recipientAddresses = new ArrayList<String>();

                         StringTokenizer st = new StringTokenizer(to, " ", false);

                              while (st.hasMoreTokens()) {

                                  recipientAddresses.add(st.nextToken());

                              }

                         return recipientAddresses;

                     }

                     protected Templates loadStyleSheet(String styleName) {

                         try {

                             Templates style = KEWServiceLocator.getStyleService().getStyleAsTranslet(styleName);

                             if (style == null) {

                                 throw new WorkflowRuntimeException("Failed to locate stylesheet with name '" + styleName + "'");

                             }

                             return style;

                         } catch (TransformerConfigurationException tce) {

                             throw new WorkflowRuntimeException("Failed to load stylesheet with name '" + styleName + "'");

                         }

                     }

         public static void addNotes(Document doc, NoteForm form) {

                 Element noteForm = EDLXmlUtils.getOrCreateChildElement(doc.getDocumentElement(), "NoteForm", true);

                 if (form.getShowEdit() != null) {

                         Element showEdit = EDLXmlUtils.getOrCreateChildElement(noteForm, "showEdit", true);

                         showEdit.appendChild(doc.createTextNode(form.getShowEdit().toLowerCase()));

                 } else {

                         Element showEdit = EDLXmlUtils.getOrCreateChildElement(noteForm, "showEdit", true);

                         showEdit.appendChild(doc.createTextNode("no"));

                 }

                 if (form.getShowAdd() != null) {

                         Element showAdd = EDLXmlUtils.getOrCreateChildElement(noteForm, "showAdd", true);

                         showAdd.appendChild(doc.createTextNode(form.getShowAdd().toString().toLowerCase()));

                 }

                 if (form.getCurrentUserName() != null) {

                         Element currentUserName = EDLXmlUtils.getOrCreateChildElement(noteForm, "currentUserName", true);

                         currentUserName.appendChild(doc.createTextNode(form.getCurrentUserName()));

                 }

                 if (form.getCurrentDate() != null) {

                         Element currentDate = EDLXmlUtils.getOrCreateChildElement(noteForm, "currentDate", true);

                         currentDate.appendChild(doc.createTextNode(form.getCurrentDate()));

                 }

                 if (form.getNoteIdNumber() != null) {

                         Element noteIdNumber = EDLXmlUtils.getOrCreateChildElement(noteForm, "noteIdNumber", true);

                         noteIdNumber.appendChild(doc.createTextNode(form.getNoteIdNumber().toString()));

                 }

                 if (form.getDocId() != null) {

                         Element docId = EDLXmlUtils.getOrCreateChildElement(noteForm, "docId", true);

                         docId.appendChild(doc.createTextNode((form.getDocId().toString())));

                 }

                 if (form.getSortNotes() != null) {

                         Element sortNotes = EDLXmlUtils.getOrCreateChildElement(noteForm, "sortNotes", true);

                         sortNotes.appendChild(doc.createTextNode(form.getSortNotes().toString().toLowerCase()));

                 }

                 if (form.getSortOrder() != null) {

                         Element sortOrder = EDLXmlUtils.getOrCreateChildElement(noteForm, "sortOrder", true);

                         sortOrder.appendChild(doc.createTextNode(form.getSortOrder().toUpperCase()));

                 }

                 if (form.getNumberOfNotes() != null) {

                         Element numberOfNotes = EDLXmlUtils.getOrCreateChildElement(noteForm, "numberOfNotes", true);

                         numberOfNotes.appendChild(doc.createTextNode(form.getNumberOfNotes().toString()));

                 }

                 if (form.getAuthorizedToAdd() != null) {

                         Element authorizedToAdd = EDLXmlUtils.getOrCreateChildElement(noteForm, "authorizedToAdd", true);

                         authorizedToAdd.appendChild(doc.createTextNode(form.getAuthorizedToAdd().toString().toLowerCase()));

                 }

                 if (form.getNumberOfNotes().intValue() > 0) {

                         Element notes = EDLXmlUtils.getOrCreateChildElement(noteForm, "Notes", true);

                         for (Iterator i = form.getNoteList().iterator(); i.hasNext();) {

                                 Note noteObj = (Note) i.next();

                                 Element note = notes.getOwnerDocument().createElement("Note");

                                 notes.appendChild(note);

                                 // Element note = Util.getOrCreateChildElement(notes, "Note",

                                 // true);

                                 if (noteObj.getNoteId() != null) {

                                         Element noteId = EDLXmlUtils.getOrCreateChildElement(note, "noteId", true);

                                         noteId.appendChild(doc.createTextNode(noteObj.getNoteId().toString()));

                                 }

                                 if (noteObj.getFormattedCreateDate() != null) {

                                         Element formattedCreateDate = EDLXmlUtils.getOrCreateChildElement(note, "formattedCreateDate", true);

                                         formattedCreateDate.appendChild(doc.createTextNode(noteObj.getFormattedCreateDate()));

                                 }

                                 if (noteObj.getFormattedCreateTime() != null) {

                                         Element formattedCreateTime = EDLXmlUtils.getOrCreateChildElement(note, "formattedCreateTime", true);

                                         formattedCreateTime.appendChild(doc.createTextNode(noteObj.getFormattedCreateTime()));

                                 }

                                 if (noteObj.getNoteAuthorFullName() != null) {

                                         Element noteAuthorFullName = EDLXmlUtils.getOrCreateChildElement(note, "noteAuthorFullName", true);

                                         noteAuthorFullName.appendChild(doc.createTextNode(noteObj.getNoteAuthorFullName()));

                                 }

                                 if (noteObj.getNoteText() != null) {

                                         Element noteText = EDLXmlUtils.getOrCreateChildElement(note, "noteText", true);

                                         noteText.appendChild(doc.createTextNode(noteObj.getNoteText()));

                                 }

                                 if (noteObj.getEditingNote() != null) {

                                         Element editingNote = EDLXmlUtils.getOrCreateChildElement(note, "editingNote", true);

                                         editingNote.appendChild(doc.createTextNode(noteObj.getEditingNote().toString()));

                                 }

                                 if (noteObj.getAuthorizedToEdit() != null) {

                                         Element authorizedToEdit = EDLXmlUtils.getOrCreateChildElement(note, "authorizedToEdit", true);

                                         authorizedToEdit.appendChild(doc.createTextNode(noteObj.getAuthorizedToEdit().toString()));

                                 }

                                 if (!noteObj.getAttachments().isEmpty()) {

                                         Element attachments = EDLXmlUtils.getOrCreateChildElement(note, "attachments", true);

                                         for (Iterator j = noteObj.getAttachments().iterator(); j.hasNext();) {

                                                 Attachment attachmentObj = (Attachment) j.next();

                                                 Element attachment = EDLXmlUtils.getOrCreateChildElement(attachments, "attachment", true);

                                                 Element attachmentId = EDLXmlUtils.getOrCreateChildElement(attachment, "attachmentId", true);

                                                 attachmentId.appendChild(doc.createTextNode(attachmentObj.getAttachmentId().toString()));

                                                 Element fileName = EDLXmlUtils.getOrCreateChildElement(attachment, "fileName", true);

                                                 fileName.appendChild(doc.createTextNode(attachmentObj.getFileName()));

                                         }

                                 }

                         }

                 }

         }

         private static class NoteForm {

                 private String showEdit;

                 private Boolean showAdd;

                 private Long noteIdNumber;

                 private Integer numberOfNotes = new Integer(0);

                 private String sortOrder = "DESCENDING";

                 private Boolean sortNotes;

                 private String currentUserName;

                 private String currentDate;

                 private Boolean authorizedToAdd;

                 private List noteList;

                 private String addText;

                 private Long idInEdit;

                 private Note note;

                 private String noteText;

                 private Long docId;

                 private String methodToCall;

                 private FileItem file;

                 public NoteForm(RequestParser requestParser) {

                         showEdit = requestParser.getParameterValue("showEdit");

                         if (!Utilities.isEmpty(requestParser.getParameterValue("showAdd"))) {

                                 showAdd = Boolean.valueOf(requestParser.getParameterValue("showAdd"));

                         }

                         if (!Utilities.isEmpty(requestParser.getParameterValue("noteIdNumber"))) {

                                 noteIdNumber = Long.valueOf(requestParser.getParameterValue("noteIdNumber"));

                         }

                         methodToCall = requestParser.getParameterValue("methodToCall");

                         sortOrder = "DESCENDING";

                         if (!Utilities.isEmpty(requestParser.getParameterValue("sortNotes"))) {

                                 sortNotes = Boolean.valueOf(requestParser.getParameterValue("sortNotes"));

                         }

                         addText = requestParser.getParameterValue("addText");

                         noteText = requestParser.getParameterValue("noteText");

                         if (!Utilities.isEmpty(requestParser.getParameterValue("idInEdit"))) {

                                 idInEdit = Long.valueOf(requestParser.getParameterValue("idInEdit"));

                         }

                         if (noteIdNumber != null) {

                                 note = KEWServiceLocator.getNoteService().getNoteByNoteId(noteIdNumber);

                         }

                         if (requestParser.getUploadList() != null && ! requestParser.getUploadList().isEmpty()) {

                                 file = (FileItem)requestParser.getUploadList().get(0);

                         }

                 }

                 public String getAddText() {

                         return addText;

                 }

                 public void setAddText(String addText) {

                         this.addText = addText;

                 }

                 public Boolean getAuthorizedToAdd() {

                         return authorizedToAdd;

                 }

                 public void setAuthorizedToAdd(Boolean authorizedToAdd) {

                         this.authorizedToAdd = authorizedToAdd;

                 }

                 public String getCurrentDate() {

                         return currentDate;

                 }

                 public void setCurrentDate(String currentDate) {

                         this.currentDate = currentDate;

                 }

                 public String getCurrentUserName() {

                         return currentUserName;

                 }

                 public void setCurrentUserName(String currentUserName) {

                         this.currentUserName = currentUserName;

                 }

                 public Long getIdInEdit() {

                         return idInEdit;

                 }

                 public void setIdInEdit(Long idInEdit) {

                         this.idInEdit = idInEdit;

                 }

                 public Note getNote() {

                         return note;

                 }

                 public void setNote(Note note) {

                         this.note = note;

                 }

                 public Long getNoteIdNumber() {

                         return noteIdNumber;

                 }

                 public void setNoteIdNumber(Long noteIdNumber) {

                         this.noteIdNumber = noteIdNumber;

                 }

                 public List getNoteList() {

                         return noteList;

                 }

                 public void setNoteList(List noteList) {

                         this.noteList = noteList;

                 }

                 public String getNoteText() {

                         return noteText;

                 }

                 public void setNoteText(String noteText) {

                         this.noteText = noteText;

                 }

                 public Integer getNumberOfNotes() {

                         return numberOfNotes;

                 }

                 public void setNumberOfNotes(Integer numberOfNotes) {

                         this.numberOfNotes = numberOfNotes;

                 }

                 public Boolean getShowAdd() {

                         return showAdd;

                 }

                 public void setShowAdd(Boolean showAdd) {

                         this.showAdd = showAdd;

                 }

                 public String getShowEdit() {

                         return showEdit;

                 }

                 public void setShowEdit(String showEdit) {

                         this.showEdit = showEdit;

                 }

                 public Boolean getSortNotes() {

                         return sortNotes;

                 }

                 public void setSortNotes(Boolean sortNotes) {

                         this.sortNotes = sortNotes;

                 }

                 public String getSortOrder() {

                         return sortOrder;

                 }

                 public void setSortOrder(String sortOrder) {

                         this.sortOrder = sortOrder;

                 }

                 public Long getDocId() {

                         return docId;

                 }

                 public void setDocId(Long docId) {

                         this.docId = docId;

                 }

                 public String getMethodToCall() {

                         return methodToCall;

                 }

                 public void setMethodToCall(String methodToCall) {

                         this.methodToCall = methodToCall;

                 }

                 public FileItem getFile() {

                         return file;

                 }

                 public void setFile(FileItem file) {

                         this.file = file;

                 }

         }

     /**

      * Method added for notes editing function. Called by retrieveNoteList method

      * @param allNotes

      * @param sortOrder

      * @return

      */

     private List sortNotes(List allNotes, String sortOrder) {

         final int returnCode = KEWConstants.Sorting.SORT_SEQUENCE_DSC.equalsIgnoreCase(sortOrder) ? -1 : 1;

         try {

           Collections.sort(allNotes,

           new Comparator() {

             public int compare(Object o1, Object o2) {

                           Timestamp date1 = ((Note) o1).getNoteCreateDate();

                           Timestamp date2 = ((Note) o2).getNoteCreateDate();

                 if (date1.before(date2)) {

                   return returnCode * -1;

                 } else if (date1.after(date2)) {

                   return returnCode;

                 } else {

                   return 0;

                 }

             }

           });

       } catch (Throwable e) {

         LOG.error(e.getMessage(), e);

       }

       return allNotes;

     }

     /**

      * Method added for notes editing function. Called by retrieveNoteList method

      * @param note

      * @throws Exception

      */

     private void getAuthorData(Note note) throws Exception {

             Person workflowUser = null;

             String id = "";

             if (note != null && note.getNoteAuthorWorkflowId() != null && ! "".equalsIgnoreCase(note.getNoteAuthorWorkflowId())) {

                 workflowUser = KIMServiceLocator.getPersonService().getPerson(note.getNoteAuthorWorkflowId());

                 id = note.getNoteAuthorWorkflowId();

             }

             if (workflowUser != null) {

                 note.setNoteAuthorFullName(workflowUser.getName());

                 note.setNoteAuthorEmailAddress(workflowUser.getEmailAddress());

                 note.setNoteAuthorNetworkId(workflowUser.getPrincipalName());

             } else {

                 note.setNoteAuthorFullName(id + " (Name not Available)");

                 note.setNoteAuthorEmailAddress("Not Available");

                 note.setNoteAuthorNetworkId("Not Available");

             }

         }

         public String getCurrentDate() {

         Date currentDate = new Date();

         DateFormat dateFormat = RiceConstants.getDefaultDateFormat();

         return dateFormat.format(currentDate);

     }

         /**

          * Method added for notes editing function.

          * @return

          */

     private NoteService getNoteService() {

                 return (NoteService) KEWServiceLocator.getService(KEWServiceLocator.NOTE_SERVICE);

         }

     /**

      * Method added for notes editing function.

      * @return

      */

     private RouteHeaderService getRouteHeaderService() {

                 return (RouteHeaderService) KEWServiceLocator.getService(KEWServiceLocator.DOC_ROUTE_HEADER_SRV);

         }

 }