Java 类javax.mail.Flags.Flag 实例源码

/**
 * Connect to the mail server and delete all mails.
 */
public void deleteMails() throws MessagingException {
    Folder folder = getStore().getFolder(MAIL_INBOX);
    folder.open(Folder.READ_WRITE);

    // Get folder's list of messages.
    Message[] messages = folder.getMessages();

    // Retrieve message headers for each message in folder.
    FetchProfile profile = new FetchProfile();
    profile.add(FetchProfile.Item.ENVELOPE);
    folder.fetch(messages, profile);

    for (Message message : messages) {
        message.setFlag(Flags.Flag.DELETED, true);
    }
    folder.close(true);

}

/**
 *  Creates the EML message in the specified folder.
 *  
 *  @param folderFileInfo The folder to create message in.
 *  @param message The original MimeMessage.
 *  @return ID of the new message created 
 * @throws FileNotFoundException 
 * @throws FileExistsException 
 * @throws MessagingException 
 * @throws IOException 
 */
private long createMimeMessageInFolder(
        FileInfo folderFileInfo,
        MimeMessage message,
        Flags flags)
        throws FileExistsException, FileNotFoundException, IOException, MessagingException 
{
    String name = AlfrescoImapConst.MESSAGE_PREFIX + GUID.generate();
    FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
    FileInfo messageFile = fileFolderService.create(folderFileInfo.getNodeRef(), name, ContentModel.TYPE_CONTENT);
    final long newMessageUid = (Long) messageFile.getProperties().get(ContentModel.PROP_NODE_DBID);
    name = AlfrescoImapConst.MESSAGE_PREFIX  + newMessageUid + AlfrescoImapConst.EML_EXTENSION;
    fileFolderService.rename(messageFile.getNodeRef(), name);
    Flags newFlags = new Flags(flags);
    newFlags.add(Flag.RECENT);
    imapService.setFlags(messageFile, newFlags, true);

    if (extractAttachmentsEnabled)
    {
        imapService.extractAttachments(messageFile.getNodeRef(), message);
    }
    // Force persistence of the message to the repository
    new IncomingImapMessage(messageFile, serviceRegistry, message);
    return newMessageUid;        
}

@Override
public void onRestoreNode(final ChildAssociationRef childAssocRef)
{
    doAsSystem(new RunAsWork<Void>()
    {
        @Override
        public Void doWork() throws Exception
        {
            NodeRef childNodeRef = childAssocRef.getChildRef();
            if (serviceRegistry.getDictionaryService().isSubClass(nodeService.getType(childNodeRef), ContentModel.TYPE_CONTENT))
            {
                setFlag(childNodeRef, Flags.Flag.DELETED, false);
                setFlag(childNodeRef, Flags.Flag.SEEN, false);
            }

            NodeRef folderRef = childAssocRef.getParentRef();
            long newId = (Long) nodeService.getProperty(childNodeRef, ContentModel.PROP_NODE_DBID);
            if (nodeService.hasAspect(folderRef, ImapModel.ASPECT_IMAP_FOLDER))
            {
                // Force generation of a new change token and updating the UIDVALIDITY 
                getUidValidityTransactionListener(folderRef).recordNewUid(newId);
            }
            return null;
        }
    });
}

protected void deleteMailsFromUserMailbox(final Properties props, final String folderName, final int start, final int deleteCount,
        final String user, final String password) throws MessagingException {
    final Store store = Session.getInstance(props).getStore();

    store.connect(user, password);
    checkStoreForTestConnection(store);
    final Folder f = store.getFolder(folderName);
    f.open(Folder.READ_WRITE);

    final int msgCount = f.getMessageCount();

    final Message[] m = deleteCount == -1 ? f.getMessages() : f.getMessages(start, Math.min(msgCount, deleteCount + start - 1));
    int d = 0;

    for (final Message message : m) {
        message.setFlag(Flag.DELETED, true);
        logger.info("Delete msgnum: {} with sid {}", message.getMessageNumber(), message.getSubject());
        d++;
    }

    f.close(true);
    logger.info("Deleted " + d + " messages");
    store.close();

}

