|
1
315 package com.ivata.groupware.business.mail;
316
317 import java.io.ByteArrayOutputStream  ;
318 import java.io.File ;
319 import java.io.IOException ;
320 import java.io.InputStream ;
321 import java.io.Serializable ;
322 import java.text.MessageFormat ;
323 import java.util.Arrays ;
324 import java.util.Calendar ;
325 import java.util.Collection ;
326 import java.util.Date ;
327 import java.util.GregorianCalendar ;
328 import java.util.Iterator ;
329 import java.util.List ;
330 import java.util.Set ;
331 import java.util.TreeMap ;
332 import java.util.Vector ;
333
334 import javax.activation.DataHandler ;
335 import javax.activation.DataSource ;
336 import javax.activation.FileDataSource ;
337 import javax.mail.Address ;
338 import javax.mail.AuthenticationFailedException ;
339 import javax.mail.Flags ;
340 import javax.mail.Folder ;
341 import javax.mail.FolderNotFoundException ;
342 import javax.mail.Message ;
343 import javax.mail.MessagingException ;
344 import javax.mail.NoSuchProviderException ;
345 import javax.mail.Part ;
346 import javax.mail.Session ;
347 import javax.mail.Store ;
348 import javax.mail.Transport ;
349 import javax.mail.internet.AddressException ;
350 import javax.mail.internet.InternetAddress ;
351 import javax.mail.internet.MimeBodyPart ;
352 import javax.mail.internet.MimeMessage ;
353 import javax.mail.internet.MimeMultipart ;
354 import javax.mail.internet.MimePart ;
355
356 import org.apache.log4j.Logger;
357
358 import com.ivata.groupware.admin.security.server.SecurityServer;
359 import com.ivata.groupware.admin.security.server.SecurityServerException;
360 import com.ivata.groupware.admin.security.server.SecuritySession;
361 import com.ivata.groupware.admin.security.user.UserDO;
362 import com.ivata.groupware.admin.setting.Settings;
363 import com.ivata.groupware.admin.setting.SettingsDataTypeException;
364 import com.ivata.groupware.business.addressbook.AddressBook;
365 import com.ivata.groupware.business.addressbook.person.PersonDO;
366 import com.ivata.groupware.business.addressbook.telecomaddress.TelecomAddressConstants;
367 import com.ivata.groupware.business.addressbook.telecomaddress.TelecomAddressDO;
368 import com.ivata.groupware.business.drive.file.FileContentDO;
369 import com.ivata.groupware.business.drive.file.FileDO;
370 import com.ivata.groupware.business.mail.message.MessageDO;
371 import com.ivata.groupware.business.mail.message.MessageNotFoundException;
372 import com.ivata.groupware.business.mail.server.MailServer;
373 import com.ivata.groupware.business.mail.server.NoMailServerException;
374 import com.ivata.groupware.business.mail.session.MailSession;
375 import com.ivata.groupware.util.SettingDateFormatter;
376 import com.ivata.groupware.web.format.EmailAddressFormatter;
377 import com.ivata.groupware.web.format.SanitizerFormat;
378 import com.ivata.mask.Mask;
379 import com.ivata.mask.MaskFactory;
380 import com.ivata.mask.util.SerializedByteArray;
381 import com.ivata.mask.util.StringHandling;
382 import com.ivata.mask.util.SystemException;
383 import com.ivata.mask.validation.ValidationError;
384 import com.ivata.mask.validation.ValidationErrors;
385 import com.ivata.mask.web.format.CharacterEntityFormat;
386 import com.ivata.mask.web.format.FormatConstants;
387 import com.ivata.mask.web.format.HTMLFormatter;
388 import com.ivata.mask.web.format.LineBreakFormat;
389 import com.ivata.mask.web.tag.webgui.list.ListColumnComparator;
390
391
392
403 public class MailImpl implements Mail, Serializable {
404
408 private class MessageTextParts {
409 public MimeBodyPart HTMLPart = null;
410 public MimeBodyPart textPart = null;
411 }
412
413
416 private static Logger logger = Logger.getLogger(MailImpl.class);
417 private AddressBook addressBook;
418 private SettingDateFormatter dateFormatter = null;
419 private MailServer mailServer;
420 MaskFactory maskFactory;
421
426 private Settings settings;
427
428
429
444 public MailImpl(SecurityServer securityServer,
445 AddressBook addressBook,
446 Settings settings,
447 MaskFactory maskFactory) {
448 assert (securityServer != null);
449 if (securityServer instanceof MailServer) {
450 this.mailServer = (MailServer) securityServer;
451 } else {
452 logger.warn("Security server class ("
453 + securityServer.getClass().getName()
454 + ") is not a mail server class.");
455 }
456 this.settings = settings;
457 this.addressBook = addressBook;
458 this.maskFactory = maskFactory;
459 }
460 private void checkDateFormatter(SecuritySession securitySession) {
461 if (dateFormatter == null) {
462 dateFormatter = new SettingDateFormatter(securitySession,
463 settings);
464 }
465 }
466
476 public MessageDO addMessageToDraftsFolder(final MailSession mailSession,
477 final MessageDO messageDO) throws SystemException {
478 checkDateFormatter(mailSession);
479
480 Store store = mailServer.connectStore(mailSession);
481 try {
482 Session javaMailSession;
483 try {
484 javaMailSession = mailSession.getJavaMailSession();
485 } catch (java.security.NoSuchProviderException e1) {
486 throw new SystemException(e1);
487 }
488
489 Folder draftsFolder = openDraftsFolder(store, mailSession);
491
492 MimeMessage newMessage = setDOToJavaMailMessage(javaMailSession,
493 draftsFolder, messageDO);
494
495 newMessage.setSentDate(Calendar.getInstance().getTime());
496
497 Message [] messages = { newMessage };
499
500 draftsFolder.appendMessages(messages);
501
502 messageDO.setMessageID(((MimeMessage ) draftsFolder.getMessage(
504 draftsFolder.getMessageCount())).getMessageID());
505
506 draftsFolder.expunge();
508 draftsFolder.close(true);
509 } catch (MessagingException e1) {
510 throw new SystemException(e1);
511 } finally {
512 try {
513 store.close();
514 } catch (MessagingException e) {
515 logger.error("Messaging exception on closing the store", e);
516 }
517 }
518
519 return messageDO;
520 }
521
522
531 private void addMultiPart(final Part messagePart,
532 final MessageDO messageDO)
533 throws SystemException {
534 String outputText = "";
535 MimeMultipart content;
536 MimeBodyPart subPart;
537
538 List messageTextParts = new Vector ();
539
540 try {
541 content = (MimeMultipart ) messagePart.getContent();
542
543 for (int i = 0; i < content.getCount(); i++) {
545 subPart = (MimeBodyPart ) content.getBodyPart(i);
546
547 if (messagePart.isMimeType("multipart/alternative") &&
550 subPart.isMimeType("text/*") &&
551 StringHandling.isNullOrEmpty(messageDO.getText())) {
552 messageTextParts.add(subPart);
553 } else if (messagePart.isMimeType("multipart/*")) {
554 if (StringHandling.isNullOrEmpty(messageDO.getText()) &&
556 (subPart.getDisposition() == null) &&
557 (subPart.getFileName() == null)) {
558 if (subPart.isMimeType("text/*")) {
559 messageTextParts.add(subPart);
560 } else if (subPart.isMimeType("multipart/*")) {
561 addMultiPart((Part ) subPart, messageDO);
562 } else {
563 addPart(subPart, messageDO);
564 }
565 } else {
566 if (subPart.isMimeType("multipart/*")) {
567 addMultiPart((Part ) subPart, messageDO);
568 } else {
569 addPart(subPart, messageDO);
570 }
571 }
572 }
573 }
574
575 if (!messageTextParts.isEmpty()) {
577 String HTML = null;
578 String text = null;
579
580 for (Iterator i = messageTextParts.iterator(); i.hasNext();) {
582 subPart = (MimeBodyPart ) i.next();
583
584 if (subPart.isMimeType("text/HTML")) {
585 HTML = (String ) subPart.getContent();
586 } else if (subPart.isMimeType("text/plain")) {
587 text = (String ) subPart.getContent();
588 }
589 }
591
592 if (HTML != null) {
593 messageDO.setText(HTML);
594 messageDO.setFormat(FormatConstants.FORMAT_HTML);
595 } else if (text != null) {
596 messageDO.setText(text);
597 messageDO.setFormat(FormatConstants.FORMAT_TEXT);
598 }
599 }
600 } catch (MessagingException e) {
601 throw new SystemException(e);
602 } catch (java.io.IOException e) {
603 throw new SystemException(e);
604 }
605 }
606
607
616 private void addPart(final MimePart part,
617 final MessageDO messageDO)
618 throws SystemException {
619 FileDO attachment = new FileDO();
620
621 try {
622 attachment.setMimeType(part.getContentType());
623 attachment.setSize(new Integer (part.getSize()));
624
625 String contentId = part.getContentID();
626 String name = part.getFileName();
627
628 if ((contentId == null) && (name == null)) {
631 return;
632 }
633
634 attachment.setName((contentId != null) ? contentId : name);
636 attachment.setComment((name != null) ? name : contentId);
637 } catch (MessagingException e) {
638 throw new SystemException(e);
639 }
640
641 messageDO.getAttachments().add(attachment);
642 }
643
644
648 private void addToSentFolder(final MailSession mailSession,
649 final MimeMessage message)
650 throws SystemException {
651 Folder sentFolder;
652
653 Store store = mailServer.connectStore(mailSession);
654 try {
655 String sentFolderName = settings.getStringSetting(
656 mailSession,
657 "emailFolderSent",
658 mailSession.getUser());
659 sentFolder = mailServer.getFolder(mailSession, store, sentFolderName);
660
661 if (!sentFolder.exists()) {
662 try {
663 if (!sentFolder.create(Folder.HOLDS_MESSAGES)) {
664 throw new SystemException(
665 "There was no sent folder for you on this server, "
666 + "and ivata mail could not create one.<br>Please "
667 + "contact your administrator.");
668 }
669 } catch (MessagingException e1) {
670 throw new SystemException(e1);
671 }
672 }
673
674 Message [] messages = { message };
675
676 try {
677 sentFolder.appendMessages(messages);
678 } catch (MessagingException eAppend) {
679 throw new SystemException(
680 "There was an error adding your message to the sent "
681 + "messages folder: " +
682 eAppend.getMessage(),
683 eAppend);
684 }
685 } catch (MessagingException eNoSent) {
686 throw new SystemException("Sent folder not available in store. " +
687 eNoSent.getMessage(),
688 eNoSent);
689 } catch (SettingsDataTypeException e) {
690 throw new SystemException(e);
691 } finally {
692 try {
693 store.close();
694 } catch (MessagingException e) {
695 logger.error("Messaging exception on closing the store", e);
696 }
697 }
698 }
699
700
715 public void addUserAliasEmailAddresses(final SecuritySession securitySession,
716 final String userName,
717 final Collection userAliases,
718 final Collection telecomAddresses,
719 final String emailAddressHost)
720 throws SystemException {
721 checkDateFormatter(securitySession);
722 Iterator telecomAddressIterator = telecomAddresses.iterator();
723 List currentAddresses = new Vector ();
724 while (telecomAddressIterator.hasNext()) {
725 TelecomAddressDO thisTelecomAddress = (TelecomAddressDO)
726 telecomAddressIterator.next();
727 if (!StringHandling.isNullOrEmpty(thisTelecomAddress.getAddress())
728 && (thisTelecomAddress.getType() == TelecomAddressConstants.TYPE_EMAIL)) {
729 currentAddresses.add(thisTelecomAddress.getAddress());
730 }
731 }
732
733 if ((currentAddresses.size() == 0)
740 && (userAliases.size() == 0)) {
741 userAliases.add(userName);
742 }
743
744 Iterator aliasIterator = userAliases.iterator();
746 while(aliasIterator.hasNext()) {
747 String alias = (String ) aliasIterator.next();
748 String aliasAddress = alias + "@" + emailAddressHost;
749 if (currentAddresses.contains(aliasAddress)) {
751 continue;
752 }
753 TelecomAddressDO newAddress = new TelecomAddressDO();
754 newAddress.setAddress(aliasAddress);
755 newAddress.setType(TelecomAddressConstants.TYPE_EMAIL);
756 newAddress.setNumber(telecomAddresses.size());
757 telecomAddresses.add(newAddress);
758 }
759 }
760
761
778 public MessageDO appendAttachments(final MailSession mailSession,
779 final String id,
780 final List attachments) throws SystemException {
781 checkDateFormatter(mailSession);
782 String newId = null;
783 UserDO user = mailSession.getUser();
784 Store store = mailServer.connectStore(mailSession);
785
786 try {
787 String siteHome = settings.getStringSetting(mailSession,
788 "siteHome", user);
789 String uploadDirectory = siteHome + "/users/" +
790 mailSession.authenticator.getPasswordAuthentication()
791 .getUserName() + "/upload/files/";
792
793 Session javaMailSession;
794
795 try {
796 javaMailSession = mailSession.getJavaMailSession();
797 } catch (SecurityServerException e) {
798 throw new SystemException(e);
799 } catch (java.security.NoSuchProviderException e) {
800 throw new SystemException(e);
801 }
802
803 Folder draftsFolder = openDraftsFolder(store, mailSession);
804 MimeMessage oldMessage = findJavaMailMessageByFolderMessageId(draftsFolder,
805 id);
806 int i;
807 MimeBodyPart newPart;
808 MimeMultipart newMessageContent = new MimeMultipart ();
809 MimeMultipart oldMessageContent;
810 MimeMessage newMessage = copyJavaMailMessage(javaMailSession,
811 oldMessage);
812
813 if (oldMessage.isMimeType("multipart/mixed")) {
815 oldMessageContent = (MimeMultipart ) oldMessage.getContent();
816
817 for (i = 0; i < oldMessageContent.getCount(); i++) {
818 newPart = (MimeBodyPart ) oldMessageContent.getBodyPart(i);
819 newMessageContent.addBodyPart(newPart);
820 }
821 } else {
822 newPart = new MimeBodyPart ();
824 newPart.setContent(oldMessage.getContent(),
825 oldMessage.getContentType());
826 newPart.setHeader("Content-Type", oldMessage.getContentType());
827 newMessageContent.addBodyPart(newPart);
828 }
829
830 for (Iterator attachmentsIterator = attachments.iterator();
832 attachmentsIterator.hasNext();) {
833 File attachment = new File (uploadDirectory,
834 (String ) attachmentsIterator.next());
835
836 if (attachment.canRead()) {
838 newPart = new MimeBodyPart ();
839 newPart.setFileName(attachment.getName());
840 newPart.setDisposition(Part.ATTACHMENT);
841
842 DataSource dataSource = new FileDataSource (attachment);
843 newPart.setDataHandler(new DataHandler (dataSource));
844 newPart.setHeader("Content-Type",
845 dataSource.getContentType());
846 newPart.setHeader("Content-Transfer-Encoding", "base64");
847 newMessageContent.addBodyPart(newPart);
848 }
849 }
850
851 newMessage.setContent(newMessageContent);
852 newMessage.setHeader("Content-Type",
853 newMessageContent.getContentType());
854
855 Message [] messages = { newMessage };
857
858 draftsFolder.appendMessages(messages);
859
860 newId = ((MimeMessage ) draftsFolder.getMessage(draftsFolder.getMessageCount())).getMessageID();
862
863 oldMessage.setFlag(Flags.Flag.DELETED, true);
865 draftsFolder.expunge();
866
867 for (Iterator attachmentsIterator = attachments.iterator();
869 attachmentsIterator.hasNext();) {
870 File attachment = new File (uploadDirectory,
871 (String ) attachmentsIterator.next());
872
873 if (attachment.canWrite()) {
874 attachment.delete();
875 }
876 }
877
878 MessageDO returnDO = getDOFromJavaMailMessage(
880 findJavaMailMessageByFolderMessageId(
881 draftsFolder, newId), true);
882 draftsFolder.close(true);
883 return returnDO;
884 } catch (MessagingException em) {
885 throw new SystemException(em);
886 } catch (IOException eio) {
887 throw new SystemException(eio);
888 } finally {
889 try {
890 store.close();
891 } catch (MessagingException e) {
892 logger.error("Messaging exception on closing the store", e);
893 }
894 }
895 }
896
897
904 private void checkMailServer() throws SystemException {
905 if (mailServer == null) {
906 logger.warn("No mail server found.");
907 throw new NoMailServerException();
908 }
909 }
910
911
924 private InternetAddress [] convertAddresses(final SecuritySession securitySession,
925 final Collection addresses)
926 throws SystemException {
927 InternetAddress [] returnAddresses = new InternetAddress [addresses.size()];
928
929 if (addresses == null) {
931 return returnAddresses;
932 }
933
934 int index = 0;
935
936 for (Iterator i = addresses.iterator(); i.hasNext();) {
937 Object item = i.next();
938 String addressString = null;
939
940 if (PersonDO.class.isInstance(item)) {
941 PersonDO person = (PersonDO) item;
942
943 addressString = person.getEmailAddress();
944 } else if (UserDO.class.isInstance(item)) {
945 UserDO user = (UserDO) item;
946 PersonDO person = addressBook.findPersonByUserName(securitySession,
947 user.getName());
948
949 if (user.isEnabled()) {
951 addressString = person.getEmailAddress();
952 }
953 } else {
954 if (!String .class.isInstance(item)) {
955 throw new SystemException("Cannot convert item of class '" +
956 item.getClass() + "' into an email address.");
957 }
958
959 addressString = (String ) item;
960 }
961
962 if (!StringHandling.isNullOrEmpty(addressString)) {
964 try {
965 returnAddresses[index++] = new InternetAddress (addressString);
966 } catch (AddressException eAddress) {
967 throw new SystemException(
968 "ERROR in MailBean: cannot convert internet address '"
969 + addressString
970 + "': "
971 + eAddress.getMessage(),
972 eAddress);
973 }
974 }
975 }
976
977 return returnAddresses;
978 }
979
980
993 private MimeMessage copyJavaMailMessage(final Session javaMailSession,
994 final MimeMessage message)
995 throws SystemException {
996 MimeMessage newMessage = new MimeMessage (javaMailSession);
997
998 try {
999 newMessage.setRecipients(Message.RecipientType.TO,
1000 message.getRecipients(Message.RecipientType.TO));
1001 newMessage.setRecipients(Message.RecipientType.CC,
1002 message.getRecipients(Message.RecipientType.CC));
1003 newMessage.setRecipients(Message.RecipientType.BCC,
1004 message.getRecipients(Message.RecipientType.BCC));
1005 newMessage.addFrom(message.getFrom());
1006 newMessage.setSubject(message.getSubject());
1007 } catch (MessagingException e) {
1008 throw new SystemException(e);
1009 }
1010
1011 return newMessage;
1012 }
1013
1014
1025 private MessageDO createDOFromJavaMailMessage(final MimeMessage message,
1026 final boolean includeContent)
1027 throws SystemException {
1028 MessageDO messageDO = new MessageDO();
1030 try {
1031 if (message.getFolder() != null) {
1033 messageDO.setFolderName(message.getFolder().getName());
1034 }
1035
1036 if (message.getReceivedDate() != null) {
1037 GregorianCalendar receivedDate = new GregorianCalendar ();
1038
1039 receivedDate.setTime(message.getReceivedDate());
1040 messageDO.setReceived(receivedDate);
1041 }
1042
1043 if (message.getRecipients(Message.RecipientType.TO) != null) {
1044 messageDO.setRecipients(Arrays.asList(toStringArray(
1045 message.getRecipients(Message.RecipientType.TO))));
1046 }
1047
1048 if (message.getRecipients(Message.RecipientType.CC) != null) {
1049 messageDO.setRecipientsCC(Arrays.asList(toStringArray(
1050 message.getRecipients(Message.RecipientType.CC))));
1051 }
1052
1053 if (message.getRecipients(Message.RecipientType.BCC) != null) {
1054 messageDO.setRecipientsBCC(Arrays.asList(toStringArray(
1055 message.getRecipients(Message.RecipientType.BCC))));
1056 }
1057
1058 if (message.getFrom() != null) {
1059 messageDO.setSenders(Arrays.asList(toStringArray(
1060 message.getFrom())));
1061 }
1062
1063 if (message.getSentDate() != null) {
1064 GregorianCalendar sentDate = new GregorianCalendar ();
1065
1066 sentDate.setTime(message.getSentDate());
1067 messageDO.setSent(sentDate);
1068 }
1069
1070 messageDO.setSize(new Integer (message.getSize()));
1071 messageDO.setSubject(message.getSubject());
1072
1073 if (includeContent) {
1075 Integer format;
1076 String text;
1077
1078 messageDO.setAttachments(new Vector ());
1080
1081 if (message.isMimeType("multipart/*")) {
1084 addMultiPart(message, messageDO);
1085
1086 } else if (message.isMimeType("text/*") ||
1088 message.isMimeType("message/*")) {
1089 if (message.isMimeType("text/HTML")) {
1091 messageDO.setFormat(FormatConstants.FORMAT_HTML);
1093 } else {
1094 messageDO.setFormat(FormatConstants.FORMAT_TEXT);
1096 }
1097
1098 messageDO.setText((String ) message.getContent());
1099
1100 } else {
1102 messageDO.setFormat(FormatConstants.FORMAT_TEXT);
1103 messageDO.setText("");
1104 addPart(message, messageDO);
1105 }
1106 }
1107 messageDO.setMessageID(message.getMessageID());
1108 } catch (MessagingException e) {
1109 throw new SystemException(e);
1110 } catch (IOException e) {
1111 throw new SystemException(e);
1112 }
1113
1114 return messageDO;
1115 }
1116
1117
1127 public void createFolder(final MailSession mailSession,
1128 final String folderName)
1129 throws SystemException {
1130 assert (mailSession != null);
1131 checkDateFormatter(mailSession);
1132
1133 Session javaMailSession;
1134
1135 try {
1136 javaMailSession = mailSession.getJavaMailSession();
1137 } catch (AuthenticationFailedException e) {
1138 throw new SystemException(
1139 "User is no longer authorized to use this server: " +
1140 e.getMessage(),
1141 e);
1142 } catch (MessagingException e) {
1143 throw new SystemException(e);
1144 } catch (SecurityServerException e) {
1145 throw new SystemException(e);
1146 } catch (java.security.NoSuchProviderException e) {
1147 throw new SystemException(e);
1148 }
1149
1150 Store store = mailServer.connectStore(mailSession);
1151 try {
1152 if (folderName == null) {
1153 throw new SystemException(
1154 "ERROR in MailBean.createFolder: folderName is null");
1155 }
1156
1157 Folder folder = mailServer.getFolder(mailSession, store, folderName);
1158
1159 if (!folder.create(Folder.HOLDS_MESSAGES)) {
1160 throw new SystemException(
1161 "ERROR in MailBean.createFolder: could not create folder '" +
1162 folderName + "'");
1163 }
1164 } catch (MessagingException e) {
1165 throw new SystemException(e);
1166 } finally {
1167 try {
1168 store.close();
1169 } catch (MessagingException e) {
1170 logger.error("Messaging exception on closing the store", e);
1171 }
1172 }
1173 }
1174
1175
1176
1196 private MimeMessage createForwardedMessage(final MailSession mailSession,
1197 final Folder folder,
1198 final List messageIds)
1199 throws SystemException {
1200 checkDateFormatter(mailSession);
1201 try {
1202 Session javaMailSession;
1203 try {
1204 javaMailSession = mailSession.getJavaMailSession();
1205 } catch (java.security.NoSuchProviderException e1) {
1206 throw new SystemException(e1);
1207 }
1208 UserDO user = mailSession.getUser();
1209
1210 MessageTextParts messageTextParts = null;
1212
1213 boolean isMultipart = false;
1216 int format = FormatConstants.FORMAT_TEXT;
1217
1218 for (Iterator i = messageIds.iterator(); i.hasNext();) {
1219 String id = (String ) i.next();
1220 MimeMessage oldMessage = findJavaMailMessageByFolderMessageId(folder,
1221 id);
1222
1223 if (oldMessage.isMimeType("multipart/*")) {
1225 isMultipart = true;
1226
1227 messageTextParts = getMultiPartText(oldMessage);
1229
1230 if (messageTextParts.HTMLPart != null) {
1231 format = FormatConstants.FORMAT_HTML;
1232
1233 break;
1235 }
1236 }
1237 }
1238
1239 String messageHeader;
1241
1242 if (format == FormatConstants.FORMAT_HTML) {
1243 messageHeader = settings.getStringSetting(mailSession,
1244 "emailHeaderForwardHTML",
1245 user);
1246 } else {
1247 messageHeader = settings.getStringSetting(mailSession,
1248 "emailHeaderForwardText",
1249 user);
1250 }
1251
1252 MimeMessage newMessage = new MimeMessage (javaMailSession);
1253 StringBuffer subject = new StringBuffer ();
1254 String subjectPrefix = settings.getStringSetting(mailSession,
1255 "emailSubjectForwardPrefix",
1256 user);
1257 String subjectSeperator = settings.getStringSetting(mailSession,
1258 "emailSubjectForwardSeperator",
1259 user);
1260
1261 subject.append(subjectPrefix);
1262
1263 StringBuffer messageText = new StringBuffer ();
1264
1265 CharacterEntityFormat characterEntities = new CharacterEntityFormat();
1267
1268 int index = 0;
1270
1271 for (Iterator i = messageIds.iterator(); i.hasNext(); ++index) {
1272 String id = (String ) i.next();
1273 MimeMessage oldMessage = findJavaMailMessageByFolderMessageId(folder,
1274 id);
1275
1276 String oldSubject = StringHandling.getNotNull(oldMessage.getSubject(),
1278 getNullString());
1279
1280 if ((subjectPrefix != null) &&
1283 (oldSubject.startsWith(subjectPrefix))) {
1284 oldSubject = oldSubject.substring(subjectPrefix.length());
1285 }
1286
1287 if ((index > 0) && !oldSubject.equals("")) {
1290 subject.append(subjectSeperator);
1291 }
1292
1293 subject.append(oldSubject);
1294
1295 String oldMessageText = null;
1297 int oldFormat = FormatConstants.FORMAT_TEXT;
1298
1299 if (oldMessage.isMimeType("multipart/*")) {
1300 if (messageTextParts.HTMLPart != null) {
1302 oldMessageText = (String ) messageTextParts.HTMLPart.getContent();
1303 oldFormat = FormatConstants.FORMAT_HTML;
1304 } else if (messageTextParts.textPart != null) {
1305 oldMessageText = (String ) messageTextParts.textPart.getContent();
1306 }
1307 } else {
1308 oldMessageText = (String ) oldMessage.getContent();
1309 }
1310
1311 if ((oldMessageText != null) && (messageHeader != null)) {
1313 messageText.append(formatMessageHeader(messageHeader,
1314 oldMessage));
1315 }
1316
1317 if (oldMessageText != null) {
1318 if ((format == FormatConstants.FORMAT_HTML) &&
1320 !(oldFormat == FormatConstants.FORMAT_HTML)) {
1321 messageText.append("<pre>\n");
1322 oldMessageText = characterEntities.format(oldMessageText);
1323 }
1324
1325 messageText.append(oldMessageText);
1326
1327 if ((format == FormatConstants.FORMAT_HTML) &&
1328 !(oldFormat == FormatConstants.FORMAT_HTML)) {
1329 messageText.append("\n</pre>\n");
1330 }
1331 }
1332 }
1333
1334 if (format == FormatConstants.FORMAT_HTML) {
1335 MimeMultipart newTextContent = createHTMLContent(messageText.toString());
1338
1339 newMessage.setContent(newTextContent);
1341 newMessage.setHeader("Content-Type",
1342 newTextContent.getContentType());
1343
1344 } else {
1346 newMessage.setContent(messageText.toString(), "text/plain");
1347 }
1348
1349 return newMessage;
1350 } catch (MessagingException e) {
1351 throw new SystemException(e);
1352 } catch (IOException e) {
1353 throw new SystemException(e);
1354 }
1355 }
1356
1357
1366 private MimeMultipart createHTMLContent(final String hTMLText)
1367 throws MessagingException {
1368 MimeMultipart newTextContent = new MimeMultipart ("alternative");
1370
1371 MimeBodyPart mimePart = new MimeBodyPart ();
1373 SanitizerFormat sanitizer = new SanitizerFormat();
1374
1375 sanitizer.setSourceName("user input");
1376 sanitizer.setTextOnly(true);
1377 mimePart.setContent(sanitizer.format(hTMLText), "text/plain");
1378 mimePart.setHeader("Content-Type", "text/plain");
1379 newTextContent.addBodyPart(mimePart);
1380
1381 mimePart = new MimeBodyPart ();
1385 sanitizer.setTextOnly(false);
1386 mimePart.setContent(sanitizer.format(hTMLText), "text/HTML");
1387 mimePart.setHeader("Content-Type", "text/HTML");
1388 newTextContent.addBodyPart(mimePart);
1389
1390 return newTextContent;
1391 }
1392
1393
1413 private MimeMessage createReplyMessage(final MailSession mailSession,
1414 final Folder folder,
1415 final String id,
1416 final Integer thread)
1417 throws SystemException {
1418 try {
1419 UserDO user = mailSession.getUser();
1420 Session javaMailSession;
1421 try {
1422 javaMailSession = mailSession.getJavaMailSession();
1423 } catch (java.security.NoSuchProviderException e) {
1424 throw new SystemException(e);
1425 }
1426
1427 MimeMessage oldMessage = this.findJavaMailMessageByFolderMessageId(folder,
1428 id);
1429
1430 MessageTextParts messageTextParts = null;
1432
1433 StringBuffer subject = new StringBuffer ();
1435 String subjectPrefix = null;
1436
1437 StringBuffer messageText = new StringBuffer ();
1439 String oldMessageText = null;
1440 String messageHeader = null;
1441
1442 HTMLFormatter formatter = new HTMLFormatter();
1444
1445 MimeMessage newMessage = (MimeMessage ) oldMessage.reply(MailConstants.THREAD_REPLY_ALL.equals(
1447 thread));
1448
1449 LineBreakFormat lineBreaks = new LineBreakFormat();
1452
1453 lineBreaks.setPrepend(settings.getStringSetting(mailSession,
1454 "emailReplyIndent",
1455 user));
1456 formatter.add(lineBreaks);
1457
1458 subjectPrefix = settings.getStringSetting(mailSession,
1460 "emailSubjectReplyPrefix",
1461 user);
1462
1463 if (oldMessage.isMimeType("multipart/*")) {
1466 messageHeader = settings.getStringSetting(mailSession,
1467 "emailHeaderReplyHTML",
1468 user);
1469 messageTextParts = getMultiPartText(oldMessage);
1470 } else {
1471 messageHeader = settings.getStringSetting(mailSession,
1472 "emailHeaderReplyText",
1473 user);
1474 }
1475
1476 String oldSubject = StringHandling.getNotNull(oldMessage.getSubject(),
1478 getNullString());
1479
1480 if ((subjectPrefix != null) &&
1481 (!oldSubject.startsWith(subjectPrefix))) {
1482 subject.append(subjectPrefix);
1483 }
1484
1485 subject.append(oldSubject);
1486 newMessage.setSubject(subject.toString());
1487
1488 int format = FormatConstants.FORMAT_TEXT;
1490
1491 if (oldMessage.isMimeType("multipart/*")) {
1492 if (messageTextParts.HTMLPart != null) {
1494 oldMessageText = (String ) messageTextParts.HTMLPart.getContent();
1495 format = FormatConstants.FORMAT_HTML;
1496 } else if (messageTextParts.textPart != null) {
1497 oldMessageText = (String ) messageTextParts.textPart.getContent();
1498 }
1499 } else {
1500 oldMessageText = (String ) oldMessage.getContent();
1501 }
1502
1503 if ((oldMessageText != null) && (messageHeader != null)) {
1505 messageText.append(formatMessageHeader(messageHeader, oldMessage));
1506 }
1507
1508 if (oldMessageText != null) {
1509 messageText.append(oldMessageText);
1510 }
1511
1512 if (format == FormatConstants.FORMAT_HTML) {
1513 MimeMultipart newTextContent = createHTMLContent(messageText.toString());
1516
1517 newMessage.setContent(newTextContent);
1519 newMessage.setHeader("Content-Type",
1520 newTextContent.getContentType());
1521
1522 } else {
1524 newMessage.setContent(messageText.toString(), "text/plain");
1525 }
1526
1527 return newMessage;
1528 } catch (MessagingException e) {
1529 throw new SystemException(e);
1530 } catch (IOException e) {
1531 throw new SystemException(e);
1532 }
1533 }
1534
1535
1565 public MessageDO createThreadMessage(final MailSession mailSession,
1566 final String folderName,
1567 final List messageIds,
1568 final Integer thread)
1569 throws SystemException {
1570 checkDateFormatter(mailSession);
1571 MimeMessage newMessage = null;
1572 MessageDO messageDO = null;
1573 Session javaMailSession;
1574
1575 try {
1576 javaMailSession = mailSession.getJavaMailSession();
1577 } catch (AuthenticationFailedException e) {
1578 throw new SystemException(
1579 "User is no longer authorized to use this server: " +
1580 e.getMessage(),
1581 e);
1582 } catch (MessagingException e) {
1583 throw new SystemException(e);
1584 } catch (java.security.NoSuchProviderException e) {
1585 throw new SystemException(e);
1586 }
1587
1588 Store store = mailServer.connectStore(mailSession);
1589 try {
1590 if ((folderName == null) || (messageIds == null) ||
1592 (messageIds.size() == 0) || (thread == null)) {
1593 throw new SystemException(
1594 "ERROR in MailBean.createThreadMessage: these parameters cannot be empty:" +
1595 " folderName (specified: '" + folderName +
1596 "') messageIds (specified: '" + messageIds +
1597 "') thread (specified: '" + thread + "').");
1598 }
1599
1600 if ((messageIds.size() > 1) &&
1602 !MailConstants.THREAD_FORWARD.equals(thread)) {
1603 throw new SystemException("ERROR in MailBean: too many messages (" +
1604 messageIds.size() +
1605 ") in thread. Only 'forward' can have multiple messages.");
1606 }
1607
1608 Folder folder = mailServer.getFolder(mailSession, store, folderName);
1610
1611 folder.open(Folder.READ_ONLY);
1612
1613 if (MailConstants.THREAD_FORWARD.equals(thread)) {
1614 newMessage = createForwardedMessage(mailSession, folder,
1615 messageIds);
1616 } else {
1617 String messageId = (String ) messageIds.get(0);
1618
1619 if (MailConstants.THREAD_DRAFT.equals(thread)) {
1620 MimeMessage oldMessage = this.findJavaMailMessageByFolderMessageId(folder,
1621 messageId);
1622 newMessage = new MimeMessage (oldMessage);
1623 } else {
1624 newMessage = createReplyMessage(mailSession, folder,
1625 messageId, thread);
1626 }
1627 }
1628
1629 Folder draftsFolder = openDraftsFolder(store, mailSession);
1631
1632 messageDO = getDOFromJavaMailMessage(newMessage, true);
1633
1634 Message [] messages = { newMessage };
1635
1636 draftsFolder.appendMessages(messages);
1637 messageDO.setFolderName(draftsFolder.getName());
1638 draftsFolder.close(true);
1639 folder.close(false);
1640 } catch (MessagingException e) {
1641 throw new SystemException(e);
1642 } finally {
1643 try {
1644 store.close();
1645 } catch (MessagingException e) {
1646 logger.error("Messaging exception on closing the store", e);
1647 }
1648 }
1649
1650 return messageDO;
1651 }
1652
1653
1666 public void deleteMessagesFromTrash(final MailSession mailSession,
1667 final List ids)
1668 throws SystemException {
1669 checkDateFormatter(mailSession);
1670 Store store = mailServer.connectStore(mailSession);
1671 try {
1672 UserDO user = mailSession.getUser();
1673 Session javaMailSession;
1674 try {
1675 javaMailSession = mailSession.getJavaMailSession();
1676 } catch (java.security.NoSuchProviderException e) {
1677 throw new SystemException(e);
1678 }
1679 Folder trashFolder = mailServer.getFolder(mailSession, store,
1680 settings.getStringSetting(
1681 mailSession,
1682 "emailFolderTrash",
1683 user));
1684
1685 trashFolder.open(Folder.READ_WRITE);
1686
1687 for (Iterator i = ids.iterator(); i.hasNext();) {
1689 String id = (String ) i.next();
1690 MimeMessage message = findJavaMailMessageByFolderMessageId(trashFolder,
1691 id);
1692
1693 message.setFlag(Flags.Flag.DELETED, true);
1694 }
1695
1696 trashFolder.expunge();
1697 trashFolder.close(true);
1698 } catch (MessagingException e) {
1699 throw new SystemException(e);
1700 } finally {
1701 try {
1702 store.close();
1703 } catch (MessagingException e) {
1704 logger.error("Messaging exception on closing the store", e);
1705 }
1706 }
1707 }
1708
1709
1720 public boolean doesFolderExist(final MailSession mailSession,
1721 final String folderName)
1722 throws SystemException {
1723 assert (mailSession != null);
1724 checkDateFormatter(mailSession);
1725
1726 Session javaMailSession = null;
1727
1728 try {
1729 javaMailSession = mailSession.getJavaMailSession();
1730 } catch (AuthenticationFailedException e) {
1731 throw new SystemException(
1732 "User is no longer authorized to use this server: " +
1733 e.getMessage(),
1734 e);
1735 } catch (MessagingException e) {
1736 throw new SystemException(e);
1737 } catch (SecurityServerException e) {
1738 throw new SystemException(e);
1739 } catch (java.security.NoSuchProviderException e) {
1740 throw new SystemException(e);
1741 }
1742
1743 boolean folderExists = false;
1744
1745 Store store = mailServer.connectStore(mailSession);
1746 try {
1747 if (folderName == null) {
1748 throw new SystemException(
1749 "ERROR in MailBean.doesFolderExist: folderName is null");
1750 }
1751
1752 Folder folder = mailServer.getFolder(mailSession, store, folderName);
1753
1754 folderExists = folder.exists();
1755 } catch (MessagingException e) {
1756 throw new SystemException(e);
1757 } finally {
1758 try {
1759 store.close();
1760 } catch (MessagingException e) {
1761 logger.error("Messaging exception on closing the store", e);
1762 }
1763 }
1764
1765 return folderExists;
1766 }
1767
1768
1779 private MimeMessage findJavaMailMessageByFolderMessageId(final Folder folder,
1780 final String id) throws SystemException {
1781 MimeMessage message = null;
1782
1783 String folderName = (folder == null) ? "[none]" : folder.getName();
1785
1786 try {
1787 if (StringHandling.isNullOrEmpty(id)) {
1789 throw new MessageNotFoundException(folderName, id,
1790 "you must specify a valid message id");
1791 } else if (folder == null) {
1792 throw new MessageNotFoundException(folderName, id,
1793 "you must specify a valid folder");
1794 } else if (!folder.exists()) {
1795 throw new MessageNotFoundException(folderName, id,
1796 folderName + " does not exist");
1797 } else if (!folder.isOpen()) {
1798 throw new MessageNotFoundException(folderName, id,
1799 folderName + " is not open");
1800 }
1801
1802 for (int messageNumber = 1;
1805 messageNumber <= folder.getMessageCount();
1806 ++messageNumber) {
1807 MimeMessage messageTest = (MimeMessage ) folder.getMessage(messageNumber);
1808
1809 if (id.equals(messageTest.getMessageID())) {
1810 message = messageTest;
1811
1812 break;
1813 }
1814 }
1815 } catch (FolderNotFoundException e) {
1816 throw new MessageNotFoundException(folderName, id,
1817 "FolderNotFoundException looking for " + folderName + ": " +
1818 e.getMessage(),
1819 e);
1820 } catch (MessagingException e) {
1821 throw new SystemException(e);
1822 }
1823
1824 return message;
1825 }
1826
1827
1843 public MessageDO findMessageByFolderMessageId(final MailSession mailSession,
1844 final String folderName,
1845 final String id) throws SystemException {
1846 checkDateFormatter(mailSession);
1847 MessageDO messageDO = null;
1848
1849 Store store = mailServer.connectStore(mailSession);
1850 try {
1851 if (folderName == null) {
1852 logger.error(
1853 "MailBean.findMessageByFolderMessageId(): "
1854 + "folderName is null.");
1855 return null;
1856 }
1857 Folder folder = mailServer.getFolder(mailSession, store, folderName);
1859
1860 folder.open(Folder.READ_ONLY);
1862
1863 MimeMessage message = findJavaMailMessageByFolderMessageId(folder,
1864 id);
1865
1866 if (message != null) {
1868 messageDO = getDOFromJavaMailMessage(message, true);
1869 }
1870
1871 folder.close(false);
1872 } catch (MessagingException e) {
1873 throw new SystemException(e);
1874 } finally {
1875 try {
1876 store.close();
1877 } catch (MessagingException e) {
1878 logger.error("Messaging exception on closing the store", e);
1879 }
1880 }
1881
1882 return messageDO;
1883 }
1884
1885
1908 public List findMessagesInFolder(final MailSession mailSession,
1909 final String folderName,
1910 final Integer sortBy,
1911 final boolean sortAscending)
1912 throws SystemException {
1913 checkDateFormatter(mailSession);
1914 UserDO user = mailSession.getUser();
1915 MessageDO messageDO;
1916 Message [] messages;
1917 int i;
1918
1919 Session javaMailSession;
1921
1922 ListColumnComparator comparator = new ListColumnComparator(sortAscending);
1924 TreeMap map = new TreeMap (comparator);
1925
1926 comparator.setSortNumerically(MailConstants.SORT_RECEIVED.equals(sortBy)
1928 || MailConstants.SORT_SENT.equals(sortBy)
1929 || MailConstants.SORT_SIZE.equals(sortBy));
1930
1931 try {
1932 javaMailSession = mailSession.getJavaMailSession();
1933 } catch (MessagingException e) {
1934 throw new SystemException(e);
1935 } catch (java.security.NoSuchProviderException e) {
1936 throw new SystemException(e);
1937 }
1938
1939 Store store = mailServer.connectStore(mailSession);
1940 try {
1941 Folder folderProcessed =
1942 mailServer.getFolder(mailSession, store, folderName);
1943
1944 String sentKey;
1946 StringBuffer key = new StringBuffer (32);
1947 GregorianCalendar received;
1948 GregorianCalendar sent;
1949
1950 String inboxFolderName = settings.getStringSetting(mailSession,
1954 "emailFolderInbox",
1955 user);
1956
1957 if (folderName.equalsIgnoreCase(inboxFolderName)) {
1958 folderProcessed.open(Folder.READ_WRITE);
1959 messages = folderProcessed.getMessages();
1960
1961 int length = messages.length;
1962
1963 for (i = 0; i < length; i++) {
1964 MimeMessage message = (MimeMessage ) messages[i];
1965
1966 String messageId = message.getMessageID();
1968
1969 if ((messageId == null) ||
1970 (messageId.indexOf("ivata-") == -1)) {
1971 MessageDO newMessage = createDOFromJavaMailMessage(message, true);
1973 Integer newId = newMessage.getId();
1974
1975 if (messageId == null) {
1976 messageId = "";
1977 }
1978
1979 messageId += ("ivata-" + newId);
1980
1981 MimeMessage ivataMessage = new MimeMessage (message);
1982
1983 ivataMessage.setHeader("Message-ID", messageId);
1984 message.setFlag(Flags.Flag.DELETED, true);
1985
1986 Message [] ivataMessages = { ivataMessage };
1987
1988 folderProcessed.appendMessages(ivataMessages);
1989 }
1990 }
1991
1992 folderProcessed.close(true);
1994 }
1995
1996 folderProcessed.open(Folder.READ_ONLY);
2000 messages = folderProcessed.getMessages();
2001
2002 for (i = 0; i < messages.length; i++) {
2003 MimeMessage message = (MimeMessage ) messages[i];
2004
2005 messageDO = getDOFromJavaMailMessage(message, false);
2006 sent = messageDO.getSent();
2007 sentKey = ((sent == null) ? ""
2008 : new Long (sent.getTime().getTime()).toString());
2009 key.delete(0, key.capacity());
2010
2011 if (MailConstants.SORT_FOLDER.equals(sortBy)) {
2013 key.append(StringHandling.getNotNull(
2014 messageDO.getFolderName()));
2015 } else if (MailConstants.SORT_ID.equals(sortBy)) {
2016 key.append(StringHandling.getNotNull(messageDO.getMessageID()));
2017 } else if (MailConstants.SORT_RECEIVED.equals(sortBy)) {
2018 received = messageDO.getReceived();
2019 key.append(((received == null) ? ""
2020 : new Long (
2021 received.getTime().getTime()).toString()));
2022 } else if (MailConstants.SORT_RECIPIENTS.equals(sortBy)) {
2023 key.append(StringHandling.getNotNull(
2024 messageDO.getRecipients()));
2025 } else if (MailConstants.SORT_RECIPIENTS_BCC.equals(sortBy)) {
2026 key.append(StringHandling.getNotNull(
2027 messageDO.getRecipientsBCC()));
2028 } else if (MailConstants.SORT_RECIPIENTS_CC.equals(sortBy)) {
2029 key.append(StringHandling.getNotNull(
2030 messageDO.getRecipientsCC()));
2031 } else if (MailConstants.SORT_SENDERS.equals(sortBy)) {
2032 key.append(StringHandling.getNotNull(messageDO.getSenders()));
2033 } else if (MailConstants.SORT_SIZE.equals(sortBy)) {
2034 key.append(StringHandling.getNotNull(messageDO.getSize()));
2035 } else if (!MailConstants.SORT_SENT.equals(sortBy)) {
2036 key.append(StringHandling.getNotNull(messageDO.getSubject()));
2038 }
2039
2040 key.append(sentKey);
2042 map.put(key.toString(), messageDO);
2043 }
2044 } catch (NoSuchProviderException e) {
2045 throw new SystemException(e);
2046 } catch (MessagingException e) {
2047 throw new SystemException(e);
2048 } catch (SettingsDataTypeException e) {
2049 throw new SystemException(e);
2050 } finally {
2051 try {
2052 store.close();
2053 } catch (MessagingException e) {
2054 logger.error("Messaging exception on closing the store", e);
2055 }
2056 }
2057
2058 return new Vector (map.values());
2059 }
2060
2061
2068 private String formatMessageHeader(final String messageHeader,
2069 final MimeMessage oldMessage)
2070 throws SystemException {
2071 Date date;
2072 String oldSentDate;
2073 String oldSubject;
2074
2075 try {
2076 date = oldMessage.getSentDate();
2077 oldSubject = StringHandling.getNotNull(oldMessage.getSubject(),
2078 getNullString());
2079 } catch (MessagingException e) {
2080 throw new SystemException(e);
2081 }
2082
2083 if (date == null) {
2084 oldSentDate = "";
2085 } else {
2086 oldSentDate = dateFormatter.format(date);
2087 }
2088
2089 EmailAddressFormatter emailFormatter = new EmailAddressFormatter();
2090
2091 try {
2092 String oldSenders = StringHandling.getNotNull(emailFormatter.format(
2095 oldMessage.getFrom()), getNullString());
2096 String oldRecipients = StringHandling.getNotNull(emailFormatter.format(
2097 oldMessage.getRecipients(MimeMessage.RecipientType.TO)),
2098 getNullString());
2099 Object [] arguments = {
2100 oldSenders, oldRecipients, oldSubject, oldSentDate
2101 };
2102
2103 return MessageFormat.format(messageHeader, arguments);
2104 } catch (MessagingException e) {
2105 throw new SystemException(e);
2106 }
2107 }
2108
2109
2126 public final FileContentDO getAttachment(final MailSession mailSession,
2127 final String folderName,
2128 final String messageId,
2129 final String attachmentId)
2130 throws SystemException {
2131 checkDateFormatter(mailSession);
2132 FileContentDO attachmentDO = null;
2133
2134 Store store = mailServer.connectStore(mailSession);
2135 try {
2136 Folder folder = mailServer.getFolder(mailSession, store, folderName);
2138
2139 folder.open(Folder.READ_ONLY);
2141
2142 Message message = findJavaMailMessageByFolderMessageId(folder,
2143 messageId);
2144 InputStream inStream = null;
2145 String mimeType = null;
2146
2147 if (message.isMimeType("multipart/*")) {
2150 MimeMultipart multiMessage = (MimeMultipart ) message.getContent();
2151 MimeBodyPart subPart = getAttachment(multiMessage, attachmentId);
2152 inStream = subPart.getInputStream();
2153 mimeType = subPart.getContentType();
2154 } else {
2155 String withOutAngels = attachmentId.substring(1,
2156 attachmentId.length() - 1);
2157
2158 if (((message.getFileName() != null) &
2159 attachmentId.equals(message.getFileName())) ||
2160 ((message.getFileName() != null) &
2161 withOutAngels.equals(message.getFileName()))) {
2162 inStream = message.getInputStream();
2163 mimeType = message.getContentType();
2164 }
2165 }
2166
2167 if ((inStream != null) && (mimeType != null)) {
2168 int oneByte;
2169
2170 ByteArrayOutputStream outStream = new ByteArrayOutputStream ();
2171
2172 while ((oneByte = inStream.read()) != -1) {
2173 outStream.write(oneByte);
2174 }
2175
2176 attachmentDO = new FileContentDO(new SerializedByteArray(
2177 outStream.toByteArray()), mimeType);
2178 }
2179
2180 folder.close(false);
2181 } catch (MessagingException e) {
2182 throw new SystemException(e);
2183 } catch (IOException e) {
2184 throw new SystemException(e);
2185 } finally {
2186 try {
2187 store.close();
2188 } catch (MessagingException e) {
2189 logger.error("Messaging exception on closing the store", e);
2190 }
2191 }
2192
2193 return attachmentDO;
2194 }
2195
2196
2206 private MimeBodyPart getAttachment(final MimeMultipart multiPart,
2207 final String attachmentId) throws MessagingException , IOException {
2208 MimeBodyPart attachment = (MimeBodyPart ) multiPart.getBodyPart(attachmentId);
2209
2210 if (attachment == null) {
2212 MimeBodyPart embeddedPart;
2213
2214 for (int i = 0; i < multiPart.getCount(); i++) {
2215 embeddedPart = (MimeBodyPart ) multiPart.getBodyPart(i);
2216
2217 if (embeddedPart.isMimeType("multipart/*")) {
2219 if ((attachment = getAttachment(
2221 (MimeMultipart ) embeddedPart.getContent(),
2222 attachmentId)) != null) {
2223 break;
2224 }
2225 } else if ((embeddedPart.getFileName() != null) &&
2226 (attachmentId.indexOf(embeddedPart.getFileName()) != -1)) {
2227 attachment = embeddedPart;
2228
2229 break;
2230 }
2231 }
2232 }
2233
2234 return attachment;
2235 }
2236
2237
2248 private MessageDO getDOFromJavaMailMessage(final MimeMessage message,
2249 final boolean includeContent)
2250 throws SystemException {
2251 MessageDO messageDO = new MessageDO();
2254 try {
2255 if (message.getFolder() != null) {
2257 messageDO.setFolderName(message.getFolder().getName());
2258 }
2259
2260 if (message.getReceivedDate() != null) {
2261 GregorianCalendar receivedDate = new GregorianCalendar ();
2262
2263 receivedDate.setTime(message.getReceivedDate());
2264 messageDO.setReceived(receivedDate);
2265 }
2266
2267 if (message.getRecipients(Message.RecipientType.TO) != null) {
2268 messageDO.setRecipients(Arrays.asList(toStringArray(
2269 message.getRecipients(Message.RecipientType.TO))));
2270 }
2271
2272 if (message.getRecipients(Message.RecipientType.CC) != null) {
2273 messageDO.setRecipientsCC(Arrays.asList(toStringArray(
2274 message.getRecipients(Message.RecipientType.CC))));
2275 }
2276
2277 if (message.getRecipients(Message.RecipientType.BCC) != null) {
2278 messageDO.setRecipientsBCC(Arrays.asList(toStringArray(
2279 message.getRecipients(Message.RecipientType.BCC))));
2280 }
2281
2282 if (message.getFrom() != null) {
2283 messageDO.setSenders(Arrays.asList(toStringArray(
2284 message.getFrom())));
2285 }
2286
2287 if (message.getSentDate() != null) {
2288 GregorianCalendar sentDate = new GregorianCalendar ();
2289
2290 sentDate.setTime(message.getSentDate());
2291 messageDO.setSent(sentDate);
2292 }
2293
2294 messageDO.setSize(new Integer (message.getSize()));
2295 messageDO.setSubject(message.getSubject());
2296
2297 if (includeContent) {
2299 Integer format;
2300 String text;
2301
2302 messageDO.setAttachments(new Vector ());
2304
2305 if (message.isMimeType("multipart/*")) {
2308 addMultiPart(message, messageDO);
2309
2310 } else if (message.isMimeType("text/*") ||
2312 message.isMimeType("message/*")) {
2313 if (message.isMimeType("text/HTML")) {
2315 messageDO.setFormat(FormatConstants.FORMAT_HTML);
2317 } else {
2318 messageDO.setFormat(FormatConstants.FORMAT_TEXT);
2320 }
2321
2322 messageDO.setText((String ) message.getContent());
2323
2324 } else {
2326 messageDO.setFormat(FormatConstants.FORMAT_TEXT);
2327 messageDO.setText("");
2328 addPart(message, messageDO);
2329 }
2330 }
2331 messageDO.setMessageID(message.getMessageID());
2332 } catch (MessagingException e) {
2333 throw new SystemException(e);
2334 } catch (IOException e) {
2335 throw new SystemException(e);
2336 }
2337
2338 return messageDO;
2339 }
2340
2341
2349 private MessageTextParts getMultiPartText(final Part message)
2350 throws SystemException {
2351 MessageTextParts messageTextParts = new MessageTextParts();
2352 MimeMultipart content;
2353 MimeBodyPart subPart;
2354 int i;
2355
2356 try {
2357 content = (MimeMultipart ) message.getContent();
2358
2359 for (i = 0; i < content.getCount(); i++) {
2361 subPart = (MimeBodyPart ) content.getBodyPart(i);
2362
2363 if (message.isMimeType("multipart/alternative")) {
2365 if (subPart.isMimeType("text/plain") &&
2366 (messageTextParts.textPart == null)) {
2367 messageTextParts.textPart = subPart;
2368 } else if (subPart.isMimeType("text/HTML") &&
2369 (messageTextParts.HTMLPart == null)) {
2370 messageTextParts.HTMLPart = subPart;
2371
2372 if (messageTextParts.textPart != null) {
2375 break;
2376 }
2377 }
2378 } else {
2379 if (subPart.isMimeType("multipart/*")) {
2381 messageTextParts = getMultiPartText((Part ) subPart);
2382
2383 } else if (subPart.isMimeType("text/plain") &&
2386 (messageTextParts.textPart == null)) {
2387 messageTextParts.textPart = subPart;
2388 } else if (subPart.isMimeType("text/HTML") &&
2389 (messageTextParts.HTMLPart == null)) {
2390 messageTextParts.HTMLPart = subPart;
2391
2392 break;
2393 }
2394 }
2395 }
2396 } catch (MessagingException e) {
2397 throw new SystemException(e);
2398 } catch (java.io.IOException e) {
2399 throw new SystemException(e);
2400 }
2401
2402 return messageTextParts;
2403 }
2404
2405
2410 private String getNullString() {
2411 return "[none]";
2413 }
2414
2415
2425 public List getUserAliases(final SecuritySession securitySession,
2426 final String userName)
2427 throws SystemException {
2428 checkMailServer();
2429 checkDateFormatter(securitySession);
2430
2431 List aliases = null;
2432 aliases = mailServer.getUserAliases(securitySession, userName);
2433
2434 return aliases;
2435 }
2436
2437
2447 public final String getVacationMessage(final SecuritySession securitySession,
2448 final String userName)
2449 throws SystemException {
2450 checkMailServer();
2451 checkDateFormatter(securitySession);
2452
2453 String vacationMessage = null;
2454 vacationMessage = mailServer.getVacationMessage(securitySession,
2455 userName);
2456
2457 return vacationMessage;
2458 }
2459
2460
2473 public final boolean hasNewMessages(final SecuritySession securitySession,
2474 final String userName,
2475 final String folderName)
2476 throws SystemException {
2477 checkMailServer();
2478 if (userName == null) {
2479 throw new SystemException(
2480 "ERROR in MailBean.getFolderModified: userName is null.");
2481 }
2482
2483 if (folderName == null) {
2484 throw new SystemException(
2485 "ERROR in MailBean.getFolderModified: folderName is null.");
2486 }
2487
2488 return mailServer.hasNewMessages(securitySession,
2489 userName, folderName);
2490 }
2491
2492
2505 public MailSession login(final UserDO user,
2506 final String password)
2507 throws SystemException {
2508 checkMailServer();
2509 return (MailSession) mailServer.login(user, password);
2510 }
2511
2512
2528 public void moveMessages(final MailSession mailSession,
2529 final String folderName,
2530 final List ids,
2531 final String targetFolderName) throws SystemException {
2532 Store store = mailServer.connectStore(mailSession);
2533 checkDateFormatter(mailSession);
2534 try {
2535 Folder folder = mailServer.getFolder(mailSession, store, folderName);
2536
2537 folder.open(Folder.READ_WRITE);
2538
2539 Folder targetFolder =
2540 mailServer.getFolder(mailSession, store, targetFolderName);
2541
2542 if (!targetFolder.exists()) {
2543 targetFolder.create(Folder.HOLDS_MESSAGES);
2544 }
2545
2546 targetFolder.open(Folder.READ_WRITE);
2547
2548 List messages = new Vector ();
2549
2550 for (Iterator i = ids.iterator(); i.hasNext();) {
2551 String id = (String ) i.next();
2552 MimeMessage message = findJavaMailMessageByFolderMessageId(folder,
2553 id);
2554
2555 if (message == null) {
2556 logger.error(
2557 "MailBean.moveMessage:I couldn't find a message with id"
2558 + id
2559 + " in folder '"
2560 + folder.getName()
2561 + "'");
2562 } else {
2563 messages.add(message);
2564 }
2565 }
2566
2567 if (!messages.isEmpty()) {
2568 Message [] messageArray = { };
2569
2570 messageArray = (Message []) messages.toArray(messageArray);
2571 targetFolder.appendMessages(messageArray);
2572 targetFolder.close(false);
2573
2574 for (Iterator i = messages.iterator(); i.hasNext();) {
2576 Message message = (Message ) i.next();
2577
2578 message.setFlag(Flags.Flag.DELETED, true);
2579 }
2580 }
2581
2582 folder.expunge();
2583 folder.close(true);
2584 } catch (NoSuchProviderException e) {
2585 throw new SystemException(e);
2586 } catch (MessagingException e) {
2587 throw new SystemException(e);
2588 } finally {
2589 try {
2590 store.close();
2591 } catch (MessagingException e) {
2592 logger.error("Messaging exception on closing the store", e);
2593 }
2594 }
2595 }
2596
2597
2613 private Folder openDraftsFolder(final Store store,
2614 final MailSession mailSession)
2615 throws SystemException {
2616 assert (store != null);
2617 assert (store.isConnected());
2618 assert (mailSession != null);
2619 checkDateFormatter(mailSession);
2620
2621 UserDO user = mailSession.getUser();
2622
2623 try {
2624 String draftsFolderName = settings.getStringSetting(mailSession,
2626 "emailFolderDrafts",
2627 user);
2628 Folder draftsFolder =
2629 mailServer.getFolder(mailSession, store, draftsFolderName);
2630 if (!(draftsFolder.exists() ||
2631 draftsFolder.create(Folder.HOLDS_MESSAGES))) {
2632 throw new SystemException(
2633 "ERROR in MailBean.openDraftsFolder: Cannot create drafts folder.");
2634 }
2635
2636 draftsFolder.open(Folder.READ_WRITE);
2637 return draftsFolder;
2638 } catch (MessagingException e) {
2639 throw new SystemException(e);
2640 }
2641 }
2642
2643
2659 private void retainAttachments(final MessageDO messageDO,
2660 final MimeBodyPart newBasePart,
2661 final MimeMessage oldMessage,
2662 final MimeMessage newMessage)
2663 throws SystemException {
2664 try {
2665 MimeMultipart newMasterContent = new MimeMultipart ();
2666 MimeMultipart oldContent = (MimeMultipart ) oldMessage.getContent();
2667
2668 for (int j = 1; j < oldContent.getCount(); j++) {
2670 MimeBodyPart mimePart = new MimeBodyPart ();
2671
2672 mimePart = (MimeBodyPart ) oldContent.getBodyPart(j);
2673
2674 if (messageDO.getAttachments() != null) {
2676 for (Iterator i = messageDO.getAttachments().iterator();
2678 i.hasNext();) {
2679 String id = ((FileDO) i.next()).getName();
2680
2681 if ((mimePart.isMimeType("message/*") &&
2683 (((MimeMessage ) mimePart.getContent()).getMessageID()
2684 .equals(id))) ||
2685 ((mimePart.getFileName() != null) &&
2686 mimePart.getFileName().equals(id)) ||
2687 ((mimePart.getContentID() != null) &&
2688 mimePart.getContentID().equals(id))) {
2689 newMasterContent.addBodyPart(mimePart);
2690 }
2691 }
2692 }
2693 }
2694
2695 if (newMasterContent.getCount() > 0) {
2698 newMasterContent.addBodyPart(newBasePart, 0);
2699 newMessage.setContent(newMasterContent);
2700
2701 } else {
2703 if (messageDO.getFormat() == FormatConstants.FORMAT_HTML) {
2704 newMessage.setContent((MimeMultipart ) newBasePart.getContent());
2705 newMessage.setHeader("Content-Type",
2706 newBasePart.getContentType());
2707 } else {
2708 newMessage.setText(messageDO.getText());
2709 }
2710 }
2711 } catch (MessagingException e) {
2712 throw new SystemException(e);
2713 } catch (IOException e) {
2714 throw new SystemException(e);
2715 }
2716 }
2717
2718
2733 public void send(final MailSession mailSession,
2734 final MessageDO messageDO)
2735 throws SystemException {
2736 checkDateFormatter(mailSession);
2737 Store store = mailServer.connectStore(mailSession);
2738 try {
2739 if (!settings.getBooleanSetting(mailSession,
2741 "emailEnable", null)
2742 .booleanValue()) {
2743 return;
2744 }
2745
2746 Session javaMailSession;
2747 try {
2748 javaMailSession = mailSession.getJavaMailSession();
2749 } catch (SecurityServerException e1) {
2750 throw new SystemException(e1);
2751 } catch (java.security.NoSuchProviderException e1) {
2752 throw new SystemException(e1);
2753 }
2754
2755 Folder draftsFolder = openDraftsFolder(store, mailSession);
2757 MimeMessage newMessage = setDOToJavaMailMessage(javaMailSession,
2758 draftsFolder, messageDO);
2759
2760 newMessage.setSentDate(Calendar.getInstance().getTime());
2761
2762 Transport.send(newMessage);
2764
2765 addToSentFolder(mailSession, newMessage);
2767
2768 draftsFolder.expunge();
2770 draftsFolder.close(true);
2771 } catch (MessagingException e) {
2772 throw new SystemException(e);
2773 } catch (SettingsDataTypeException e) {
2774 throw new SystemException(e);
2775 } finally {
2776 try {
2777 store.close();
2778 } catch (MessagingException e) {
2779 logger.error("Messaging exception on closing the store", e);
2780 }
2781 }
2782 }
2783
2784
2813 public void send(final MailSession mailSession,
2814 final String fromAddress,
2815 final Collection to,
2816 final Collection cc,
2817 final Collection bcc,
2818 final String subject,
2819 Object content, String contentType, boolean addToSentFolder)
2820 throws SystemException {
2821 checkDateFormatter(mailSession);
2822 try {
2823 try {
2824 if (!settings.getBooleanSetting(mailSession, "emailEnable", null)
2826 .booleanValue()) {
2827 return;
2828 }
2829 } catch (SettingsDataTypeException e) {
2830 throw new SystemException(e);
2831 }
2832
2833 Session javaMailSession;
2835
2836 try {
2837 javaMailSession = mailSession.getJavaMailSession();
2838 } catch (AuthenticationFailedException e) {
2839 throw new SystemException(
2840 "User is no longer authorized to use this server: " +
2841 e.getMessage(),
2842 e);
2843 } catch (MessagingException e) {
2844 throw new SystemException(e);
2845 } catch (SecurityServerException e) {
2846 throw new SystemException(e);
2847 } catch (java.security.NoSuchProviderException e) {
2848 throw new SystemException(e);
2849 }
2850
2851 Store store = javaMailSession.getStore("imap");
2852
2853 if (store == null) {
2854 throw new SystemException(
2855 "ERROR in MailBean: could not access the mail store");
2856 }
2857
2858 MimeMessage message = new MimeMessage (javaMailSession);
2859
2860 try {
2861 message.setFrom(new InternetAddress (fromAddress));
2862 message.setSubject(subject);
2863 message.setRecipients(MimeMessage.RecipientType.TO,
2864 convertAddresses(null, to));
2865
2866 if (cc != null) {
2867 message.setRecipients(MimeMessage.RecipientType.CC,
2868 convertAddresses(null, cc));
2869 }
2870
2871 if (bcc != null) {
2872 message.setRecipients(MimeMessage.RecipientType.BCC,
2873 convertAddresses(null, bcc));
2874 }
2875
2876 message.setContent(content, contentType);
2877 message.setSentDate(Calendar.getInstance().getTime());
2878 } catch (MessagingException e) {
2879 throw new SystemException("Please check your input: " +
2880 e.getMessage(),
2881 e);
2882 }
2883
2884 try {
2886 Transport.send(message);
2887 } catch (MessagingException e) {
2888 throw new SystemException("The message could not be sent: " +
2889 e.getMessage(),
2890 e);
2891 }
2892
2893 if (addToSentFolder) {
2895 addToSentFolder(mailSession, message);
2896 }
2897 } catch (NoSuchProviderException e) {
2898 throw new SystemException(e);
2899 }
2900 }
2901
2902
2927 private MimeMessage setDOToJavaMailMessage(final Session javaMailSession,
2928 final Folder draftsFolder,
2929 final MessageDO messageDO)
2930 throws SystemException {
2931 MimeMessage newMessage = new MimeMessage (javaMailSession);
2932
2933 try {
2934 newMessage.addFrom(convertAddresses(null, messageDO.getSenders()));
2935 newMessage.setSubject(messageDO.getSubject());
2936 newMessage.setRecipients(MimeMessage.RecipientType.TO,
2937 convertAddresses(null, messageDO.getRecipients()));
2938
2939 if (messageDO.getRecipientsCC() != null) {
2940 newMessage.setRecipients(MimeMessage.RecipientType.CC,
2941 convertAddresses(null, messageDO.getRecipientsCC()));
2942 }
2943
2944 if (messageDO.getRecipientsBCC() != null) {
2945 newMessage.setRecipients(MimeMessage.RecipientType.BCC,
2946 convertAddresses(null, messageDO.getRecipientsBCC()));
2947 }
2948
2949 newMessage.setSentDate(Calendar.getInstance().getTime());
2950
2951 MimeMessage oldMessage = null;
2953
2954 if ((messageDO.getMessageID() != null) && (draftsFolder != null)) {
2955 oldMessage = findJavaMailMessageByFolderMessageId(draftsFolder,
2956 messageDO.getMessageID());
2957 }
2958
2959 MimeBodyPart newBasePart = new MimeBodyPart ();
2960
2961 if (messageDO.getFormat() == FormatConstants.FORMAT_TEXT) {
2964 newBasePart.setText(messageDO.getText());
2965 } else {
2966 MimeMultipart newTextContent = createHTMLContent(messageDO.getText());
2968
2969 newBasePart.setContent(newTextContent);
2971 newBasePart.setHeader("Content-Type",
2972 newTextContent.getContentType());
2973 }
2974
2975 if ((oldMessage == null) ||
2980 !oldMessage.isMimeType("multipart/mixed") ||
2981 (messageDO.getAttachments() == null)) {
2982 if (messageDO.getFormat() == FormatConstants.FORMAT_HTML) {
2984 newMessage.setContent((MimeMultipart ) newBasePart.getContent());
2985 newMessage.setHeader("Content-Type",
2986 newBasePart.getContentType());
2987 } else {
2988 newMessage.setText(messageDO.getText());
2989 }
2990 } else {
2991 retainAttachments(messageDO, newBasePart, oldMessage, newMessage);
2994
2995 oldMessage.setFlag(Flags.Flag.DELETED, true);
2997 }
2998 } catch (StackOverflowError e) {
2999 e.printStackTrace();
3000 } catch (MessagingException e) {
3001 throw new SystemException(e);
3002 } catch (IOException e) {
3003 throw new SystemException(e);
3004 }
3005
3006 return newMessage;
3007 }
3008
3009
3017 private void setMultiPartText(final Part message,
3018 final MessageTextParts messageTextPartsParam)
3019 throws SystemException {
3020 MessageTextParts messageTextParts = messageTextPartsParam;
3021 MimeMultipart content;
3022 MimeBodyPart subPart;
3023 int i;
3024
3025 try {
3026 content = (MimeMultipart ) message.getContent();
3027
3028 for (i = 0; i < content.getCount(); i++) {
3030 subPart = (MimeBodyPart ) content.getBodyPart(i);
3031
3032 if (message.isMimeType("multipart/alternative")) {
3034 if (subPart.isMimeType("text/plain") &&
3035 (messageTextParts.textPart != null)) {
3036 subPart.setContent(messageTextParts.textPart.getContent(),
3037 "text/plain");
3038 } else if (subPart.isMimeType("text/HTML") &&
3039 (messageTextParts.HTMLPart != null)) {
3040 subPart.setContent(messageTextParts.HTMLPart.getContent(),
3041 "text/HTML");
3042
3043 break;
3045 }
3046 }
3047
3048 if (message.isMimeType("multipart/related") ||
3050 message.isMimeType("multipart/mixed")) {
3051 if (subPart.isMimeType("multipart/*")) {
3053 messageTextParts = getMultiPartText((Part ) subPart);
3054 } else if (subPart.isMimeType("text/plain") &&
3055 (messageTextParts.textPart == null)) {
3056 messageTextParts.textPart = subPart;
3057 } else if (subPart.isMimeType("text/HTML") &&
3058 (messageTextParts.HTMLPart == null)) {
3059 messageTextParts.HTMLPart = subPart;
3060
3061 break;
3062 }
3063 }
3064 }
3065 } catch (MessagingException e) {
3066 throw new SystemException(e);
3067 } catch (java.io.IOException e) {
3068 throw new SystemException(e);
3069 }
3070 }
3071
3072
3073
3084 public final void setUserAliases(final SecuritySession securitySession,
3085 final String userName,
3086 final Collection userAliases)
3087 throws SystemException {
3088 checkMailServer();
3089 checkDateFormatter(securitySession);
3090
3091 List currentUserAliases = mailServer.getUserAliases(securitySession,
3093 userName);
3094 PersonDO person = addressBook.findPersonByUserName(securitySession,
3095 userName);
3096 UserDO user = person.getUser();
3097 Set telecomAddresses = person.getTelecomAddresses();
3098
3099 String emailAddressHost =
3100 settings.getStringSetting(
3101 securitySession,
3102 "emailAddressHost",
3103 user);
3104
3105 Iterator currentUserAliasesIterator = currentUserAliases.iterator();
3108 List removedEmailAddresses = new Vector ();
3109 List removedEmailTelecomAddresses = new Vector ();
3110 List currentEmailAddresses = new Vector ();
3111 while (currentUserAliasesIterator.hasNext()) {
3112 String alias = (String ) currentUserAliasesIterator.next();
3113 if (!userAliases.contains(alias)) {
3114 removedEmailAddresses.add(alias + "@" + emailAddressHost);
3115 }
3116 }
3117 Iterator telecomAddressIterator = telecomAddresses.iterator();
3118 while (telecomAddressIterator.hasNext()) {
3119 TelecomAddressDO thisTelecomAddress = (TelecomAddressDO)
3120 telecomAddressIterator.next();
3121 if (thisTelecomAddress.getType() == TelecomAddressConstants.TYPE_EMAIL) {
3122 if (removedEmailAddresses.contains(thisTelecomAddress.getAddress())) {
3123 removedEmailTelecomAddresses.add(thisTelecomAddress);
3124 } else {
3125 currentEmailAddresses.add(thisTelecomAddress.getAddress());
3126 }
3127 }
3128 }
3129
3130 int sizeBefore = telecomAddresses.size();
3131 if (user.getId() != null) {
3132 addUserAliasEmailAddresses(securitySession, userName, userAliases,
3133 telecomAddresses, emailAddressHost);
3134 }
3135 int sizeAfter = telecomAddresses.size();
3136
3137 if ((removedEmailTelecomAddresses.size() > 0)
3140 || (sizeAfter != sizeBefore)) {
3141 Iterator removedEmailTelecomAddressesIterator = removedEmailTelecomAddresses.iterator();
3142 while (removedEmailTelecomAddressesIterator.hasNext()) {
3143 telecomAddresses.remove(removedEmailTelecomAddressesIterator.next());
3144 }
3145 addressBook.amendPerson(securitySession, person);
3146 }
3147
3148 userAliases.remove(userName);
3150
3151 mailServer.setUserAliases(securitySession, userName, userAliases);
3152 }
3153
3154
3164 public final void setVacationMessage(final SecuritySession securitySession,
3165 final String userName,
3166 final String vacationMessage)
3167 throws SystemException {
3168 checkMailServer();
3169 checkDateFormatter(securitySession);
3170 mailServer.setVacationMessage(securitySession, userName, null);
3171 }
3172
3173
3182 private String [] toStringArray(final Address [] addresses) {
3183 int i;
3184 String [] retArray = new String [addresses.length];
3185
3186 for (i = 0; i < addresses.length; i++) {
3187 retArray[i] = addresses[i].toString();
3188 }
3189
3190 return retArray;
3191 }
3192
3193
3205 public ValidationErrors validate(final SecuritySession securitySession,
3206 final MessageDO messageDO) {
3207 checkDateFormatter(securitySession);
3208 ValidationErrors errors = new ValidationErrors();
3209 Mask mask = maskFactory.getMask(MessageDO.class);
3210
3211 if ((messageDO.getRecipients() == null) ||
3213 (messageDO.getRecipients().size() == 0)) {
3214 errors.add(new ValidationError(
3215 "compose",
3216 Mail.BUNDLE_PATH,
3217 mask.getField("recipients"),
3218 "errors.required"));
3219 }
3220
3221 if ((messageDO.getSenders() == null) ||
3223 (messageDO.getSenders().size() == 0)) {
3224 errors.add(new ValidationError(
3225 "compose",
3226 Mail.BUNDLE_PATH,
3227 mask.getField("senders"),
3228 "errors.required"));
3229 }
3230
3231 if ((messageDO == null) ||
3233 StringHandling.isNullOrEmpty(messageDO.getSubject())) {
3234 errors.add(new ValidationError(
3235 "compose",
3236 Mail.BUNDLE_PATH,
3237 mask.getField("subject"),
3238 "errors.required"));
3239 }
3240
3241 if ((messageDO == null) ||
3243 StringHandling.isNullOrEmpty(messageDO.getText())) {
3244 errors.add(new ValidationError(
3245 "compose",
3246 Mail.BUNDLE_PATH,
3247 mask.getField("text"),
3248 "errors.required"));
3249 }
3250
3251 if (messageDO.getRecipients() != null) {
3253 for (Iterator i = messageDO.getRecipients().iterator();
3254 i.hasNext();) {
3255 String currentRecipient = "";
3256
3257 try {
3258 currentRecipient = (String ) i.next();
3259
3260 InternetAddress emailAddress = new InternetAddress (currentRecipient,
3261 true);
3262 } catch (AddressException e) {
3263 errors.add(new ValidationError(
3264 "",
3265 Mail.BUNDLE_PATH,
3266 mask.getField("to"),
3267 "errors.mail.wrongEmailAddress",
3268 Arrays.asList(new String [] { currentRecipient })));
3269 }
3270 }
3271 }
3272
3273 if (messageDO.getRecipientsCC() != null) {
3274 for (Iterator i = messageDO.getRecipientsCC().iterator();
3275 i.hasNext();) {
3276 String currentRecipientCC = "";
3277
3278 try {
3279 currentRecipientCC = (String ) i.next();
3280
3281 InternetAddress emailAddress = new InternetAddress (currentRecipientCC,
3282 true);
3283 } catch (AddressException e) {
3284 errors.add(new ValidationError(
3285 "",
3286 Mail.BUNDLE_PATH,
3287 mask.getField("cc"),
3288 "errors.mail.wrongEmailAddress",
3289 Arrays.asList(new String [] { currentRecipientCC })));
3290 }
3291 }
3292 }
3293
3294 if (messageDO.getRecipientsBCC() != null) {
3295 for (Iterator i = messageDO.getRecipientsBCC().iterator();
3296 i.hasNext();) {
3297 String currentRecipientBCC = "";
3298
3299 try {
3300 currentRecipientBCC = (String ) i.next();
3301
3302 InternetAddress emailAddress = new InternetAddress (currentRecipientBCC,
3303 true);
3304 } catch (AddressException e) {
3305 errors.add(new ValidationError(
3306 "",
3307 Mail.BUNDLE_PATH,
3308 mask.getField("bcc"),
3309 "errors.mail.wrongEmailAddress",
3310 Arrays.asList(new String [] { currentRecipientBCC })));
3311 }
3312 }
3313 }
3314
3315 return errors;
3316 }
3317}
3318 |
Popular Tags |
Java API By Example, From Geeks To Geeks.