/** * Marks messages as seen after receiving them. */ public ReceiverBuilder markSeen() { this.flagsToSet.add(Flags.Flag.SEEN); return this; }
/** * Deletes messages upon receiving. */ public ReceiverBuilder markDeleted() { this.flagsToSet.add(Flags.Flag.DELETED); return this; }
/** * Marks message with given flag. */ public ReceiverBuilder mark(final Flags.Flag flagToSet) { this.flagsToSet.add(flagToSet); return this; }
/** * Unmarks a message with given flag. */ public ReceiverBuilder unmark(final Flags.Flag flagToUnset) { this.flagsToUnset.add(flagToUnset); return this; }
/** * Receives all emails that matches given {@link EmailFilter} and * mark all messages as 'seen' and 'deleted'. * * @param filter {@link EmailFilter} * @return array of {@link ReceivedEmail}s. */ public ReceivedEmail[] receiveEmailAndDelete(final EmailFilter filter) { final Flags flags = new Flags(); flags.add(Flags.Flag.SEEN); flags.add(Flags.Flag.DELETED); return receiveMessages(filter, flags, null, false, null); }
/** * Defines filter for single flag. * * @param flag The flag to filter on. * @param value The {@link Flag} setting to check for. * @return this */ public EmailFilter flag(final Flag flag, final boolean value) { final Flags flags = new Flags(); flags.add(flag); return flags(flags, value); }
/** * Receives all emails that matches given {@link EmailFilter} * and mark them as 'seen' (ie 'read'). * * @param filter {@link EmailFilter} * @return array of {@link ReceivedEmail}s. */ public ReceivedEmail[] receiveEmailAndMarkSeen(final EmailFilter filter) { final Flags flagsToSet = new Flags(); flagsToSet.add(Flags.Flag.SEEN); return receiveMessages(filter, flagsToSet, null, false, null); }
/** * Set the flags for this message. <p> * * This implementation modifies the <code>flags</code> field. * * @exception IllegalWriteException if the underlying * implementation does not support modification * @exception IllegalStateException if this message is * obtained from a READ_ONLY folder. * @exception MessagingException for other failures */ public synchronized void setFlags(Flags flag, boolean set) throws MessagingException { if (set) flags.add(flag); else flags.remove(flag); }
/** * Set the flags for this message. <p> * * This implementation modifies the <code>flags</code> field. * * @exception IllegalWriteException if the underlying * implementation does not support modification * @exception IllegalStateException if this message is * obtained from a READ_ONLY folder. * @exception MessagingException for other failures */ @Override public synchronized void setFlags(Flags flag, boolean set) throws MessagingException { if (set) flags.add(flag); else flags.remove(flag); }
private void setMessageFlags(Message[] filteredMessages) throws MessagingException { boolean recentFlagSupported = false; Flags flags = getFolder().getPermanentFlags(); if (flags != null) { recentFlagSupported = flags.contains(Flags.Flag.RECENT); } for (Message message : filteredMessages) { if (!recentFlagSupported) { if (flags != null && flags.contains(Flags.Flag.USER)) { if (this.logger.isDebugEnabled()) { this.logger.debug("USER flags are supported by this mail server. Flagging message with '" + this.userFlag + "' user flag"); } Flags siFlags = new Flags(); siFlags.add(this.userFlag); message.setFlags(siFlags, true); } else { this.logger.debug("USER flags are not supported by this mail server. " + "Flagging message with system flag"); message.setFlag(Flags.Flag.FLAGGED, true); } } setAdditionalFlags(message); } }
public void validateSearchTermsWhenShouldMarkAsReadNoExistingFlagsGuts(String userFlag, ImapMailReceiver receiver) throws NoSuchFieldException, IllegalAccessException, InvocationTargetException { receiver.setShouldMarkMessagesAsRead(true); receiver.setBeanFactory(mock(BeanFactory.class)); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); when(folder.getPermanentFlags()).thenReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); Method compileSearchTerms = ReflectionUtils.findMethod(receiver.getClass(), "compileSearchTerms", Flags.class); compileSearchTerms.setAccessible(true); Flags flags = new Flags(); SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags); assertTrue(searchTerms instanceof NotTerm); NotTerm notTerm = (NotTerm) searchTerms; Flags siFlags = new Flags(); siFlags.add(userFlag); assertEquals(siFlags, ((FlagTerm) notTerm.getTerm()).getFlags()); }
private SearchTerm applyTermsWhenNoRecentFlag(Folder folder, SearchTerm searchTerm) { NotTerm notFlagged = null; if (folder.getPermanentFlags().contains(Flag.USER)) { if (logger.isDebugEnabled()) { logger.debug("This email server does not support RECENT flag, but it does support " + "USER flags which will be used to prevent duplicates during email fetch." + " This receiver instance uses flag: " + getUserFlag()); } Flags siFlags = new Flags(); siFlags.add(getUserFlag()); notFlagged = new NotTerm(new FlagTerm(siFlags, true)); } else { logger.debug("This email server does not support RECENT or USER flags. " + "System flag 'Flag.FLAGGED' will be used to prevent duplicates during email fetch."); notFlagged = new NotTerm(new FlagTerm(new Flags(Flag.FLAGGED), true)); } if (searchTerm == null) { return notFlagged; } else { return new AndTerm(searchTerm, notFlagged); } }
/** * Unmarks a message with given flag. */ public ReceiverBuilder unmark(final Flags.Flag flagToUnset) { this.flagsToUnset.add(flagToUnset); return this; }
public FlagsBuilder add(Flags.Flag... flags) { for (Flags.Flag flag : flags) { internalFlags.add(flag); } return this; }
@Test public void validateSearchTermsWhenShouldMarkAsReadWithExistingFlags() throws Exception { ImapMailReceiver receiver = new ImapMailReceiver(); receiver.setShouldMarkMessagesAsRead(true); receiver.setBeanFactory(mock(BeanFactory.class)); receiver.afterPropertiesSet(); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); when(folder.getPermanentFlags()).thenReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); Method compileSearchTerms = ReflectionUtils.findMethod(receiver.getClass(), "compileSearchTerms", Flags.class); compileSearchTerms.setAccessible(true); Flags flags = new Flags(); flags.add(Flag.ANSWERED); SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags); assertTrue(searchTerms instanceof AndTerm); AndTerm andTerm = (AndTerm) searchTerms; SearchTerm[] terms = andTerm.getTerms(); assertEquals(2, terms.length); NotTerm notTerm = (NotTerm) terms[0]; assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(Flag.ANSWERED)); notTerm = (NotTerm) terms[1]; Flags siFlags = new Flags(); siFlags.add(AbstractMailReceiver.DEFAULT_SI_USER_FLAG); assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(siFlags)); }
/** * Get the deleted message count. */ public synchronized int getDeletedMessageCount() throws MessagingException { if (!opened) { checkExists(); // no way to do this on closed folders return -1; } // if opened, issue server-side search for messages that do // have the DELETED flag. Flags f = new Flags(); f.add(Flags.Flag.DELETED); try { synchronized(messageCacheLock) { int[] matches = getProtocol().search(new FlagTerm(f, true)); return matches.length; // NOTE: 'matches' is never null } } catch (ConnectionException cex) { throw new FolderClosedException(this, cex.getMessage()); } catch (ProtocolException pex) { // Shouldn't happen throw new MessagingException(pex.getMessage(), pex); } }
/** * Get the deleted message count. */ @Override public synchronized int getDeletedMessageCount() throws MessagingException { if (!opened) { checkExists(); // no way to do this on closed folders return -1; } // if opened, issue server-side search for messages that do // have the DELETED flag. Flags f = new Flags(); f.add(Flags.Flag.DELETED); try { synchronized(messageCacheLock) { int[] matches = getProtocol().search(new FlagTerm(f, true)); return matches.length; // NOTE: 'matches' is never null } } catch (ConnectionException cex) { throw new FolderClosedException(this, cex.getMessage()); } catch (ProtocolException pex) { // Shouldn't happen throw new MessagingException(pex.getMessage(), pex); } }
f.add(Flags.Flag.SEEN); try { synchronized(messageCacheLock) {
f.add(Flags.Flag.SEEN); try { synchronized(messageCacheLock) {