public void changeMailStatus(int mailId, Flag flag, MailCredentials credentials) throws MessagingException {
    Properties properties = getServerProperties(credentials.getProtocol(), credentials.getHost(),
            "" + credentials.getPort());
    Session session = Session.getDefaultInstance(properties);

    // connects to the message store
    Store store = session.getStore(credentials.getProtocol());
    store.connect(credentials.getUsername(), credentials.getPassword());

    // opens the inbox folder
    Folder folderInbox = store.getFolder("INBOX");
    folderInbox.open(Folder.READ_WRITE);

    logger.debug("unread:" + folderInbox.getUnreadMessageCount() + ", new:" + folderInbox.getNewMessageCount());

    // fetches new messages from server
    int msgnum[] = new int[] { mailId };
    Message[] messages = folderInbox.getMessages(msgnum);

    if (messages.length == 1 && messages[0] != null) {
        messages[0].setFlag(flag, true);
    }

    folderInbox.close(false);
    store.close();
}

public void expungeMessage(FileInfo fileInfo)
{
    Flags flags = getFlags(fileInfo);
    if (flags.contains(Flags.Flag.DELETED))
    {
        // See MNT-12259
        //fileFolderService.delete(fileInfo.getNodeRef());
        hideAndDelete(fileInfo.getNodeRef());
        messageCache.remove(fileInfo.getNodeRef());
    }
}

/**
 * Set flags to the specified imapFolder.
 * 
 * @param messageInfo FileInfo of imap Folder.
 * @param flags flags to set.
 * @param value value to set.
 */
public void setFlags(FileInfo messageInfo, Flags flags, boolean value)
{
    checkForFlaggableAspect(messageInfo.getNodeRef());


    for (Flags.Flag flag : flags.getSystemFlags())
    {
        setFlag(messageInfo, flag, value);
    }
}

@Override
public void onRestoreNode(final ChildAssociationRef childAssocRef)
{
    doAsSystem(new RunAsWork<Void>()
    {
        @Override
        public Void doWork() throws Exception
        {
            NodeRef childNodeRef = childAssocRef.getChildRef();
            if (serviceRegistry.getDictionaryService().isSubClass(nodeService.getType(childNodeRef), ContentModel.TYPE_CONTENT))
            {
                setFlag(childNodeRef, Flags.Flag.DELETED, false);
                setFlag(childNodeRef, Flags.Flag.SEEN, false);
            }

            NodeRef folderRef = childAssocRef.getParentRef();
            long newId = (Long) nodeService.getProperty(childNodeRef, ContentModel.PROP_NODE_DBID);
            if (nodeService.hasAspect(folderRef, ImapModel.ASPECT_IMAP_FOLDER))
            {
                // Force generation of a new change token and updating the UIDVALIDITY 
                getUidValidityTransactionListener(folderRef).recordNewUid(newId);
            }
            return null;
        }
    });
}

/**
 * Moves the node <code>sourceNodeRef</code> extracted from the message id.
 * A part of a complex move operation.
 * 
 * @param folderInfo FileInfo
 * @param message MimeMessage
 * @param flags Flags
 * @param sourceNodeRef NodeRef
 * @return UUID of the moved node
 * @throws FileExistsException
 * @throws FileNotFoundException
 */
@SuppressWarnings("deprecation")
private long copyOrMoveNode(FileInfo folderInfo, MimeMessage message, Flags flags, NodeRef sourceNodeRef, boolean move)
        throws FileExistsException, FileNotFoundException
{
    FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
    FileFilterMode.setClient(FileFilterMode.Client.imap);
    FileInfo messageFile = null;
    if (move)
    {
        fileFolderService.setHidden(sourceNodeRef, false);
        messageFile = fileFolderService.move(sourceNodeRef, folderInfo.getNodeRef(), null);
    }
    else
    {
        NodeRef newNodeRef = serviceRegistry.getCopyService().copyAndRename(sourceNodeRef, folderInfo.getNodeRef(), ContentModel.ASSOC_CONTAINS, null, false);
        fileFolderService.setHidden(newNodeRef, false);
        messageFile = fileFolderService.getFileInfo(newNodeRef);
    }
    final long newMessageUid = (Long) messageFile.getProperties().get(ContentModel.PROP_NODE_DBID);

    imapService.persistMessageHeaders(messageFile.getNodeRef(), message);

    Flags newFlags = new Flags(flags);
    newFlags.add(Flag.RECENT);

    imapService.setFlags(messageFile, newFlags, true);
    imapService.setFlag(messageFile, Flag.DELETED, false);

    return newMessageUid;
}

