/** * Sets {@link AndTerm} as searchTerm. * * @param searchTerm {@link SearchTerm} to set as AND. */ protected void and(final SearchTerm searchTerm) { if (this.searchTerm == null) { this.searchTerm = searchTerm; return; } this.searchTerm = new AndTerm(this.searchTerm, searchTerm); }
protected Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
protected Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
/** * Add search term. * * @param term * search term to add */ private void addSearchTerm( SearchTerm term ) { if ( this.searchTerm != null ) { this.searchTerm = new AndTerm( this.searchTerm, term ); } else { this.searchTerm = term; } }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Defines AND group of filters. * * @param emailFilters array of {@link EmailFilter}s to AND. * @return this */ public EmailFilter and(final EmailFilter... emailFilters) { final SearchTerm[] searchTerms = new SearchTerm[emailFilters.length]; for (int i = 0; i < emailFilters.length; i++) { searchTerms[i] = emailFilters[i].searchTerm; } concat(new AndTerm(searchTerms)); 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)); }
public void setReceivedDateTermBetween( Date beginDate, Date endDate ) { if ( this.protocol == MailConnectionMeta.PROTOCOL_POP3 ) { log.logError( BaseMessages.getString( PKG, "MailConnection.Error.ReceivedDatePOP3Unsupported" ) ); } else { addSearchTerm( new AndTerm( new ReceivedDateTerm( ComparisonTerm.LT, endDate ), new ReceivedDateTerm( ComparisonTerm.GT, beginDate ) ) ); } }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
@Test void testReceivedDate() { final EmailFilter emailFilter = EmailFilter.filter() .receivedDate(EmailFilter.Operator.EQ, 1524575533757L) .sentDate(EmailFilter.Operator.GT, 1524575533757L); final SearchTerm expected = new AndTerm( new ReceivedDateTerm(3, new Date(1524575533757L)), new SentDateTerm(5, new Date(1524575533757L)) ); assertEquals(expected, emailFilter.searchTerm); }
/** * append IMAP search term information from an AndTerm item. * * @param term The source AndTerm * @param charset target charset for the search information (can be null). * @param out The target command buffer. */ protected void appendAnd(AndTerm term, String charset) throws MessagingException { // ANDs are pretty easy. Just append all of the terms directly to the // command as is. SearchTerm[] terms = term.getTerms(); for (int i = 0; i < terms.length; i++) { appendSearchTerm(terms[i], charset); } }
@Test void testAnd2() { final EmailFilter emailFilter = filter() .from(FROM) .to(TO); final SearchTerm expected = new AndTerm( new FromStringTerm(FROM), new RecipientStringTerm(Message.RecipientType.TO, TO) ); assertEquals(expected, emailFilter.searchTerm); }
private static Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
@Test void testAndOrNot() { final EmailFilter emailFilter = filter() .from(FROM) .to(TO) .or() .not() .subject(SUBJECT) .from(FROM_2); final SearchTerm expected = new OrTerm( new OrTerm( new AndTerm( new FromStringTerm(FROM), new RecipientStringTerm(Message.RecipientType.TO, TO) ), new NotTerm( new SubjectTerm(SUBJECT) ) ), new FromStringTerm(FROM_2) ); assertEquals(expected, emailFilter.searchTerm); }
protected Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
@Test void testAndOrNotAlt() { final EmailFilter emailFilter = filter() .or( filter().and( filter().from(FROM), filter().to(TO) ), filter().not(filter().subject(SUBJECT)), filter().from(FROM_2) ); final SearchTerm expected = new OrTerm( new SearchTerm[]{ new AndTerm( new FromStringTerm(FROM), new RecipientStringTerm(Message.RecipientType.TO, TO) ), new NotTerm( new SubjectTerm(SUBJECT) ), new FromStringTerm(FROM_2) } ); assertEquals(expected, emailFilter.searchTerm); }
protected Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
private SearchTerm fromAndNotSeenTerm(Flags supportedFlags, Folder folder) { try { FromTerm fromTerm = new FromTerm(new InternetAddress("bar@baz")); return new AndTerm(fromTerm, new FlagTerm(new Flags(Flags.Flag.SEEN), false)); } catch (AddressException e) { throw new RuntimeException(e); } }
private static Argument and(AndTerm term, String charset) throws SearchException, IOException { // Combine the sequences for both terms SearchTerm[] terms = term.getTerms(); // Generate the search sequence for the first term Argument result = generateSequence(terms[0], charset); // Append other terms for (int i = 1; i < terms.length; i++) result.append(generateSequence(terms[i], charset)); return result; }
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); } }