/** * Check mail folder for an email using subject. * * @param emailSubject Email subject * @param folder mail folder to check for an email * @param protocol protocol used to connect to the server * @return whether mail received or not * @throws MessagingException if we're unable to connect to the store */ private static boolean isMailReceivedBySubject(String emailSubject, String folder, String protocol, GreenMailUser user) throws MessagingException { boolean emailReceived = false; Folder mailFolder; Store store = getConnection(user, protocol); try { mailFolder = store.getFolder(folder); mailFolder.open(Folder.READ_WRITE); SearchTerm searchTerm = new AndTerm(new SubjectTerm(emailSubject), new BodyTerm(emailSubject)); Message[] messages = mailFolder.search(searchTerm); for (Message message : messages) { if (message.getSubject().contains(emailSubject)) { log.info("Found the Email with Subject : " + emailSubject); emailReceived = true; break; } } } finally { if (store != null) { store.close(); } } return emailReceived; }
@Override protected long[] searchInternal(SearchTerm searchTerm) { List<SimpleStoredMessage> messages = getMessages(); long[] result = new long[messages.size()]; int i = 0; for (SimpleStoredMessage message : messages) { if (searchTerm.match(message.getMimeMessage())) { result[i] = message.getUid(); i++; } } return Arrays.copyOfRange(result, 0, i); }
public long[] search(SearchTerm searchTerm) { ArrayList matchedMessages = new ArrayList(); for (int i = 0; i < mailMessages.size(); i++) { SimpleStoredMessage message = (SimpleStoredMessage) mailMessages.get(i); if (searchTerm.match(message.getMimeMessage())) { matchedMessages.add(message); } } long[] matchedUids = new long[matchedMessages.size()]; for (int i = 0; i < matchedUids.length; i++) { SimpleStoredMessage storedMessage = (SimpleStoredMessage) matchedMessages.get(i); long uid = storedMessage.getUid(); matchedUids[i] = uid; } return matchedUids; }
private SearchTerm createFieldSearchTerm(String f) { switch (f.toLowerCase()) { case "from": return new FromStringTerm(matchingText); case "cc": return new RecipientStringTerm(Message.RecipientType.CC, matchingText); case "to": return new RecipientStringTerm(Message.RecipientType.TO, matchingText); case "body": return new BodyTerm(matchingText); case "subject": return new SubjectTerm(matchingText); default: return null; } }
@Test public void multipleFieldsShouldReturnOrTerm() { final Set fields = new HashSet(); fields.add("to"); fields.add("from"); fields.add("cc"); Rule rule = Rule.create() .sourceFolder("INBOX") .matchingText("testText") .fields(fields); SearchTerm term = rule.getSearchTerm(); Assert.assertTrue(term instanceof OrTerm); SearchTerm[] terms = ((OrTerm) term).getTerms(); for (SearchTerm t : terms) { Assert.assertTrue(t instanceof FromStringTerm || (t instanceof RecipientStringTerm && ((RecipientStringTerm) t).getRecipientType() == Message.RecipientType.CC) || (t instanceof RecipientStringTerm && ((RecipientStringTerm) t).getRecipientType() == Message.RecipientType.TO)); } }
/** * Check a particular email has received to a given email folder by email subject. * * @param emailSubject - Email emailSubject to find email is in inbox or not * @return - found the email or not * @throws ESBMailTransportIntegrationTestException - Is thrown if an error occurred while reading the emails */ public static boolean isMailReceivedBySubject(String emailSubject, String folder) throws ESBMailTransportIntegrationTestException { boolean emailReceived = false; Folder mailFolder; Store store = getConnection(); try { mailFolder = store.getFolder(folder); mailFolder.open(Folder.READ_WRITE); SearchTerm searchTerm = new AndTerm(new SubjectTerm(emailSubject), new BodyTerm(emailSubject)); Message[] messages = mailFolder.search(searchTerm); for (Message message : messages) { if (message.getSubject().contains(emailSubject)) { log.info("Found the email emailSubject : " + emailSubject); emailReceived = true; break; } } return emailReceived; } catch (MessagingException ex) { log.error("Error when getting mail count ", ex); throw new ESBMailTransportIntegrationTestException("Error when getting mail count ", ex); } finally { if (store != null) { try { store.close(); } catch (MessagingException e) { log.warn("Error when closing the store ", e); } } } }
public Message[] search(final SearchTerm term, final Message[] msgsToSearch) { final List<MockMessage> sms = new ArrayList<MockMessage>(); final List<Message> msgsToSearchL = new ArrayList<Message>(); if (msgsToSearch != null) { msgsToSearchL.addAll(Arrays.asList(msgsToSearch)); } for (final Message msg : getMessages()) { if (term != null && term.match(msg)) { if (msgsToSearch == null || msgsToSearchL.contains(msg)) { sms.add((MockMessage) msg); } } } return sms.toArray(new Message[sms.size()]); }
public MessageIterator(Folder folder, int batchSize) { try { this.folder = folder; this.batchSize = batchSize; SearchTerm st = getSearchTerm(); if (st != null) { doBatching = false; messagesInCurBatch = folder.search(st); totalInFolder = messagesInCurBatch.length; folder.fetch(messagesInCurBatch, fp); current = 0; LOG.info("Total messages : " + totalInFolder); LOG.info("Search criteria applied. Batching disabled"); } else { totalInFolder = folder.getMessageCount(); LOG.info("Total messages : " + totalInFolder); getNextBatch(batchSize, folder); } } catch (MessagingException e) { throw new DataImportHandlerException(DataImportHandlerException.SEVERE, "Message retreival failed", e); } }
@Override public long[] search(SearchTerm searchTerm) { List<StoredMessage> matchedMessages = new ArrayList<>(); synchronized (mailMessages) { for (int i = 0; i<mailMessages.size();i++) { StoredMessage mailMessage = mailMessages.get(i); // Update message sequence number for potential sequence set search // https://tools.ietf.org/html/rfc3501#page-10 mailMessage.updateMessageNumber(i+1); if (searchTerm.match(mailMessage.getMimeMessage())) { matchedMessages.add(mailMessage); } } } long[] matchedUids = new long[matchedMessages.size()]; for (int i = 0; i < matchedUids.length; i++) { StoredMessage storedMessage = matchedMessages.get(i); long uid = storedMessage.getUid(); matchedUids[i] = uid; } return matchedUids; }
@SuppressWarnings("serial") private Message[] getMessagesByIds(Folder notesFolder, final List<String> notes) throws Exception { return notesFolder.search(new SearchTerm() { @Override public boolean match(Message message) { try { for (String note: notes) { String[] id = message.getHeader(HeaderUtils.INOTES_ID_HEADER); if (id != null && note.equals(id[0])) { return true; } } return false; } catch (Exception e) { return false; } } }); }
/** * Searches the mailbox for messages that match the given searching criteria * * @param searchTerm - search term that contains search criteria. * @return UIDs of the messages */ public long[] search(final SearchTerm searchTerm) { CommandCallback<long[]> command = new CommandCallback<long[]>() { public long[] command() throws Throwable { return searchInternal(searchTerm); } }; return command.run(); }
private void extractSearchTermResultsToList(List<AlfrescoImapFolder> folders, SearchTerm searchTerm, ArrayList<Long> resList) { for (AlfrescoImapFolder folder : folders) { for (long l : folder.search(searchTerm)) { resList.add(l); } } }
public void doProcess(ImapRequestLineReader request, ImapResponse response, ImapSession session, boolean useUids) throws ProtocolException, FolderException { // Parse the search term from the request SearchTerm searchTerm = parser.searchTerm(request); parser.endLine(request); MailFolder folder = session.getSelected(); long[] uids = folder.search(searchTerm); StringBuffer idList = new StringBuffer(); for (int i = 0; i < uids.length; i++) { if (i > 0) { idList.append(SP); } long uid = uids[i]; if (useUids) { idList.append(uid); } else { int msn = folder.getMsn(uid); idList.append(msn); } } response.commandResponse(this, idList.toString()); boolean omitExpunged = (!useUids); session.unsolicitedResponses(response, omitExpunged); response.commandComplete(this); }
private SearchTerm extractSearchTerm(ImapRequestLineReader request) throws ProtocolException { StringBuilder sb = new StringBuilder(); trimFirstSpace(request); char next = request.nextChar(); if (next == '(') { return paren(request); } else { while (next != ' ' && next != '\r' && next != '\n' && next != ')') { sb.append(next); request.consume(); next = request.nextChar(); } } SearchTermBuilder b = SearchTermBuilder.create(sb.toString()); if (b.isExpressionParameter()) { extractParameterExpression(request, b); } extractParameters(request, b); return b.build(); }
private void extractParameterExpression(ImapRequestLineReader request, SearchTermBuilder builder) throws ProtocolException { while (builder.expectsParameter()) { SearchTerm st = extractSearchTerm(request); builder.addParameter(st); } }
/** * Some expressions can use brackets for complex parameters * @param request request * @return search term in brackets * @throws ProtocolException */ private SearchTerm paren(ImapRequestLineReader request) throws ProtocolException { request.consume(); SearchTerm resultTerm = null; char next = request.nextWordChar(); while (next != ')') { SearchTerm searchTerm = extractSearchTerm(request); resultTerm = (resultTerm == null ? searchTerm : new AndTerm(resultTerm, searchTerm)); next = request.nextWordChar(); } request.consume(); return resultTerm; }
@Override protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception { URI url = new URI(uri); // must use copy as each endpoint can have different options MailConfiguration config = getConfiguration().copy(); // only configure if we have a url with a known protocol config.configure(url); configureAdditionalJavaMailProperties(config, parameters); MailEndpoint endpoint = new MailEndpoint(uri, this, config); endpoint.setContentTypeResolver(contentTypeResolver); setProperties(endpoint.getConfiguration(), parameters); Map<String, Object> sstParams = IntrospectionSupport.extractProperties(parameters, "searchTerm."); if (!sstParams.isEmpty()) { // use SimpleSearchTerm as POJO to store the configuration and then convert that to the actual SearchTerm SimpleSearchTerm sst = new SimpleSearchTerm(); setProperties(sst, sstParams); SearchTerm st = MailConverters.toSearchTerm(sst, getCamelContext().getTypeConverter()); endpoint.setSearchTerm(st); } // sanity check that we know the mail server ObjectHelper.notEmpty(config.getHost(), "host"); ObjectHelper.notEmpty(config.getProtocol(), "protocol"); return endpoint; }
/** * @return Messages from input folder according to the search and sort criteria stored in the endpoint * @throws MessagingException If message retrieval fails */ private List<KeyValueHolder<String, Message>> retrieveMessages() throws MessagingException { List<KeyValueHolder<String, Message>> answer = new ArrayList<>(); Message[] messages; final SortTerm[] sortTerm = getEndpoint().getSortTerm(); final SearchTerm searchTerm = computeSearchTerm(); if (sortTerm != null && serverCanSort) { final IMAPFolder imapFolder = (IMAPFolder) folder; if (searchTerm != null) { // Sort and search using server capability messages = imapFolder.getSortedMessages(sortTerm, searchTerm); } else { // Only sort using server capability messages = imapFolder.getSortedMessages(sortTerm); } } else { if (searchTerm != null) { messages = folder.search(searchTerm, retrieveAllMessages()); } else { messages = retrieveAllMessages(); } // Now we can sort (emulate email sort but restrict sort terms) if (sortTerm != null) { MailSorter.sortMessages(messages, sortTerm); } } for (Message message : messages) { String key = getEndpoint().getMailUidGenerator().generateUuid(getEndpoint(), message); if (isValidMessage(key, message)) { answer.add(new KeyValueHolder<>(key, message)); } } return answer; }
/** * @return Search term from endpoint (including "seen" check) or null if there is no search term */ private SearchTerm computeSearchTerm() { if (getEndpoint().getSearchTerm() != null) { return getEndpoint().getSearchTerm(); } else if (getEndpoint().getConfiguration().isUnseen()) { return new SearchTermBuilder().unseen().build(); } return null; }
protected SearchTerm createSearchTerm() { // we just want the unseen Camel related mails SearchTermBuilder build = new SearchTermBuilder(); build.unseen().subject("Camel").body(Op.or, "Camel"); return build.build(); }
@Override protected SearchTerm createSearchTerm() { // we just want the unseen mails which is not spam SearchTermBuilder build = new SearchTermBuilder(); build.unseen().body(Op.not, "Spam").subject(Op.not, "Spam"); return build.build(); }
/** * Returns a <pre>{@link SearchTerm}</pre> to be used when retrieving messages. * Default term is only for unseen emails, but when retrieveSeenEmails is * set to true it returns a union of terms for both unseen and seen messages. * * @return a search term to be used for message retrieval. */ private SearchTerm getSearchTerm() { Flags seenFlag = new Flags(Flag.SEEN); FlagTerm unseenFlagTerm = new FlagTerm(seenFlag, false); if (retrieveSeenEmails) { FlagTerm seenFlagTerm = new FlagTerm(seenFlag, true); return new OrTerm(unseenFlagTerm, seenFlagTerm); } return unseenFlagTerm; }
@Override public JavaxMailMessage[] search(SearchTerm term) throws RuntimeMessagingException { try { return decorateMessageArray(delegate.search(term)); } catch (MessagingException e) { throw new RuntimeMessagingException(e); } }
@Override public JavaxMailMessage[] search(SearchTerm term, Message[] msgs) throws RuntimeMessagingException { try { return decorateMessageArray(delegate.search(term, msgs)); } catch (MessagingException e) { throw new RuntimeMessagingException(e); } }
@Override public boolean match(SearchTerm term) throws RuntimeMessagingException { try { return delegate.match(term); } catch (MessagingException e) { throw new RuntimeMessagingException(e); } }
public synchronized Message[] search(SearchTerm paramSearchTerm) throws MessagingException { if (paramSearchTerm instanceof FlagTerm) { FlagTerm flagTerm = (FlagTerm) paramSearchTerm; Flags flags = flagTerm.getFlags(); if (flags.equals(new Flags(Flags.Flag.SEEN))) { try { return getUnreadMessage(0); } catch (Exception e) { throw new MessagingException(e.getMessage(),e); } } } throw new MessagingException("Ews folder don't support search with search term " + paramSearchTerm); }
private SearchTerm extractSearchTerm(ImapRequestLineReader request) throws ProtocolException { StringBuilder sb = new StringBuilder(); trimFirstSpace(request); char next = request.nextChar(); if (next == '(') { return paren(request); } else { while (next != ' ' && next != '\n' && next != ')') { sb.append(next); request.consume(); next = request.nextChar(); } } SearchTermBuilder b = SearchTermBuilder.create(sb.toString()); if (b.isExpressionParameter()) { extractParameterExpression(request, b); } extractParameters(request, b); return b.build(); }
/** * 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; } }