/**
 * Marks all messages in the folder as deleted using {@link javax.mail.Flags.Flag#DELETED} flag.
 */
@Override
public void deleteAllMessagesInternal() throws FolderException
{
    if (isReadOnly())
    {
        throw new FolderException("Can't delete all - Permission denied");
    }

    for (Map.Entry<Long, FileInfo> entry : searchMails().entrySet())
    {
        imapService.setFlag(entry.getValue(), Flags.Flag.DELETED, true);
        // comment out to physically remove content.
        // fileFolderService.delete(fileInfo.getNodeRef());
    }
}

/**
 * Returns the list of messages that have no {@link javax.mail.Flags.Flag#DELETED} flag set for current user.
 * 
 * @return the list of non-deleted messages.
 */
@Override
protected List<SimpleStoredMessage> getNonDeletedMessagesInternal()
{
    if (logger.isDebugEnabled())
    {
        logger.debug("[getNonDeletedMessagesInternal] " + this);
    }
    List<SimpleStoredMessage> result = new ArrayList<SimpleStoredMessage>();

    Collection<SimpleStoredMessage> values = getMessagesInternal();
    for (SimpleStoredMessage message : values)
    {
        if (!getFlags(message).contains(Flags.Flag.DELETED))
        {
            result.add(message);
        }

    }
    if (logger.isDebugEnabled() && folderInfo != null)
    {
        logger.debug(folderInfo.getName() + " - Non deleted messages count:" + result.size());
    }
    return result;
}

/**
 * Returns count of messages with {@link javax.mail.Flags.Flag#RECENT} flag.
 * If {@code reset} parameter is {@code true} - removes {@link javax.mail.Flags.Flag#RECENT} flag from
 * the message for current user.
 * 
 * @param reset - if true the {@link javax.mail.Flags.Flag#RECENT} will be deleted for current user if exists.
 * @return returns count of recent messages.
 */
@Override
public int getRecentCount(boolean reset)
{
    int recent = getFolderStatus().recentCount;
    if (reset && recent > 0)
    {
        CommandCallback<Void> command = new CommandCallback<Void>()
        {
            public Void command() throws Throwable
            {
                for (FileInfo fileInfo : folderStatus.search.values())
                {
                    Flags flags = imapService.getFlags(fileInfo);
                    if (flags.contains(Flags.Flag.RECENT))
                    {
                        imapService.setFlag(fileInfo, Flags.Flag.RECENT, false);
                    }
                }
                return null;
            }
        };
        try
        {
            command.run();
        }
        catch (AccessDeniedException ade)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Access denied to reset RECENT FLAG");
            }
        }
    }
    return recent;        
}

@Test
public void deleteMailById() throws MessagingException {

  MimeMessage[] mails = greenMail.getReceivedMessages();
  String messageId = mails[0].getMessageID();

  MailConnectors.deleteMails()
    .createRequest()
      .folder("INBOX")
      .messageIds(messageId)
    .execute();

  mails = greenMail.getReceivedMessages();
  assertThat(mails).hasSize(2);
  assertThat(mails[0].isSet(Flag.DELETED)).isTrue();
  assertThat(mails[1].isSet(Flag.DELETED)).isFalse();
}

@Test
public void folderFromConfiguration() throws MessagingException {

  MailConnectors.deleteMails()
    .createRequest()
      .messageNumbers(1)
    .execute();

  MimeMessage[] mails = greenMail.getReceivedMessages();
  assertThat(mails).hasSize(2);
  assertThat(mails[0].isSet(Flag.DELETED)).isTrue();
  assertThat(mails[1].isSet(Flag.DELETED)).isFalse();
}

/**
 * Connect to the mail server and delete all mails.
 */
public void deleteMails() throws MessagingException {
    Folder folder = getStore().getFolder(MAIL_INBOX);
    folder.open(Folder.READ_WRITE);

    // Get folder's list of messages.
    Message[] messages = folder.getMessages();

    // Retrieve message headers for each message in folder.
    FetchProfile profile = new FetchProfile();
    profile.add(FetchProfile.Item.ENVELOPE);
    folder.fetch(messages, profile);

    for (Message message : messages) {
        message.setFlag(Flags.Flag.DELETED, true);
    }
    folder.close(true);

}

