Java 类javax.mail.UIDFolder 实例源码

public void changeStatus( String folderName, long mailIDs[], Flags.Flag newFlag, boolean value ){
  try{

    Folder folderToUse = mailStore.getFolder(folderName);
    folderToUse.open( Folder.READ_WRITE );

    Flags f = new Flags();
    f.add( newFlag );

    Message mlist[];
    if ( folderToUse instanceof UIDFolder )
        mlist = ((UIDFolder)folderToUse).getMessagesByUID( mailIDs );
    else
        mlist = folderToUse.getMessages( returnToInts(mailIDs) );

    for ( int x=0; x < mlist.length; x++ )
        mlist[x].setFlags( f, value );

    folderToUse.close( true );
    setData( "succeeded",   cfBooleanData.TRUE );

  } catch (Exception E ){
    setData( "errortext",   new cfStringData( E.getMessage() ) );
    setData( "succeeded",   cfBooleanData.FALSE );
  }
}

public void markMessagesAsRead(String[] ids, boolean seen) throws NoSuchProviderException, MessagingException, IOException {
  IMAPFolder folder = (IMAPFolder)getStore().getFolder("Inbox");
  folder.open(Folder.READ_WRITE);
  UIDFolder uidFolder = folder;

  Message[] msgs;


  long[] uids = new long[ids.length];
  int i = 0;
  for (String s : ids) {
    try {
      uids[i++] = Long.parseLong(s);
    } catch (Exception ex) {
      Log.d("rgai", "", ex);
    }
  }
  // TODO: if instance not support UID, then use simple id
  msgs = uidFolder.getMessagesByUID(uids);

  folder.setFlags(msgs, new Flags(Flags.Flag.SEEN), seen);

  folder.close(false);
}

public void getMessage( cfImapConnection imapConnection, String rootFolder, long messageID, String _attachURI, String _attachDIR ) throws cfmRunTimeException {
    try{
        Folder  folderToList;

        if ( rootFolder == null || rootFolder.length() == 0 )
            folderToList = imapConnection.mailStore.getDefaultFolder();
        else
            folderToList = imapConnection.mailStore.getFolder(rootFolder);

        if ( (folderToList.getType() & Folder.HOLDS_MESSAGES) != 0){

            if ( !folderToList.isOpen() )
                folderToList.open( Folder.READ_ONLY );

            boolean bResult = false;
            if ( folderToList instanceof UIDFolder )    
                bResult = extractMessage( ((UIDFolder)folderToList).getMessageByUID( messageID ), messageID, _attachURI, _attachDIR );
            else
                bResult = extractMessage( folderToList.getMessage( (int)messageID ), messageID, _attachURI, _attachDIR );

            if ( !bResult ) imapConnection.setStatus( false, "Message does not exist" );
            else imapConnection.setStatus( true, "" );

            folderToList.close(false);
        }

    }catch(Exception E){
        imapConnection.setStatus( false, E.getMessage() );
    }
}

private MessageListResult getFlagChangesOfMessages(TreeSet<MessageListElement> loadedMessages) throws MessagingException {

  List<MessageListElement> emails = new LinkedList<MessageListElement>();
  Store store = getStore(account);

  if (store == null || !store.isConnected()) {
    return new MessageListResult(emails, MessageListResult.ResultType.ERROR);
  }
  IMAPFolder imapFolder = (IMAPFolder)store.getFolder(accountFolder.folder);
  imapFolder.open(Folder.READ_ONLY);
  UIDFolder uidFolder = imapFolder;

  long smallestUID = getSmallestUID(loadedMessages);

  Message messages[] = imapFolder.getMessagesByUID(smallestUID, UIDFolder.LASTUID);

  FlagTerm ft = new FlagTerm(new Flags(Flags.Flag.SEEN), false);
  Message unseenMsgs[] = imapFolder.search(ft, messages);

  addMessagesToListAs(uidFolder, emails, unseenMsgs, loadedMessages, false);

  // searching for seen messages
  List<Message> seenMessages = new ArrayList<Message>(Arrays.asList(messages));
  for (int k = 0; k < unseenMsgs.length; k++) {
    String unseenUid = Long.toString(uidFolder.getUID(unseenMsgs[k]));
    for (int l = 0; l < seenMessages.size(); ) {
      String seenUid = Long.toString(uidFolder.getUID(seenMessages.get(l)));
      if (seenUid.equals(unseenUid)) {
        seenMessages.remove(l);
      } else {
        l++;
      }
    }
  }

  addMessagesToListAs(uidFolder, emails, seenMessages.toArray(new Message[seenMessages.size()]), loadedMessages, true);

  imapFolder.close(false);

  return new MessageListResult(emails, MessageListResult.ResultType.FLAG_CHANGE);
}

