trinidad-example/trinidad-demo/src/main/java/org/apache/myfaces/trinidaddemo/email/MessageData.java - myfaces-trinidad - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache 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.apache.org/licenses/LICENSE-2.0
  *
  * 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.apache.myfaces.trinidaddemo.email;

 import java.io.IOException;

 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 import javax.mail.Address;
 import javax.mail.BodyPart;
 import javax.mail.Folder;
 import javax.mail.Message;
 import javax.mail.MessagingException;
 import javax.mail.Part;

 import javax.mail.internet.MimeBodyPart;
 import javax.mail.internet.MimeMultipart;
 import javax.mail.Flags.Flag;

 /**
  * MessageData contains all the information needed to display a UI
  * for a javax.mail.Message object.  There are methods to get the
  * sender, the subject, the size, the date, the to list, the cc list,
  * the content type, the content itself, and the line count of the message.
  *
  * @version 1.0
  */
 public class MessageData
 {
   /**
    * Create a new MessageData object given the message object.
    */
   public MessageData(Message message) throws MessagingException
   {
     _message = message;

     // cache the size just because it involves a calculation
     _size = message.getSize() / 1024;

     // cache this since the folder has to be open to get this:
     _isRead = _message.isSet(Flag.SEEN);
     _isDeleted = _message.isSet(Flag.DELETED);
   }

   /**
    * Get the number of the message in its containing folder.
    *
    * @return the message number. this index is based at 1
    */
   public int getMessageNumber()
   {
     return _message.getMessageNumber();
   }

   /**
    * Get the Address object that corresponds to the sender
    */
   public Address getSender() throws MessagingException
   {
     // we assume that the original sender is the first one
     return _message.getFrom()[0];
   }

   /**
    * Get the subject of the message.  If the subject is empty or null
    * we return a string <empty> to indicate the subject did not contain
    * anything.
    */
   public String getSubject() throws MessagingException
   {
     String subject = _message.getSubject();

     // if the subject is empty than make sure we return something so the
     // user can click on it to see its contents!  Need to internationalize this.
     if ( (subject == null) || "".equals(subject) )
       subject = "<empty>";

     return subject;
   }

   /**
    * Get the size of the message in kilobytes.
    *
    * @return size in kilo bytes
    */
   public int getSize()
   {
     return _size;
   }

   /**
    * Get the sent date of the message.
    */
   public Date getSentDate() throws MessagingException
   {
     return _message.getSentDate();
   }

   /**
    * Get an array of Address objects that correspond to the list of
    * addresses the message was sent to.
    */
   public Address[] getTos() throws MessagingException
   {
     Address[] tos = _message.getRecipients(Message.RecipientType.TO);
     return tos;
   }

   /**
    * Get an array of Address objects that correspond to the list of
    * addresses the message was cc'd to.
    */
   public Address[] getCcs() throws MessagingException
   {
     Address[] ccs = _message.getRecipients(Message.RecipientType.CC);
     return ccs;
   }

   /**
    * Get a string representing the content type of the message.  The
    * string returned is truncated to just show the initial part of the type
    * like text/plain.  Also if the original message is a more complex type
    * like multipart, this method will actually search through all the parts
    * and try and find a text/plain or text/html to make the UI easier to
    * handle.
    */
   public String getContentType() throws MessagingException
   {
     // catch IOExceptions and ignore them, because content type really
     // shouldn't care much about io exceptions
     try
     {
       _tryInit();
     }
     catch (IOException ioe)
     {
       ;
     }

     return _contentType;
   }

   /**
    * Get an object representing the content type of the message.  If the
    * original message is a more complex type like multipart, this method
    * will actually search through all the parts and try and find a
    * text/plain or text/html to make the UI easier to handle.
    */
   public Object getContent() throws MessagingException, IOException
   {
     // catch IOExceptions and ignore them, because content type really
     // shouldn't care much about io exceptions
     try
     {
       _tryInit();
     }
     catch (IOException ioe)
     {
       ;
     }

     return _content;
   }

   /**
    * Get the number of lines in the message.  If the original message is a
    * more complex type like multipart, this method will actually search
    * through all the parts and try and find a text/plain or text/html
    * and getLineCount() will return the number of messages in that part.
    */
   public int getLineCount() throws MessagingException
   {
     // catch IOExceptions and ignore them, because content type really
     // shouldn't care much about io exceptions
     try
     {
       _tryInit();
     }
     catch (IOException ioe)
     {
       ;
     }

     return _lineCount;
   }


   /**
    * Return true if the message has been read yet.
    */
   public boolean isRead()
   {
     return _isRead;
   }

   /**
    * Return true if the message has been deleted.
    */
   public boolean isDeleted()
   {
     return _isDeleted;
   }

   /**
    * Get the underlying Message Object.
    */
   public Message getMessage()
   {
     return _message;
   }

   /**
    * Get the list of attachments.
    */
   public List<BodyPart> getAttachments()
   {
     return _attachments;
   }

   /**
    * Returns true if any attachments are available.
    */
   public boolean isAttachmentPresent()
   {
     return (_attachments != null) && (!_attachments.isEmpty());
   }


   ////////////////////////////////////////////////////////////////////////////
   // private methods
   ////////////////////////////////////////////////////////////////////////////
   /**
    * Initialize the linecount, content type, and content once and for all.
    */
   synchronized private void _tryInit() throws MessagingException, IOException
   {
     // only gather the information if we haven't been initalized yet
     if (_lineCount == -1)
     {
       int count = 0;
       String contentType = null;
       Object content = null;

       // open the folder;  open it read-write if the message hasn't yet
       // been read (in which case we'll need to set it accordingly)
       _message.getFolder().open(_isRead
                                 ? Folder.READ_ONLY
                                 : Folder.READ_WRITE);

       List<BodyPart> attachments = new ArrayList<BodyPart>();

       try
       {
         // get the linecount, content type, and content
         count = _message.getLineCount();
         contentType = _message.getContentType();
         content = _message.getContent();

         // if its a multipart type then lets look through all the parts
         // and see if we can find the more interesting text or html ones
         // so that we can display them better
         if (contentType.startsWith(_MULTIPART))
         {
           if (content instanceof MimeMultipart)
           {
             boolean found = false;

             MimeMultipart mm = (MimeMultipart)content;
             for (int i=0;i<mm.getCount();i++)
             {
               BodyPart bp = mm.getBodyPart(i);

               if (!found && (bp instanceof MimeBodyPart))
               {
                 MimeBodyPart mbp = (MimeBodyPart)bp;
                 String type = mbp.getContentType();

                 if (type.startsWith(_HTML_TEXT) ||
                     type.startsWith(_PLAIN_TEXT) )
                 {
                   found = true;
                   count = mbp.getLineCount();
                   content = mbp.getContent();
                   contentType = type;

                   // be happy with the first thing we find either plain
                   // text or html, and skip over it as an attachment
                   continue;
                 }
               }

               // OK, now let's see if it's an attachment
               String disp = bp.getDisposition();
               if (disp == null || disp.equalsIgnoreCase(Part.ATTACHMENT))
               {
                 attachments.add(bp);
               }
             }

             // if we don't find something either text or html, and we don't
             // have any attachments then we are in trouble.  Just throw an
             // exception and let the code below set things up properly.
             if (!found)
             {
               if (!attachments.isEmpty())
                 content = "";
               else
                 throw new IllegalStateException();
             }
           }
         }

         // strip of the extra parts of the content type so we return something
         // like plain/text or html/text
         int index = contentType.indexOf(';');
         if (index != -1)
           contentType = contentType.substring(0, index);

         // Mark it as seen
         _message.getFlags().add(Flag.SEEN);
         _isRead = true;
       }
       catch (Exception e)
       {
         content = "Error trying to display content";
         count = 1;
         contentType = _PLAIN_TEXT;
         attachments.clear();
       }
       // always make sure to close the message in case there was an error.
       finally
       {
         _message.getFolder().close(false);
       }

       _lineCount = count;
       _contentType = contentType;
       _content = content;
       _attachments = attachments;
     }
   }

   // this implementation tries very poorly to handle attachments by just
   // putting them inline.  If we had more time to figure out java mail we
   // could do something better with attachements
   /**
    * Initialize the linecount, content type, and content once and for all.
   synchronized private void _tryInit() throws MessagingException, IOException
   {
     // only gather the information if we haven't been initalized yet
     if (_lineCount == -1)
     {
       int count = 0;
       String contentType = null;
       Object content = null;

       // open the folder
       _message.getFolder().open(Folder.READ_ONLY);

       try
       {
         // get the linecount, content type, and content
         count = _message.getLineCount();
         contentType = _message.getContentType();
         content = _message.getContent();

         // if its a multipart type then lets look through all the parts
         // and see if we can find the more interesting text or html ones
         // so that we can display them better
         if (contentType.startsWith(_MULTIPART))
         {
             if (content instanceof MimeMultipart)
             {
               MimeMultipart mm = (MimeMultipart)content;
               Object plainContent = null;
               Object htmlContent = null;
               int plainCount = 0;
               int htmlCount = 0;

               // loop through all of the parts.  If we find more than
               // one plain text than append then all together so we can
               // display simple attachements better
               for (int i=0;i<mm.getCount();i++)
               {
                 BodyPart bp = mm.getBodyPart(i);

                 if (bp instanceof MimeBodyPart)
                 {
                   MimeBodyPart mbp = (MimeBodyPart)bp;
                   String type = mbp.getContentType();

                   if (type.startsWith(_PLAIN_TEXT))
                   {
                     plainCount += mbp.getLineCount();
                     Object newContent = mbp.getContent();

                     if (plainContent == null)
                       plainContent = newContent;
                     else
                     {
                       plainContent = plainContent + "\n---------------------------------\n" + newContent;
                       plainCount++;
                     }
                   }
                   else if (type.startsWith(_HTML_TEXT))
                   {
                     htmlCount += mbp.getLineCount();
                     Object newContent = mbp.getContent();

                     if (htmlContent == null)
                       htmlContent = newContent;
                     else
                     {
                       htmlContent = htmlContent + "\n---------------------------------\n" + newContent;
                       htmlCount++;
                     }
                   }
                 }
               }

               // if we found any plain content use that first
               if (plainContent != null)
               {
                 count = plainCount;
                 content = plainContent;
                 contentType = _PLAIN_TEXT;
               }
               // then html
               else if (htmlContent != null)
               {
                 count = htmlCount;
                 content = htmlContent;
                 contentType = _HTML_TEXT;
               }
               // if we found neither thrown an exception which we will
               // catch down below to setup state
               else
               {
                 throw new IllegalStateException();
               }
             }
         }

         // strip of the extra parts of the content type so we return something
         // like plain/text or html/text
         int index = contentType.indexOf(';');
         if (index != -1)
           contentType = contentType.substring(0, index);
       }
       catch (Exception e)
       {
         content = "Could not display content";
         count = 0;
         contentType = _PLAIN_TEXT;
       }
       // always make sure to close the message in case there was an error.
       finally
       {
         _message.getFolder().close(false);
       }

       _lineCount = count;
       _contentType = contentType;
       _content = content;
     }
   }
    */

   ////////////////////////////////////////////////////////////////////////////
   // private variables
   ////////////////////////////////////////////////////////////////////////////
   private static final String _PLAIN_TEXT = "TEXT/PLAIN";
   private static final String _HTML_TEXT = "TEXT/HTML";
   private static final String _MULTIPART = "multipart";

   private final Message _message;
   private Object _content = null;
   private String _contentType= null;
   private int _lineCount = -1;
   private int _size;
   private boolean _isRead;
   private boolean _isDeleted;
   private List<BodyPart> _attachments;
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache 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.apache.org/licenses/LICENSE-2.0
	*
	* 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.apache.myfaces.trinidaddemo.email;

	import java.io.IOException;

	import java.util.ArrayList;
	import java.util.Date;
	import java.util.List;

	import javax.mail.Address;
	import javax.mail.BodyPart;
	import javax.mail.Folder;
	import javax.mail.Message;
	import javax.mail.MessagingException;
	import javax.mail.Part;

	import javax.mail.internet.MimeBodyPart;
	import javax.mail.internet.MimeMultipart;
	import javax.mail.Flags.Flag;

	/**
	* MessageData contains all the information needed to display a UI
	* for a javax.mail.Message object. There are methods to get the
	* sender, the subject, the size, the date, the to list, the cc list,
	* the content type, the content itself, and the line count of the message.
	*
	* @version 1.0
	*/
	public class MessageData
	{
	/**
	* Create a new MessageData object given the message object.
	*/
	public MessageData(Message message) throws MessagingException
	{
	_message = message;

	// cache the size just because it involves a calculation
	_size = message.getSize() / 1024;

	// cache this since the folder has to be open to get this:
	_isRead = _message.isSet(Flag.SEEN);
	_isDeleted = _message.isSet(Flag.DELETED);
	}

	/**
	* Get the number of the message in its containing folder.
	*
	* @return the message number. this index is based at 1
	*/
	public int getMessageNumber()
	{
	return _message.getMessageNumber();
	}

	/**
	* Get the Address object that corresponds to the sender
	*/
	public Address getSender() throws MessagingException
	{
	// we assume that the original sender is the first one
	return _message.getFrom()[0];
	}

	/**
	* Get the subject of the message. If the subject is empty or null
	* we return a string <empty> to indicate the subject did not contain
	* anything.
	*/
	public String getSubject() throws MessagingException
	{
	String subject = _message.getSubject();

	// if the subject is empty than make sure we return something so the
	// user can click on it to see its contents! Need to internationalize this.
	if ( (subject == null) \|\| "".equals(subject) )
	subject = "<empty>";

	return subject;
	}

	/**
	* Get the size of the message in kilobytes.
	*
	* @return size in kilo bytes
	*/
	public int getSize()
	{
	return _size;
	}

	/**
	* Get the sent date of the message.
	*/
	public Date getSentDate() throws MessagingException
	{
	return _message.getSentDate();
	}

	/**
	* Get an array of Address objects that correspond to the list of
	* addresses the message was sent to.
	*/
	public Address[] getTos() throws MessagingException
	{
	Address[] tos = _message.getRecipients(Message.RecipientType.TO);
	return tos;
	}

	/**
	* Get an array of Address objects that correspond to the list of
	* addresses the message was cc'd to.
	*/
	public Address[] getCcs() throws MessagingException
	{
	Address[] ccs = _message.getRecipients(Message.RecipientType.CC);
	return ccs;
	}

	/**
	* Get a string representing the content type of the message. The
	* string returned is truncated to just show the initial part of the type
	* like text/plain. Also if the original message is a more complex type
	* like multipart, this method will actually search through all the parts
	* and try and find a text/plain or text/html to make the UI easier to
	* handle.
	*/
	public String getContentType() throws MessagingException
	{
	// catch IOExceptions and ignore them, because content type really
	// shouldn't care much about io exceptions
	try
	{
	_tryInit();
	}
	catch (IOException ioe)
	{
	;
	}

	return _contentType;
	}

	/**
	* Get an object representing the content type of the message. If the
	* original message is a more complex type like multipart, this method
	* will actually search through all the parts and try and find a
	* text/plain or text/html to make the UI easier to handle.
	*/
	public Object getContent() throws MessagingException, IOException
	{
	// catch IOExceptions and ignore them, because content type really
	// shouldn't care much about io exceptions
	try
	{
	_tryInit();
	}
	catch (IOException ioe)
	{
	;
	}

	return _content;
	}

	/**
	* Get the number of lines in the message. If the original message is a
	* more complex type like multipart, this method will actually search
	* through all the parts and try and find a text/plain or text/html
	* and getLineCount() will return the number of messages in that part.
	*/
	public int getLineCount() throws MessagingException
	{
	// catch IOExceptions and ignore them, because content type really
	// shouldn't care much about io exceptions
	try
	{
	_tryInit();
	}
	catch (IOException ioe)
	{
	;
	}

	return _lineCount;
	}


	/**
	* Return true if the message has been read yet.
	*/
	public boolean isRead()
	{
	return _isRead;
	}

	/**
	* Return true if the message has been deleted.
	*/
	public boolean isDeleted()
	{
	return _isDeleted;
	}

	/**
	* Get the underlying Message Object.
	*/
	public Message getMessage()
	{
	return _message;
	}

	/**
	* Get the list of attachments.
	*/
	public List<BodyPart> getAttachments()
	{
	return _attachments;
	}

	/**
	* Returns true if any attachments are available.
	*/
	public boolean isAttachmentPresent()
	{
	return (_attachments != null) && (!_attachments.isEmpty());
	}


	////////////////////////////////////////////////////////////////////////////
	// private methods
	////////////////////////////////////////////////////////////////////////////
	/**
	* Initialize the linecount, content type, and content once and for all.
	*/
	synchronized private void _tryInit() throws MessagingException, IOException
	{
	// only gather the information if we haven't been initalized yet
	if (_lineCount == -1)
	{
	int count = 0;
	String contentType = null;
	Object content = null;

	// open the folder; open it read-write if the message hasn't yet
	// been read (in which case we'll need to set it accordingly)
	_message.getFolder().open(_isRead
	? Folder.READ_ONLY
	: Folder.READ_WRITE);

	List<BodyPart> attachments = new ArrayList<BodyPart>();

	try
	{
	// get the linecount, content type, and content
	count = _message.getLineCount();
	contentType = _message.getContentType();
	content = _message.getContent();

	// if its a multipart type then lets look through all the parts
	// and see if we can find the more interesting text or html ones
	// so that we can display them better
	if (contentType.startsWith(_MULTIPART))
	{
	if (content instanceof MimeMultipart)
	{
	boolean found = false;

	MimeMultipart mm = (MimeMultipart)content;
	for (int i=0;i<mm.getCount();i++)
	{
	BodyPart bp = mm.getBodyPart(i);

	if (!found && (bp instanceof MimeBodyPart))
	{
	MimeBodyPart mbp = (MimeBodyPart)bp;
	String type = mbp.getContentType();

	if (type.startsWith(_HTML_TEXT) \|\|
	type.startsWith(_PLAIN_TEXT) )
	{
	found = true;
	count = mbp.getLineCount();
	content = mbp.getContent();
	contentType = type;

	// be happy with the first thing we find either plain
	// text or html, and skip over it as an attachment
	continue;
	}
	}

	// OK, now let's see if it's an attachment
	String disp = bp.getDisposition();
	if (disp == null \|\| disp.equalsIgnoreCase(Part.ATTACHMENT))
	{
	attachments.add(bp);
	}
	}

	// if we don't find something either text or html, and we don't
	// have any attachments then we are in trouble. Just throw an
	// exception and let the code below set things up properly.
	if (!found)
	{
	if (!attachments.isEmpty())
	content = "";
	else
	throw new IllegalStateException();
	}
	}
	}

	// strip of the extra parts of the content type so we return something
	// like plain/text or html/text
	int index = contentType.indexOf(';');
	if (index != -1)
	contentType = contentType.substring(0, index);

	// Mark it as seen
	_message.getFlags().add(Flag.SEEN);
	_isRead = true;
	}
	catch (Exception e)
	{
	content = "Error trying to display content";
	count = 1;
	contentType = _PLAIN_TEXT;
	attachments.clear();
	}
	// always make sure to close the message in case there was an error.
	finally
	{
	_message.getFolder().close(false);
	}

	_lineCount = count;
	_contentType = contentType;
	_content = content;
	_attachments = attachments;
	}
	}

	// this implementation tries very poorly to handle attachments by just
	// putting them inline. If we had more time to figure out java mail we
	// could do something better with attachements
	/**
	* Initialize the linecount, content type, and content once and for all.
	synchronized private void _tryInit() throws MessagingException, IOException
	{
	// only gather the information if we haven't been initalized yet
	if (_lineCount == -1)
	{
	int count = 0;
	String contentType = null;
	Object content = null;

	// open the folder
	_message.getFolder().open(Folder.READ_ONLY);

	try
	{
	// get the linecount, content type, and content
	count = _message.getLineCount();
	contentType = _message.getContentType();
	content = _message.getContent();

	// if its a multipart type then lets look through all the parts
	// and see if we can find the more interesting text or html ones
	// so that we can display them better
	if (contentType.startsWith(_MULTIPART))
	{
	if (content instanceof MimeMultipart)
	{
	MimeMultipart mm = (MimeMultipart)content;
	Object plainContent = null;
	Object htmlContent = null;
	int plainCount = 0;
	int htmlCount = 0;

	// loop through all of the parts. If we find more than
	// one plain text than append then all together so we can
	// display simple attachements better
	for (int i=0;i<mm.getCount();i++)
	{
	BodyPart bp = mm.getBodyPart(i);

	if (bp instanceof MimeBodyPart)
	{
	MimeBodyPart mbp = (MimeBodyPart)bp;
	String type = mbp.getContentType();

	if (type.startsWith(_PLAIN_TEXT))
	{
	plainCount += mbp.getLineCount();
	Object newContent = mbp.getContent();

	if (plainContent == null)
	plainContent = newContent;
	else
	{
	plainContent = plainContent + "\n---------------------------------\n" + newContent;
	plainCount++;
	}
	}
	else if (type.startsWith(_HTML_TEXT))
	{
	htmlCount += mbp.getLineCount();
	Object newContent = mbp.getContent();

	if (htmlContent == null)
	htmlContent = newContent;
	else
	{
	htmlContent = htmlContent + "\n---------------------------------\n" + newContent;
	htmlCount++;
	}
	}
	}
	}

	// if we found any plain content use that first
	if (plainContent != null)
	{
	count = plainCount;
	content = plainContent;
	contentType = _PLAIN_TEXT;
	}
	// then html
	else if (htmlContent != null)
	{
	count = htmlCount;
	content = htmlContent;
	contentType = _HTML_TEXT;
	}
	// if we found neither thrown an exception which we will
	// catch down below to setup state
	else
	{
	throw new IllegalStateException();
	}
	}
	}

	// strip of the extra parts of the content type so we return something
	// like plain/text or html/text
	int index = contentType.indexOf(';');
	if (index != -1)
	contentType = contentType.substring(0, index);
	}
	catch (Exception e)
	{
	content = "Could not display content";
	count = 0;
	contentType = _PLAIN_TEXT;
	}
	// always make sure to close the message in case there was an error.
	finally
	{
	_message.getFolder().close(false);
	}

	_lineCount = count;
	_contentType = contentType;
	_content = content;
	}
	}
	*/

	////////////////////////////////////////////////////////////////////////////
	// private variables
	////////////////////////////////////////////////////////////////////////////
	private static final String _PLAIN_TEXT = "TEXT/PLAIN";
	private static final String _HTML_TEXT = "TEXT/HTML";
	private static final String _MULTIPART = "multipart";

	private final Message _message;
	private Object _content = null;
	private String _contentType= null;
	private int _lineCount = -1;
	private int _size;
	private boolean _isRead;
	private boolean _isDeleted;
	private List<BodyPart> _attachments;
	}