private boolean verifyMail(final String sender, final String subject) {
    LOG.info("Waiting for notification to be sent...");
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
    }

    boolean found = false;
    try {
        Session session = Session.getDefaultInstance(
                System.getProperties());
        Store store = session.getStore("pop3");
        store.connect(pop3Host, mailAddress, mailPassword);

        Folder inbox = store.getFolder("INBOX");
        assertNotNull(inbox);
        inbox.open(Folder.READ_WRITE);

        Message[] messages = inbox.getMessages();
        for (int i = 0; i < messages.length; i++) {
            if (sender.equals(messages[i].getFrom()[0].toString())
                    && subject.equals(messages[i].getSubject())) {

                found = true;
                messages[i].setFlag(Flag.DELETED, true);
            }
        }
        inbox.close(true);
        store.close();
    } catch (Throwable t) {
        LOG.error("Unexpected exception", t);
        fail("Unexpected exception while fetching e-mail");
    }

    return found;
}

private void markMessageRead(List<EwsMessage> messagesRead) throws MessagingException, Exception,
  ServiceResponseException {
    if (messagesRead == null || messagesRead.isEmpty())
        return;
    for (EwsMessage aMessage : messagesRead) {
        EmailMessage aRawMessage = aMessage.getEmailMessage();

        if (aMessage.getFlags().contains(Flag.SEEN)) {
            aRawMessage.setIsRead(Boolean.TRUE);
        } else {
            aRawMessage.setIsRead(Boolean.FALSE);
        }

        aRawMessage.update(CONFLICT_RESOLUTION_MODE);
    }
}

private Message[] deleteMessages(List<EwsMessage> messagesToDelete) throws MessagingException {
    if (messagesToDelete == null || messagesToDelete.isEmpty())
        return new Message[] {};
    List<EwsMessage> lDeletedMessages = new ArrayList<EwsMessage>();
    for (int i = messagesToDelete.size() - 1; i >= 0; i--) {
        EwsMessage aMessage = messagesToDelete.get(i);
        if (aMessage.getFlags().contains(Flag.DELETED)) {
            try {
                EmailMessage aRawMessage = aMessage.getEmailMessage();
                aRawMessage.delete(DELETE_MODE);
            } catch (Exception e) {
                throw new MessagingException(e.getMessage(), e);
            }
            lDeletedMessages.add(aMessage);
            messagesToDelete.remove(i);
        }
    }
    Message[] retValue = lDeletedMessages.toArray(new Message[0]);
    if (retValue.length > 0) {
        notifyMessageRemovedListeners(true, retValue);
    }
    return retValue;
}

@Override
public void treatMessage(Message message) throws Exception
{
    String sender = InternetAddress.toString(message.getFrom());
    String subject = message.getSubject();
    if (sender.contains("leboncoin.fr") && subject.contains("Activez votre annonce"))
    {
        Logger.traceINFO("Found confirmation mail - " + subject);
        String url = extractConfirmationUrl(message.getContent().toString());

        Logger.traceINFO("Sending confirmation : " + url);
        HtmlPage confirmationPage = Client.get().getPage(url);
        String confirmationStr = confirmationPage.asXml();

        if (confirmationStr.contains("Vous nous avez d�j� envoy� une confirmation"))
        {
            Logger.traceERROR("Mail already confirmed. This is a huge error.");
        }

        Logger.traceINFO("Confirmation sent for mail - " + subject);
        message.setFlag(Flag.SEEN, true);
    }
}

public void expungeMessage(FileInfo fileInfo)
{
    Flags flags = getFlags(fileInfo);
    if (flags.contains(Flags.Flag.DELETED))
    {
        // See MNT-12259
        //fileFolderService.delete(fileInfo.getNodeRef());
        hideAndDelete(fileInfo.getNodeRef());
        messageCache.remove(fileInfo.getNodeRef());
    }
}

/**
 * Set flags to the specified imapFolder.
 * 
 * @param messageInfo FileInfo of imap Folder.
 * @param flags flags to set.
 * @param value value to set.
 */