private void addMessagesToListAs(UIDFolder folder, List<MessageListElement> emails, Message[] messages,
                                 TreeSet<MessageListElement> loadedMessages, boolean seen) throws MessagingException {
  for (int i = 0; i < messages.length; i++) {
    Message m = messages[i];
    if (m != null) {
      long uid = folder.getUID(m);
      MessageListElement testerElement = new MessageListElement(-1, Long.toString(uid), seen, null, null, account,
              Type.EMAIL, true);
      MessageListElement loadedMsg = MessageProvider.Helper.isMessageLoaded(loadedMessages, testerElement);
      if (loadedMsg != null) {
        testerElement.setDate(loadedMsg.getDate());
        emails.add(testerElement);
      }
    }
  }
}

@Override
public void markMessageAsRead(String id, boolean seen) throws NoSuchProviderException, MessagingException, IOException {

  IMAPFolder folder = (IMAPFolder)getStore().getFolder("Inbox");
  folder.open(Folder.READ_WRITE);
  UIDFolder uidFolder = (UIDFolder)folder;

  Message ms = uidFolder.getMessageByUID(Long.parseLong(id));

  if (ms != null) {
    ms.setFlag(Flags.Flag.SEEN, seen);
  }
  folder.close(false);
}

@Override
public MessageListResult getUIDListForMerge(String lowestStoredMessageUID) throws MessagingException {
  UIDFolder folder = getFolder();

  if (folder == null) {
    return null;
  }
  List<MessageListElement> mles = new LinkedList<MessageListElement>();
  Message[] messages = folder.getMessagesByUID(Long.parseLong(lowestStoredMessageUID), UIDFolder.LASTUID);
  for (int i = 0; i < messages.length; i++) {
    Message m = messages[i];
    if (m != null) {
      long uid = folder.getUID(m);
      MessageListElement testerElement = new MessageListElement(Long.toString(uid), account);
      mles.add(testerElement);
    }
  }
  return new MessageListResult(mles, MessageListResult.ResultType.MERGE_DELETE);
}

public void deleteMessage(String id) throws NoSuchProviderException, MessagingException, IOException {
  IMAPFolder folder = (IMAPFolder)getStore().getFolder("Inbox");
  folder.open(Folder.READ_WRITE);
  UIDFolder uidFolder = (UIDFolder)folder;

  Message ms = uidFolder.getMessageByUID(Long.parseLong(id));

  if (ms != null) {
    ms.setFlag(Flags.Flag.DELETED, true);
  }
  folder.close(true);
}

private void deleteMessagesFromServer( cfSession _Session ) throws cfmRunTimeException {

        //--[ Get Message Store
        Store popStore          = openConnection( _Session );

        //--[ Open up the Folder:INBOX and retrieve the headers
        Folder popFolder    = openFolder( _Session, popStore );

    try{
      Message[] listOfMessages  = popFolder.getMessages();
      FetchProfile fProfile = new FetchProfile();
      fProfile.add( FetchProfile.Item.ENVELOPE );

      if ( containsAttribute( "UID" ) ){
        String[] messageUIDList = getMessageUIDList( getDynamic(_Session,"UID").getString() );
        fProfile.add(UIDFolder.FetchProfileItem.UID);
        popFolder.fetch( listOfMessages, fProfile );

        for ( int x=0; x < listOfMessages.length; x++ ){
          if ( messageUIDValid( messageUIDList, getMessageUID( popFolder, listOfMessages[x] ) ) ){
            listOfMessages[x].setFlag( Flags.Flag.DELETED, true );
          }
        }

      }else if ( containsAttribute( "MESSAGENUMBER" ) ){
            int[] messageList   = getMessageList( getDynamic(_Session,"MESSAGENUMBER").getString() );
            popFolder.fetch( listOfMessages, fProfile );

            for ( int x=0; x < listOfMessages.length; x++ ){
                if ( messageIDValid(messageList, listOfMessages[x].getMessageNumber() ) ){
                    listOfMessages[x].setFlag( Flags.Flag.DELETED, true );
                }
            }

      }else{
        throw newRunTimeException( "Either MESSAGENUMBER or UID attribute must be specified when ACTION=DELETE" );
      }
    }catch(Exception ignore){}

    //--[ Close off the folder      
        closeFolder( popFolder );
        closeConnection( popStore );
    }

