webmailsession.java

java 开发的一个电子邮局,挺实用的

     */
    public void storeMessage(HTTPRequestHeader head) {
	XMLMessage xml_message=model.getWorkMessage();
	XMLMessagePart xml_textpart=xml_message.getFirstMessageTextPart();
	
	/* Store the already typed message if necessary/possible */
	if(head.isContentSet("BODY")) {
	    StringBuffer content=new StringBuffer();
		// Modified by exce, start
		/**
		 * Because the data transfered through HTTP should be ISO8859_1,
		 * HTTPRequestHeader is also ISO8859_1 encoded. Furthermore, the 
		 * string we used in brwoser is UTF-8 encoded, hence we have to 
		 * transcode the stored variables from ISO8859_1 to UTF-8 so that
		 * the client browser displays correctly.
		 */
		String bodyString;
		try {
			bodyString = new String(head.getContent("BODY").getBytes("ISO8859_1"), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			bodyString = head.getContent("BODY");
		}
		
	    // If the user enabled "break line", then do it!
	    if(user.wantsBreakLines()) {
		// StringTokenizer tok=new StringTokenizer(head.getContent("BODY"),"\n");
		StringTokenizer tok=new StringTokenizer(bodyString,"\n");
		while(tok.hasMoreTokens()) {
		    String line=tok.nextToken();		
		    Enumeration enum=Helper.breakLine(line,user.getMaxLineLength(),
						      Helper.getQuoteLevel(line));
		    while(enum.hasMoreElements()) {	       
			content.append((String)enum.nextElement()).append('\n');
		    }
		}
	    } else {
		// content.append(head.getContent("BODY"));
		content.append(bodyString);
		// Modified by exce, end
	    }	
	    xml_textpart.removeAllContent();
	    xml_textpart.addContent(content.toString(),0);
	}

	if(head.isContentSet("TO")) {
		// Modified by exce, start
	    // xml_message.setHeader("TO",head.getContent("TO"));
	    try {
			xml_message.setHeader("TO", new String(head.getContent("TO").getBytes("ISO8859_1"), "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			xml_message.setHeader("TO",head.getContent("TO"));
		}
		// Modified by exce, end
	}
	if(head.isContentSet("CC")) {
		// Modified by exce, start
	    // xml_message.setHeader("CC",head.getContent("CC"));
	    try {
			xml_message.setHeader("CC", new String(head.getContent("CC").getBytes("ISO8859_1"), "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			xml_message.setHeader("CC",head.getContent("CC"));
		}
		// Modified by exce, end
	}
	if(head.isContentSet("BCC")) {
		// Modified by exce, start
	    // xml_message.setHeader("BCC",head.getContent("BCC"));
	    try {
			xml_message.setHeader("BCC", new String(head.getContent("BCC").getBytes("ISO8859_1"), "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			xml_message.setHeader("BCC",head.getContent("BCC"));
		}
		// Modified by exce, end
	}
	if(head.isContentSet("REPLY-TO")) {
		// Modified by exce, start
	    // xml_message.setHeader("REPLY-TO",head.getContent("REPLY-TO"));
	    try {
			xml_message.setHeader("REPLY-TO", new String(head.getContent("REPLY-TO").getBytes("ISO8859_1"), "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			xml_message.setHeader("REPLY-TO",head.getContent("REPLY-TO"));
		}
		// Modified by exce, end
	}
	if(head.isContentSet("SUBJECT")) {
		// Modified by exce, start
	    // xml_message.setHeader("SUBJECT",head.getContent("SUBJECT"));
	    try {
			xml_message.setHeader("SUBJECT", new String(head.getContent("SUBJECT").getBytes("ISO8859_1"), "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			xml_message.setHeader("SUBJECT",head.getContent("SUBJECT"));
		}
		// Modified by exce, end
	}
	setEnv();
    }	       	
    
    /**
     * Connect to all Mailhosts
     * @deprecated Should use refreshFolderInformation now.
     */
    public void connectAll() {
	refreshFolderInformation();
    }


    /**
       Get a childfolder of a rootfolder for a specified hash value
    */
    public Folder getChildFolder(Folder root, String folderhash) {
	return getFolder(folderhash);
    }
    
    /**
     * Get the folder with the given hashvalue.
     * @returns Folder with the given hashvalue
     */
    public Folder getFolder(String folderhash) {
	return (Folder)folders.get(folderhash);
    }

    /**
     * This method tries to generate a unique folder identifier for the given folder.
     * This method generates an MD5 sum over the complete folder URL, if possible.
     * @see getFolderTree
     * @see net.wastl.webmail.misc.MD5
     */
    protected String generateFolderHash(Folder folder) {
	String id=Integer.toHexString(folder.hashCode());	
	// If possible, use the MD5-Sum for the folder ID because it is persistant over sessions
	try {
	    MD5 md5=new MD5(folder.getURLName());	   
	    id=md5.asHex();
	} catch(MessagingException ex) {
	}

	return id;
    }


    /**
     * Construct the folder subtree for the given folder and append it to xml_parent.
     * 
     * @param folder the folder where we begin
     * @param xml_parent the XML Element where the gathered information will be appended
     * @param subscribed_only Only list subscribed folders
     * @returns maximum depth of the folder tree (needed to calculate the necessary columns in a table)
     */
    protected int getFolderTree(Folder folder, Element xml_parent, boolean subscribed_only) {
	int depth=1;

	String id=generateFolderHash(folder);

	boolean holds_folders=false,holds_messages=false;
	Element xml_folder;
	try {
	    holds_folders=(folder.getType() & Folder.HOLDS_FOLDERS) == Folder.HOLDS_FOLDERS;
	    holds_messages=(folder.getType() & Folder.HOLDS_MESSAGES) == Folder.HOLDS_MESSAGES;
	    xml_folder=model.createFolder(id,folder.getName(),holds_folders,holds_messages);
	    if(folder.isSubscribed()) {
		xml_folder.setAttribute("subscribed","true");
	    } else {
		xml_folder.setAttribute("subscribed","false");
	    }
	} catch(MessagingException ex) {
	    xml_folder=model.createFolder(id,folder.getName(),holds_folders,holds_messages);
	    xml_folder.setAttribute("error",ex.getMessage());
	}


	folders.put(id,folder);


	try {
	    /* This folder can contain messages */
	    if(holds_messages) {

		Element messagelist=model.createMessageList();

		int total_messages=folder.getMessageCount();
		int new_messages=folder.getNewMessageCount();

		if((total_messages == -1 || new_messages == -1) || !folder.isOpen()) {
		    folder.open(Folder.READ_ONLY);
		    total_messages=folder.getMessageCount();
		    new_messages=folder.getNewMessageCount();
		}
		folder.close(false);

		messagelist.setAttribute("total",total_messages+"");
		messagelist.setAttribute("new",new_messages+"");
		xml_folder.appendChild(messagelist);
	    }
	} catch(MessagingException ex) {
	    xml_folder.setAttribute("error",ex.getMessage());
	}

	try {
	    /* There are subfolders, get them! */
	    if(holds_folders) {
		Folder[] subfolders;

		/* If the user only wanted to see subscribed folders, call listSubscribed 
		   otherwise call list() */
		if(subscribed_only) {
		    try {
			subfolders=folder.listSubscribed();
		    } catch(MessagingException ex) {
			System.err.println("Subscribe not supported");
			subfolders=folder.list();
		    }
		} else {
		    subfolders=folder.list();
		}
		int max_tree_depth=0;

		/* Recursiveley add subfolders to the XML model */
		for(int i=0;i<subfolders.length;i++) {
		    int tree_depth=getFolderTree(subfolders[i],xml_folder,subscribed_only);
		    if(tree_depth>max_tree_depth) {
			max_tree_depth=tree_depth;
		    }
		}
		depth+=max_tree_depth;
	    }
	} catch(MessagingException ex) {
	    xml_folder.setAttribute("error",ex.getMessage());
	}

	xml_parent.appendChild(xml_folder);
	return depth;
    }


    public void refreshFolderInformation() {
	refreshFolderInformation(false);
    }

    /**
     * Refresh Information about folders.
     * Tries to connect folders that are not yet connected.
     */
    public void refreshFolderInformation(boolean subscribed_only) {
	setEnv();
	if(folders==null) folders=new Hashtable();
	Folder cur_folder=null;
	String cur_mh_id="";
	Enumeration mailhosts=user.mailHosts();
	int max_depth=0;
	while(mailhosts.hasMoreElements()) {
	    cur_mh_id=(String)mailhosts.nextElement();

	    MailHostData mhd=user.getMailHost(cur_mh_id);
	    
	    URLName url=new URLName(mhd.getHostURL());
	    
	    Element mailhost=model.createMailhost(mhd.getName(),mhd.getID(),url.toString());
	    
	    int depth=0;

	    try {

		cur_folder=getRootFolder(cur_mh_id);		
			       
		
		/* Cannot unsubscribe root folder! */
		try {
		    cur_folder.setSubscribed(true);
		} catch(MessagingException ex) {
		    // Only IMAP supports subscription
		}

		/* Here we try to determine the remote IMAP or POP host. There is no problem if this fails
		   (it will most likely for POP3), so the exception is caught and not handled */
		try {
		    // Washington University
		    if(cur_folder.getFolder("~"+mhd.getLogin()+"/mail").exists()) {
			/* Washington University stores user mailboxes as
			 * ~user/mail/... */
			depth=getFolderTree(cur_folder.getFolder("INBOX"),mailhost, subscribed_only);
			if(depth>max_depth) {				
			    max_depth=depth;
			}
			depth=getFolderTree(cur_folder.getFolder("~"+mhd.getLogin()+"/mail"),mailhost, subscribed_only);
		    } 
		    /* Cyrus, Courier & Co have their folders beneath the INBOX */
		    else if(cur_folder.getFolder("INBOX").exists()) {
			depth=getFolderTree(cur_folder.getFolder("INBOX"),mailhost, subscribed_only);
		    }		    
		} /* If it didn't work it failed in the "if" statement, since "getFolderTree" doesn't throw exceptions
		     so what we want to do is to simply construct the folder tree for INBOX */
		catch(MessagingException ex) {
		    depth=getFolderTree(cur_folder.getFolder("INBOX"),mailhost, subscribed_only);
		}
	    } 
	    // Here a more serious exception has been caught (Connection failed)
	    catch(MessagingException ex) {
		mailhost.setAttribute("error",ex.getMessage());
		parent.getStorage().log(Storage.LOG_WARN,"Error connecting to mailhost ("+url.toString()+"): "+ex.getMessage());
	    }
		    
	    if(depth>max_depth) {
		max_depth=depth;
	    }

	    model.addMailhost(mailhost);

	}

	model.setStateVar("max folder depth",(1+max_depth)+"");
    }		

    public void refreshFolderInformation(String folderhash) {
	Folder folder=getFolder(folderhash);
	Element xml_folder=model.getFolder(folderhash);
	
	if(xml_folder.getAttribute("holds_messages").toLowerCase().equals("true")) {
	    try {
		Element messagelist=model.createMessageList();
		
		int total_messages=folder.getMessageCount();
		int new_messages=folder.getNewMessageCount();
		
		if((total_messages == -1 || new_messages == -1) && !folder.isOpen()) {
		    folder.open(Folder.READ_ONLY);
		    total_messages=folder.getMessageCount();
		    new_messages=folder.getNewMessageCount();
		}
		folder.close(false);
		
		messagelist.setAttribute("total",total_messages+"");
		messagelist.setAttribute("new",new_messages+"");

		model.removeMessageList(xml_folder);
		xml_folder.appendChild(messagelist);
	    
	    } catch(MessagingException ex) {
		xml_folder.setAttribute("error",ex.getMessage());
	    }
	}
	
    }

    /**
     * Try to subscribe to a folder (i.e. unhide it)
     */
    public void subscribeFolder(String folderhash) {
	Folder folder=getFolder(folderhash);
	
	// Only IMAP supports subscription...
	try {
	    folder.setSubscribed(true);
	} catch(MessagingException ex) {
	    //System.err.println("Folder subscription not supported");
	}
    }

    /**
     * Try to unsubscribe from a folder (i.e. hide it)
     */
    public void unsubscribeFolder(String folderhash) {
	Folder folder=getFolder(folderhash);
	
	// Only IMAP supports subscription...
	try {
	    folder.setSubscribed(false);
	} catch(MessagingException ex) {
	    //System.err.println("Folder subscription not supported");
	}
    }    

    /**
     * Subscribe all folders for a Mailhost 
     * Do it the non-recursive way: Uses a simple Queue :-)
     */
    public void setSubscribedAll(String id, boolean subscribed) throws MessagingException {
	Folder folder=getRootFolder(id);