public void setFlags(FileInfo messageInfo, Flags flags, boolean value)
{
    checkForFlaggableAspect(messageInfo.getNodeRef());


    for (Flags.Flag flag : flags.getSystemFlags())
    {
        setFlag(messageInfo, flag, value);
    }
}

/**
 * Moves the node <code>sourceNodeRef</code> extracted from the message id.
 * A part of a complex move operation.
 * 
 * @param folderInfo FileInfo
 * @param message MimeMessage
 * @param flags Flags
 * @param sourceNodeRef NodeRef
 * @return UUID of the moved node
 * @throws FileExistsException
 * @throws FileNotFoundException
 */
@SuppressWarnings("deprecation")
private long copyOrMoveNode(FileInfo folderInfo, MimeMessage message, Flags flags, NodeRef sourceNodeRef, boolean move)
        throws FileExistsException, FileNotFoundException
{
    FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
    FileFilterMode.setClient(FileFilterMode.Client.imap);
    FileInfo messageFile = null;
    if (move)
    {
        fileFolderService.setHidden(sourceNodeRef, false);
        messageFile = fileFolderService.move(sourceNodeRef, folderInfo.getNodeRef(), null);
    }
    else
    {
        NodeRef newNodeRef = serviceRegistry.getCopyService().copyAndRename(sourceNodeRef, folderInfo.getNodeRef(), ContentModel.ASSOC_CONTAINS, null, false);
        fileFolderService.setHidden(newNodeRef, false);
        messageFile = fileFolderService.getFileInfo(newNodeRef);
    }
    final long newMessageUid = (Long) messageFile.getProperties().get(ContentModel.PROP_NODE_DBID);

    imapService.persistMessageHeaders(messageFile.getNodeRef(), message);

    Flags newFlags = new Flags(flags);
    newFlags.add(Flag.RECENT);

    imapService.setFlags(messageFile, newFlags, true);
    imapService.setFlag(messageFile, Flag.DELETED, false);

    return newMessageUid;
}

/**
 * Marks all messages in the folder as deleted using {@link javax.mail.Flags.Flag#DELETED} flag.
 */
@Override
public void deleteAllMessagesInternal() throws FolderException
{
    if (isReadOnly())
    {
        throw new FolderException("Can't delete all - Permission denied");
    }

    for (Map.Entry<Long, FileInfo> entry : searchMails().entrySet())
    {
        imapService.setFlag(entry.getValue(), Flags.Flag.DELETED, true);
        // comment out to physically remove content.
        // fileFolderService.delete(fileInfo.getNodeRef());
    }
}

/**
 * Returns the list of messages that have no {@link javax.mail.Flags.Flag#DELETED} flag set for current user.
 * 
 * @return the list of non-deleted messages.
 */
@Override
protected List<SimpleStoredMessage> getNonDeletedMessagesInternal()
{
    if (logger.isDebugEnabled())
    {
        logger.debug("[getNonDeletedMessagesInternal] " + this);
    }
    List<SimpleStoredMessage> result = new ArrayList<SimpleStoredMessage>();

    Collection<SimpleStoredMessage> values = getMessagesInternal();
    for (SimpleStoredMessage message : values)
    {
        if (!getFlags(message).contains(Flags.Flag.DELETED))
        {
            result.add(message);
        }

    }
    if (logger.isDebugEnabled() && folderInfo != null)
    {
        logger.debug(folderInfo.getName() + " - Non deleted messages count:" + result.size());
    }
    return result;
}

/**
 * Returns count of messages with {@link javax.mail.Flags.Flag#RECENT} flag.
 * If {@code reset} parameter is {@code true} - removes {@link javax.mail.Flags.Flag#RECENT} flag from
 * the message for current user.
 * 
 * @param reset - if true the {@link javax.mail.Flags.Flag#RECENT} will be deleted for current user if exists.
 * @return returns count of recent messages.
 */
@Override
public int getRecentCount(boolean reset)
{
    int recent = getFolderStatus().recentCount;
    if (reset && recent > 0)
    {
        CommandCallback<Void> command = new CommandCallback<Void>()
        {
            public Void command() throws Throwable
            {
                for (FileInfo fileInfo : folderStatus.search.values())
                {
                    Flags flags = imapService.getFlags(fileInfo);
                    if (flags.contains(Flags.Flag.RECENT))
                    {
                        imapService.setFlag(fileInfo, Flags.Flag.RECENT, false);
                    }
                }
                return null;
            }
        };
        try
        {
            command.run();
        }
        catch (AccessDeniedException ade)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Access denied to reset RECENT FLAG");
            }
        }
    }
    return recent;        
}