private void readMessages( cfSession _Session, Folder popFolder, cfQueryResultData popData, int _start, int _max, boolean GetAll, File attachmentDir )  throws cfmRunTimeException  {
  try{
    int maxRows = _max;
    int startRow = _start;
    String messageNumber = getDynamic(_Session,"MESSAGENUMBER").getString();
    boolean containsUID = containsAttribute( "UID" );
    boolean usingMessageNumber = messageNumber.length() > 0;
    int msgCount = popFolder.getMessageCount();

    // if MAXROWS is not specified, or UID or MESSAGENUMBER is, then we want to get all the messages
    if ( _max == -1 || containsUID || usingMessageNumber ){
        maxRows = msgCount;
    }
    if ( containsUID || usingMessageNumber ){
        startRow = 1;
    }

    if ( msgCount != 0 && startRow > msgCount ){
        throw newRunTimeException( "The value of STARTROW must not be greater than the total number of messages in the folder, " + popFolder.getMessageCount() + "." );
    }

    Message[] listOfMessages;
    if ( !usingMessageNumber ){
        listOfMessages = popFolder.getMessages();
    }else{
        listOfMessages = popFolder.getMessages( getMessageList( messageNumber ) );
    }

    FetchProfile fProfile = new FetchProfile();
    fProfile.add( FetchProfile.Item.ENVELOPE );
    fProfile.add(UIDFolder.FetchProfileItem.UID);
    popFolder.fetch( listOfMessages, fProfile );

    if ( containsUID ){
      String[] messageUIDList = getMessageUIDList( getDynamic(_Session,"UID").getString() );

      for ( int x=0; x < listOfMessages.length; x++ ){
        if ( messageUIDList.length == 0 || messageUIDValid( messageUIDList, getMessageUID( popFolder, listOfMessages[x] ) ) ){
          populateMessage( _Session, listOfMessages[x], popData, GetAll, attachmentDir, popFolder );
        }
      }
    }else{
            popFolder.fetch( listOfMessages, fProfile );
            int end = startRow -1 + maxRows;
            if ( end > listOfMessages.length ){
                end = listOfMessages.length;
            }
            for ( int x=startRow-1; x < end; x++ ){
                populateMessage( _Session, listOfMessages[x], popData, GetAll, attachmentDir, popFolder );
            }
    }
  }catch(Exception E){
    if ( E.getMessage() != null )
        throw newRunTimeException( E.getMessage() );
    else
      throw newRunTimeException( E.toString() );
  }

}

public synchronized Message[] getByIds(final long start, final long end/* final Folder folder*/) {
    checkExists();
    final List<MockMessage> sms = new ArrayList<MockMessage>();
    int num = 0;

    MockMessage lastMsg = null;

    for (final MockMessage mockMessage : new TreeSet<MockMessage>(messages.values())) {

        lastMsg = mockMessage;

        if (end == UIDFolder.LASTUID) {
            if (getMessageCount() != 1 && mockMessage.getMockid() < start) { // TODO
                                                                             // check?
                continue;
            }
        } else {
            if (mockMessage.getMockid() < start || mockMessage.getMockid() > end) {
                continue;
            }
        }

        mockMessage.setMessageNumber(++num);
        // mockMessage.setFolder(folder);
        sms.add(mockMessage);
    }

    if (end == UIDFolder.LASTUID && sms.size() == 0) {
        lastMsg.setMessageNumber(++num);
        // lastMsg.setFolder(folder);
        sms.add(lastMsg);
    }

    logger.debug("getByIds(" + start + "," + end + " for " + getFullName() + " returns " + sms.size());
    return sms.toArray(new Message[sms.size()]);
}

private long getNextUID(IMAPFolder folder, UIDFolder uidImapFolder, int messageCount) throws MessagingException {
  if (account.getAccountType().equals(MessageProvider.Type.GMAIL)) {
    return folder.getUIDNext();
  } else {
    int start = Math.max(1, messageCount);
    int end = start;
    Message messages[] = folder.getMessages(start, end);
    return uidImapFolder.getUID(messages[0]) + 1;
  }
}

public byte[] getAttachmentOfMessage(String messageId,
        String attachmentId, AttachmentProgressUpdate onProgressUpdate)
        throws NoSuchProviderException, MessagingException, IOException {

  IMAPFolder folder = (IMAPFolder)getStore().getFolder("Inbox");
  UIDFolder uidFolder = (UIDFolder)folder;
  folder.open(Folder.READ_ONLY);

  Message ms = uidFolder.getMessageByUID(Long.parseLong(messageId));

  byte[] data = getMessageAttachment(ms, attachmentId, onProgressUpdate);

  folder.close(false);

  return data;

}

