public static Builder builderFromMessageResult(MessageResult messageResult) throws MailboxException { Builder builder = builder() .uid(messageResult.getUid()) .modSeq(messageResult.getModSeq()) .size(messageResult.getSize()) .internalDate(messageResult.getInternalDate().toInstant()) .attachments(messageResult.getAttachments()) .mailboxId(messageResult.getMailboxId()); try { return builder.content(messageResult.getFullContent().getInputStream()); } catch (IOException e) { throw new MailboxException("Can't get message full content: " + e.getMessage(), e); } }
@Override public long size() throws MailboxException { return result.getHeaders().size(); }
private Stream<MailboxException> updateFlags(MessageId messageId, UpdateMessagePatch updateMessagePatch, MailboxSession mailboxSession, MessageResult messageResult) { try { if (!updateMessagePatch.isFlagsIdentity()) { messageIdManager.setFlags( updateMessagePatch.applyToState(messageResult.getFlags()), FlagsUpdateMode.REPLACE, messageId, ImmutableList.of(messageResult.getMailboxId()), mailboxSession); } return Stream.of(); } catch (MailboxException e) { return Stream.of(e); } }
private Iterator<MessageResult.Header> getHeaders(MessageResult messageResult, int[] path, boolean isBase) throws MailboxException { final Iterator<MessageResult.Header> headers; if (isBase) { headers = messageResult.getHeaders().headers(); } else { MessageResult.MimePath mimePath = new MimePathImpl(path); headers = messageResult.iterateHeaders(mimePath); } return headers; }
private MailImpl buildMailFromMessage(MessageResult message) throws MessagingException, IOException, MailboxException { return MailImpl.fromMimeMessage(message.getMessageId().serialize(), new MimeMessage( Session.getDefaultInstance(new Properties()), message.getFullContent().getInputStream())); }
public FetchResponse build(FetchData fetch, MessageResult result, MessageManager mailbox, ImapSession session, boolean useUids) throws MessageRangeException, MailboxException { final SelectedMailbox selected = session.getSelected(); final long resultUid = result.getUid(); final int resultMsn = selected.msn(resultUid); final Flags resultFlags = result.getFlags(); if (fetch.isSetSeen() && !resultFlags.contains(Flags.Flag.SEEN)) { mailbox.setFlags(new Flags(Flags.Flag.SEEN), true, false, MessageRange.one(resultUid), mailboxSession); setInternalDate(result.getInternalDate()); setSize(result.getSize()); body = new MimeDescriptorStructure(false, result.getMimeDescriptor(), envelopeBuilder); bodystructure = new MimeDescriptorStructure(true, result.getMimeDescriptor(), envelopeBuilder); if (changedSince != -1) { if (changedSince < result.getModSeq()) { setModSeq(result.getModSeq()); setModSeq(result.getModSeq());
while (it.hasNext()) { MessageResult mr = it.next(); final MessageUid uid = mr.getUid(); int msn = selected.msn(uid); if (msn == SelectedMailbox.NO_SUCH_MESSAGE) { boolean condstoreEnabled = EnableProcessor.getEnabledCapabilities(session).contains(ImapConstants.SUPPORTS_CONDSTORE); final Flags flags = mr.getFlags(); final MessageUid uidOut; if (useUid || qresyncEnabled) { response = new FetchResponse(msn, flags, uidOut, mr.getModSeq(), null, null, null, null, null, null); } else { response = new FetchResponse(msn, flags, uidOut, null, null, null, null, null, null, null);
@Override public List<MessageMetaData> getMessages() throws IOException { try { mailboxManager.startProcessingRequest(session); Iterator<MessageResult> results = manager.getMessages(MessageRange.all(), METADATA_GROUP, session); List<MessageMetaData> mList = new ArrayList<>(); while (results.hasNext()) { MessageResult result = results.next(); MessageMetaData metaData = new MessageMetaData(String.valueOf(result.getUid().asLong()), result.getSize()); mList.add(metaData); } return ImmutableList.copyOf(mList); } catch (MailboxException e) { throw new IOException("Unable to retrieve messages", e); } finally { mailboxManager.endProcessingRequest(session); } }
private FetchResponse.BodyElement headers(final MessageResult messageResult, String name, final int[] path, final boolean isBase) throws MailboxException { if (isBase) { // if its base we can just return the raw headers without parsing // them. See MAILBOX-311 and IMAP-? HeadersBodyElement element = new HeadersBodyElement(name, messageResult.getHeaders()); try { if (messageResult.getSize() - element.size() <= 0) { // Seems like this mail has no body element.noBody(); } } catch (IOException e) { throw new MailboxException("Unable to get size of header body element", e); } return element; } else { final Iterator<MessageResult.Header> headers = getHeaders(messageResult, path, isBase); List<MessageResult.Header> lines = MessageResultUtils.getAll(headers); return headerBodyElement(messageResult, name, lines, path, isBase); } }
@Override public int compareTo(MessageResult that) { return uid.compareTo(that.getUid()); }
private void init() throws MailboxException { MailboxSession mailboxSession = ImapSessionUtils.getMailboxSession(session); mailboxManager.addListener(path, this, mailboxSession); MessageResultIterator messages = mailboxManager.getMailbox(path, mailboxSession).getMessages(MessageRange.all(), FetchGroupImpl.MINIMAL, mailboxSession); synchronized (this) { while(messages.hasNext()) { MessageResult mr = messages.next(); applicableFlags.add(mr.getFlags()); add(mr.getUid()); } // \RECENT is not a applicable flag in imap so remove it from the list applicableFlags.remove(Flags.Flag.RECENT); } }
private FetchResponse.BodyElement content(final MessageResult messageResult, String name, final int[] path, final boolean isBase) throws MailboxException { final FetchResponse.BodyElement result; Content full; if (isBase) { try { full = messageResult.getFullContent(); } catch (IOException e) { throw new MailboxException("Unable to get content", e); } } else { MessageResult.MimePath mimePath = new MimePathImpl(path); full = messageResult.getMimeBody(mimePath); } if (full == null) { full = new EmptyContent(); } result = new ContentBodyElement(name, full); return result; } }
@Before public void setUp() throws MailboxException { ImapSession imapSession = mock(ImapSession.class); when(imapSession.getAttribute(ImapSessionUtils.MAILBOX_SESSION_ATTRIBUTE_SESSION_KEY)) .thenReturn(MAILBOX_SESSION); when(imapSession.getState()).thenReturn(ImapSessionState.AUTHENTICATED); MailboxManager mailboxManager = mock(MailboxManager.class); MessageManager messageManager = mock(MessageManager.class); when(mailboxManager.getDelimiter()).thenReturn(PATH_DELIMITER); when(mailboxManager.getMailbox(any(MailboxId.class), any(MailboxSession.class))) .thenReturn(messageManager); when(mailboxManager.getMailbox(any(MailboxPath.class), any(MailboxSession.class))) .thenReturn(messageManager); MessageResult messageResult = mock(MessageResult.class); when(messageResult.getMailboxId()).thenReturn(TestId.of(36)); when(messageResult.getUid()).thenReturn(MESSAGE_UID); when(messageManager.getApplicableFlags(any())) .thenReturn(new Flags()); when(messageManager.search(any(), any())) .thenReturn(ImmutableList.of(MESSAGE_UID).iterator()); when(messageManager.getMessages(any(), any(), any())) .thenReturn(new SingleMessageResultIterator(messageResult)); testee = new SelectedMailboxImpl(mailboxManager, imapSession, MAILBOX_PATH); }
private HeaderBodyElement headerBodyElement(MessageResult messageResult, String name, List<MessageResult.Header> lines, int[] path, boolean isBase) throws MailboxException { final HeaderBodyElement result = new HeaderBodyElement(name, lines); // if the size is 2 we had found not header and just want to write the empty line with CLRF terminated // so check if there is a content for it. If not we MUST NOT write the empty line in any case // as stated in rfc3501 if (result.size() == 2) { // Check if its base as this can give use a more correctly working check // to see if we need to write the newline out to the client. // This is related to IMAP-298 if (isBase) { if (messageResult.getSize() - result.size() <= 0) { // Seems like this mail has no body result.noBody(); } } else { try { if (content(messageResult, name, path, isBase).size() <= 0) { // Seems like this mail has no body result.noBody(); } } catch (IOException e) { throw new MailboxException("Unable to get size of header body element", e); } } } return result; }
private Optional<InputStream> loadMessageAsBlob(MessageId messageId, MailboxSession mailboxSession) { try { return messageIdManager.getMessages(ImmutableList.of(messageId), FetchGroupImpl.FULL_CONTENT, mailboxSession) .stream() .map(Throwing.function(message -> message.getFullContent().getInputStream())) .findFirst(); } catch (MailboxException e) { throw new RuntimeException(e); } }
private FetchResponse.BodyElement text(final MessageResult messageResult, String name, final int[] path, final boolean isBase) throws MailboxException { final FetchResponse.BodyElement result; Content body; if (isBase) { try { body = messageResult.getBody(); } catch (IOException e) { throw new MailboxException("Unable to get TEXT of body", e); } } else { MessageResult.MimePath mimePath = new MimePathImpl(path); body = messageResult.getBody(mimePath); } if (body == null) { body = new EmptyContent(); } result = new ContentBodyElement(name, body); return result; }
/** * Find the highest mod-sequence number in the given {@link MessageRange}'s. * * @param session * @param mailbox * @param ranges * @param currentHighest * @return highestModSeq * @throws MailboxException */ private Long findHighestModSeq(MailboxSession session, MessageManager mailbox, List<MessageRange> ranges, long currentHighest) throws MailboxException { Long highestModSeq = null; // Reverse loop over the ranges as its more likely that we find a match at the end int size = ranges.size(); for (int i = size - 1; i > 0; i--) { MessageResultIterator results = mailbox.getMessages(ranges.get(i), FetchGroupImpl.MINIMAL, session); while (results.hasNext()) { long modSeq = results.next().getModSeq(); if (highestModSeq == null || modSeq > highestModSeq) { highestModSeq = modSeq; } if (highestModSeq == currentHighest) { return highestModSeq; } } } return highestModSeq; }
public List<AttachmentId> retrieveAttachmentIds(MessageId messageId, String username) throws MailboxException { MailboxSession mailboxSession = mailboxManager.createSystemSession(username); List<MessageResult> messages = messageIdManager.getMessages( ImmutableList.of(messageId), FetchGroupImpl.MINIMAL, mailboxSession); return messages.stream() .flatMap(Throwing.function(messageResult -> messageResult.getAttachments().stream())) .map(MessageAttachment::getAttachmentId) .collect(Guavate.toImmutableList()); } }
public FetchResponse build(FetchData fetch, MessageResult result, MessageManager mailbox, ImapSession session, boolean useUids) throws MessageRangeException, MailboxException { final SelectedMailbox selected = session.getSelected(); final MessageUid resultUid = result.getUid(); final int resultMsn = selected.msn(resultUid); final Flags resultFlags = result.getFlags(); if (fetch.isSetSeen() && !resultFlags.contains(Flags.Flag.SEEN)) { mailbox.setFlags(new Flags(Flags.Flag.SEEN), MessageManager.FlagsUpdateMode.ADD, MessageRange.one(resultUid), mailboxSession); setInternalDate(result.getInternalDate()); setSize(result.getSize()); body = new MimeDescriptorStructure(false, result.getMimeDescriptor(), envelopeBuilder); bodystructure = new MimeDescriptorStructure(true, result.getMimeDescriptor(), envelopeBuilder); if (changedSince != -1) { if (changedSince < result.getModSeq()) { setModSeq(result.getModSeq()); setModSeq(result.getModSeq());