public synchronized Message[] expunge() throws MessagingException {
    checkExists();
    final List<Message> expunged = new ArrayList<Message>();
    for (final Message msg : getByFlags(new Flags(Flag.DELETED), true)) {

        expunged.add(messages.remove(((MockMessage) msg).getMockid()));
        ((MockMessage) msg).setExpunged(true);

        for (final MailboxEventListener mailboxEventListener : mailboxEventListeners) {
            mailboxEventListener.messageExpunged(this, (MockMessage) msg, true);
        }
    }

    logger.debug(expunged.size() + " messages expunged (deleted) from" + getFullName());
    return expunged.toArray(new Message[expunged.size()]);

}

/**
 * Sets flags for this message. Flags not explicitly stored in metadata
 * will be kept in-memory.
 * @param flag The current state of flags for this message.
 */
@Override
public synchronized void setFlags(Flags flag, boolean set) throws MessagingException {
    if (flag.contains(Flag.RECENT))
        setRecent(set);
    if (flag.contains(Flag.SEEN))
        setUnread(!set);
    if (flag.contains(Flag.ANSWERED))
        setReplied(set);
    if (flag.contains(Flag.DELETED))
        setDeleted(set);
    super.setFlags(flag, set);
}

/**
 * Updates in-memory flags from stored metadata and returns them.
 */
@Override
public Flags getFlags() throws MessagingException {
    super.setFlag(Flag.RECENT, isRecent());
    super.setFlag(Flag.SEEN, !isUnread());
    super.setFlag(Flag.ANSWERED, isReplied());
    super.setFlag(Flag.DELETED, isDeleted());
    return super.getFlags();
}

private void doDeleteMessages(final Folder folder, final Collection<Message> messages) {
    List<Message> messagesFiltered = FluentIterable.from(messages).filter(MessagePredicates.forRecipient(mailAccount.getAddress()))
            .toList();
    if (messagesFiltered.isEmpty()) {
        return;
    }

    try {
        log.debug("Flagging {} message(s) for deletion", messagesFiltered.size());
        for (Message message : messagesFiltered) {
            message.setFlag(Flag.DELETED, true);
        }
        folder.close(true);
        log.debug("Expunged {} message(s)", messagesFiltered.size());
    } catch (MessagingException ex) {
        throw new MailException("Error deleting e-mail message", ex);
    }
}

/**
 * Writes mailbox to mbox format
 */