private ProcessResult processMessageSlice(final int start, final int end, final String folderName) throws Exception {

        logger.debug("processMessageSlice() started with " + start + "/" + end + "/" + folderName);
        final long startTime = System.currentTimeMillis();
        final Store store = Session.getInstance(props).getStore();
        store.connect(user, password);
        final Folder folder = store.getFolder(folderName);
        final UIDFolder uidfolder = (UIDFolder) folder;

        IMAPUtils.open(folder);

        try {

            final Message[] msgs = folder.getMessages(start, end);
            folder.fetch(msgs, IMAPUtils.FETCH_PROFILE_HEAD);

            logger.debug("folder fetch done");

            long highestUid = 0;
            int processedCount = 0;

            for (final Message m : msgs) {
                try {

                    IMAPUtils.open(folder);
                    final long uid = uidfolder.getUID(m);

                    mailDestination.onMessage(m);

                    highestUid = Math.max(highestUid, uid);
                    processedCount++;

                    if (Thread.currentThread().isInterrupted()) {
                        break;
                    }

                } catch (final Exception e) {
                    stateManager.onError("Unable to make indexable message", m, e);
                    logger.error("Unable to make indexable message due to {}", e, e.toString());

                    IMAPUtils.open(folder);
                }
            }

            final long endTime = System.currentTimeMillis() + 1;
            final ProcessResult pr = new ProcessResult(highestUid, processedCount, endTime - startTime);
            logger.debug("processMessageSlice() ended with " + pr);
            return pr;

        } finally {

            IMAPUtils.close(folder);
            IMAPUtils.close(store);
        }

    }

private Map<String, cfData> extractMessage( Message Mess ){
    Map<String, cfData> HT  = new FastMap<String, cfData>();

try{
    HT.put( "subject",  new cfStringData( Mess.getSubject() ) );

    Folder parentFolder = Mess.getFolder();
    if ( parentFolder instanceof UIDFolder )
        HT.put( "id",   new cfNumberData( ((UIDFolder)parentFolder).getUID( Mess) ) );
    else
        HT.put( "id",   new cfNumberData( Mess.getMessageNumber() ) );

    //--[ Get the FROM field
    Address[] from  = Mess.getFrom();
    if ( from != null && from.length > 0 ){
        cfStructData sdFrom = new cfStructData();

        String name = ((InternetAddress)from[0]).getPersonal();
        if ( name != null )
                sdFrom.setData( "name", new cfStringData( name ) );

        sdFrom.setData( "email", new cfStringData( ((InternetAddress)from[0]).getAddress() ) );
        HT.put( "from", sdFrom );
    }

    //--[ Get the TO/CC/BCC field
    cfArrayData AD  = extractAddresses( Mess.getRecipients(Message.RecipientType.TO) );
    if ( AD != null )
        HT.put( "to", AD );
    else
      HT.put( "to", cfNullData.NULL );


    AD  = extractAddresses( Mess.getRecipients(Message.RecipientType.CC) );
    if ( AD != null )
        HT.put( "cc", AD );     
    else
      HT.put( "cc", cfNullData.NULL );

    AD  = extractAddresses( Mess.getRecipients(Message.RecipientType.BCC) );
    if ( AD != null )
        HT.put( "bcc", AD );
    else
      HT.put( "bcc", cfNullData.NULL );

    //--[ Set the flags
    HT.put( "answered", cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.ANSWERED ) ) );
    HT.put( "deleted",  cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.DELETED ) ) );
    HT.put( "draft",        cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.DRAFT ) ) );
    HT.put( "flagged",  cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.FLAGGED ) ) );
    HT.put( "recent",       cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.RECENT ) ) );
    HT.put( "seen",         cfBooleanData.getcfBooleanData( Mess.isSet( Flags.Flag.SEEN ) ) );

    HT.put( "size",         new cfNumberData( Mess.getSize() ) );
    HT.put( "lines",        new cfNumberData( Mess.getLineCount() ) );

    Date DD = Mess.getReceivedDate();
    if ( DD == null )
            HT.put( "rxddate",  new cfDateData( System.currentTimeMillis() ) );
      else
            HT.put( "rxddate",  new cfDateData( DD.getTime() ) );


    DD = Mess.getSentDate();
    if ( DD == null )
            HT.put( "sentdate",     new cfDateData( System.currentTimeMillis() ) );
      else
            HT.put( "sentdate",     new cfDateData( DD.getTime() ) );

}catch(Exception E){
  com.nary.Debug.printStackTrace( E );
}

return HT;        
}

private UIDFolder unwrapUIDFolder() {
    if (_folder instanceof UIDFolder) {
        return (UIDFolder) _folder;
    }
    throw new IllegalStateException("No UIDFolder supported by "+_folder.getClass());
}