public void writeMailBoxToFile(String outputDirectory)
{
    try
    {
        PrintWriter out = new PrintWriter(new FileWriter(
                outputDirectory + File.separator + mailBoxID + ".mbox", 
                false));

        for (StoredSmtpMessage msg : mails.values())
        {
            if (!msg.getFlags().contains(Flag.DELETED))
                StreamUtilities.writeMessageToMBoxRDFormat(msg, out);
        }
        out.close();
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
}

public List<Mail> getNewEmails(MailCredentials credentials) throws MessagingException, IOException {
    Properties properties = getServerProperties(credentials.getProtocol(), credentials.getHost(),
            "" + credentials.getPort());
    Session session = Session.getDefaultInstance(properties);

    // connects to the message store
    Store store = session.getStore(credentials.getProtocol());
    store.connect(credentials.getUsername(), credentials.getPassword());

    logger.debug("url:" + store.getURLName());
    // opens the inbox folder
    Folder folderInbox = store.getFolder("INBOX");
    folderInbox.open(Folder.READ_ONLY);

    logger.debug("unread:" + folderInbox.getUnreadMessageCount() + ", new:" + folderInbox.getNewMessageCount());

    // fetches new messages from server
    FlagTerm ft = new FlagTerm(new Flags(Flags.Flag.SEEN), false);
    Message messages[] = folderInbox.search(ft);

    List<Mail> mails = getMails(messages);

    // disconnect
    folderInbox.close(false);
    store.close();
    return Lists.reverse(mails);
}

private List<String> getFlags(Message msg) throws MessagingException {
    List<String> returnedFlags = new ArrayList<String>();
    Flags flags = msg.getFlags();
    if (flags.contains(Flag.ANSWERED)) {
        returnedFlags.add("answered");
    } else if (flags.contains(Flag.DELETED)) {
        returnedFlags.add("deleted");
    } else if (flags.contains(Flag.DRAFT)) {
        returnedFlags.add("draft");
    } else if (flags.contains(Flag.RECENT)) {
        returnedFlags.add("new");
    } else if (flags.contains(Flag.SEEN)) {
        returnedFlags.add("seen");
    }
    return returnedFlags;

}

@Override
public void onCreateChildAssociation(final ChildAssociationRef childAssocRef, boolean isNewNode)
{
    doAsSystem(new RunAsWork<Void>()
    {
        @Override
        public Void doWork() throws Exception
        {
            NodeRef childNodeRef = childAssocRef.getChildRef();

            if (serviceRegistry.getDictionaryService().isSubClass(nodeService.getType(childNodeRef), ContentModel.TYPE_CONTENT))
            {
                long newId = (Long) nodeService.getProperty(childNodeRef, ContentModel.PROP_NODE_DBID);
                // Keep a record of minimum and maximum node IDs in this folder in this transaction and add a listener that will
                // update the UIDVALIDITY and MAXUID properties appropriately. Also force generation of a new change token
                getUidValidityTransactionListener(childAssocRef.getParentRef()).recordNewUid(newId);
                // Flag new content as recent
                setFlag(childNodeRef, Flags.Flag.RECENT, true);
            }

            if (logger.isDebugEnabled())
            {
                logger.debug("[onCreateChildAssociation] Association " + childAssocRef + " created. CHANGETOKEN will be changed.");
            }
            return null;
        }
    });
}

public String[] readPassAndKeyFromEmail(boolean delete, String userName)
        throws MessagingException {
    // Download message headers from server.
    int retries = 0;
    String userPass = null;
    String userKey = null;
    while (retries < 40 && userPass == null) {

        // Open main "INBOX" folder.
        Folder folder = getStore().getFolder(MAIL_INBOX);
        folder.open(Folder.READ_WRITE);

        // Get folder's list of messages.
        Message[] messages = folder.getMessages();

        // Retrieve message headers for each message in folder.
        FetchProfile profile = new FetchProfile();
        profile.add(FetchProfile.Item.ENVELOPE);
        folder.fetch(messages, profile);

        for (Message message : messages) {
            if (message.getSubject().equals(MAIL_SUBJECT_USER_ACCOUNT_CREATED_EN)) {
                String content = getMessageContent(message);
                String userNameFromEmail = readInformationFromGivenMail(MAIL_BODY_USERNAME_PATTERN_EN, content);
                if (userName.equals(userNameFromEmail)) {
                    userKey = readInformationFromGivenMail(MAIL_BODY_USERKEY_PATTERN_EN, content);
                    userPass = readInformationFromGivenMail(MAIL_BODY_PASSWORD_PATTERN_EN, content);
                    if (delete) {
                        message.setFlag(Flag.DELETED, true);
                    }
                    break;
                }
            }
        }
        folder.close(true);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // ignored
        }
        retries++;
    }

    return new String[] {userKey, userPass};
}

/**
 * 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);
}

@Override
public Object invokeTarget() throws Exception {
  // poll only messages which are not deleted
  Message[] messages = target.search(new FlagTerm(new Flags(Flag.DELETED), false));

  return Arrays.asList(messages);
}

@Override
public Object invokeTarget() throws Exception {

  for (Message message : target) {
    message.setFlag(Flag.DELETED, true);
  }

  return null;
}

@Test
@Deployment(resources = "processes/mail-delete.bpmn")
public void deleteMailById() throws MessagingException {

  MimeMessage[] mails = greenMail.getReceivedMessages();
  String messageId = mails[0].getMessageID();

  engineRule.getRuntimeService().startProcessInstanceByKey("delete-mail",
      Variables.createVariables().putValue("messageId", messageId));

  mails = greenMail.getReceivedMessages();
  assertThat(mails).hasSize(2);
  assertThat(mails[0].isSet(Flag.DELETED)).isTrue();
  assertThat(mails[1].isSet(Flag.DELETED)).isFalse();
}