private void addVanishedResponse(SelectedMailbox selected, Collection<Long> expungedUids, final ImapProcessor.Responder responder) { for (final Long uid : expungedUids) { final long uidValue = uid.longValue(); selected.remove(uidValue); } IdRange[] uidRange = idRanges(MessageRange.toRanges(expungedUids)); responder.respond(new VanishedResponse(uidRange, false)); }
@Override public void remove(String... uids) throws IOException { List<MessageUid> uidList = Arrays.stream(uids) .map(uid -> MessageUid.of(Long.valueOf(uid))) .collect(Guavate.toImmutableList()); List<MessageRange> ranges = MessageRange.toRanges(uidList); try { mailboxManager.startProcessingRequest(session); for (MessageRange range : ranges) { manager.setFlags(new Flags(Flags.Flag.DELETED), MessageManager.FlagsUpdateMode.ADD, range, session); manager.expunge(range, session); } } catch (MailboxException e) { throw new IOException("Unable to remove messages for ranges " + ranges); } finally { mailboxManager.endProcessingRequest(session); } }
private void addVanishedResponse(SelectedMailbox selected, Collection<MessageUid> expungedUids, ImapProcessor.Responder responder) { for (MessageUid uid : expungedUids) { selected.remove(uid); } UidRange[] uidRange = uidRanges(MessageRange.toRanges(expungedUids)); responder.respond(new VanishedResponse(uidRange, false)); }
@Test public void givenASingleNumberToRangeShouldReturnOneRange() { List<MessageRange> ranges = MessageRange.toRanges(Arrays.asList(MessageUid.of(1L))); assertThat(ranges).containsExactly(MessageUid.of(1).toRange()); }
private void addFlagsResponses(final ImapSession session, final SelectedMailbox selected, final ImapProcessor.Responder responder, boolean useUid) { try { final MessageManager mailbox = getMailbox(session, selected); final MailboxSession mailboxSession = ImapSessionUtils.getMailboxSession(session); // Check ifwe need to send a FLAGS and PERMANENTFLAGS response before the FETCH response // This is the case if some new flag/keyword was used // See IMAP-303 if (selected.hasNewApplicableFlags()) { flags(responder, selected); permanentFlags(responder, mailbox.getMetaData(false, mailboxSession, MessageManager.MetaData.FetchGroup.NO_COUNT), selected); selected.resetNewApplicableFlags(); } final Collection<Long> flagUpdateUids = selected.flagUpdateUids(); if (!flagUpdateUids.isEmpty()) { Iterator<MessageRange> ranges = MessageRange.toRanges(flagUpdateUids).iterator(); while(ranges.hasNext()) { addFlagsResponses(session, selected, responder, useUid, ranges.next(), mailbox, mailboxSession); } } } catch (MailboxException e) { handleResponseException(responder, e, HumanReadableText.FAILURE_TO_LOAD_FLAGS, session); } }
Iterator<MessageRange> ranges = MessageRange.toRanges(flagUpdateUids).iterator(); while (ranges.hasNext()) { if (messageManager == null) {
/** * Copy the {@link MessageRange} to the {@link StoreMessageManager} * * @param set * @param toMailbox * @param session * @throws MailboxException */ public List<MessageRange> copyTo(final MessageRange set, final StoreMessageManager toMailbox, final MailboxSession session) throws MailboxException { if (!toMailbox.isWriteable(session)) { throw new ReadOnlyException(new StoreMailboxPath(toMailbox.getMailboxEntity()), session.getPathDelimiter()); } return locker.executeWithLock(session, new StoreMailboxPath(toMailbox.getMailboxEntity()), () -> { SortedMap<MessageUid, MessageMetaData> copiedUids = copy(set, toMailbox, session); return MessageRange.toRanges(new ArrayList<>(copiedUids.keySet())); }, true); }
@Test public void testTwoSeqUidToRange() { List<MessageRange> ranges = MessageRange.toRanges(Arrays.asList(MessageUid.of(1L), MessageUid.of(2L))); assertThat(ranges).containsExactly(MessageRange.range(MessageUid.of(1), MessageUid.of(2))); }
if (session.getAttribute(SEARCH_MODSEQ) != null) { MetaData metaData = mailbox.getMetaData(false, msession , MessageManager.MetaData.FetchGroup.NO_COUNT); highestModSeq = findHighestModSeq(msession, mailbox, MessageRange.toRanges(uids), metaData.getHighestModSeq()); idList.add(ids[i]); List<MessageRange> ranges = MessageRange.toRanges(idList); idRanges = new IdRange[ranges.size()]; for (int i = 0 ; i <ranges.size(); i++) {
vanishedUids.remove(uids.next()); IdRange[] vanishedIdRanges = idRanges(MessageRange.toRanges(vanishedUids)); responder.respond(new VanishedResponse(vanishedIdRanges, true));
vanishedUids.remove(uids.next()); UidRange[] vanishedIdRanges = uidRanges(MessageRange.toRanges(vanishedUids)); responder.respond(new VanishedResponse(vanishedIdRanges, true));
if (session.getAttribute(SEARCH_MODSEQ) != null) { MetaData metaData = mailbox.getMetaData(false, msession, MessageManager.MetaData.FetchGroup.NO_COUNT); highestModSeq = findHighestModSeq(msession, mailbox, MessageRange.toRanges(uids), metaData.getHighestModSeq());
/** * Move the {@link MessageRange} to the {@link StoreMessageManager} * * @param set * @param toMailbox * @param session * @throws MailboxException */ public List<MessageRange> moveTo(final MessageRange set, final StoreMessageManager toMailbox, final MailboxSession session) throws MailboxException { if (!isWriteable(session)) { throw new ReadOnlyException(getMailboxPath(), session.getPathDelimiter()); } if (!toMailbox.isWriteable(session)) { throw new ReadOnlyException(new StoreMailboxPath(toMailbox.getMailboxEntity()), session.getPathDelimiter()); } //TODO lock the from mailbox too, in a non-deadlocking manner - how? return locker.executeWithLock(session, new StoreMailboxPath(toMailbox.getMailboxEntity()), () -> { SortedMap<MessageUid, MessageMetaData> movedUids = move(set, toMailbox, session); return MessageRange.toRanges(new ArrayList<>(movedUids.keySet())); }, true); }
List<MessageRange> mRanges = MessageRange.toRanges(uids); for (int a = 0 ; a < mRanges.size(); a++) { setFlags(request, mailboxSession, mailbox, mRanges.get(a), session, tag, imapCommand, responder); List<MessageRange> ranges = MessageRange.toRanges(failed); IdRange[] idRanges = new IdRange[ranges.size()]; for (int i = 0 ; i < ranges.size(); i++) {
List<MessageRange> mRanges = MessageRange.toRanges(uids); for (MessageRange mRange : mRanges) { setFlags(request, mailboxSession, mailbox, mRange, session, tag, imapCommand, responder); } else { if (useUids) { List<MessageRange> ranges = MessageRange.toRanges(failed); UidRange[] idRanges = new UidRange[ranges.size()]; for (int i = 0; i < ranges.size(); i++) {
@Test public void givenSomeNumbersToRangeShouldReturnThreeRanges() { List<MessageRange> ranges = MessageRange.toRanges( Arrays.asList( MessageUid.of(1L), MessageUid.of(2L), MessageUid.of(3L), MessageUid.of(5L), MessageUid.of(6L), MessageUid.of(9L))); assertThat(ranges).containsExactly( MessageRange.range(MessageUid.of(1), MessageUid.of(3)), MessageRange.range(MessageUid.of(5), MessageUid.of(6)), MessageUid.of(9).toRange()); }
/** * Return a List which holds all uids of recent messages and optional reset * the recent flag on the messages for the uids */ protected List<MessageUid> recent(final boolean reset, MailboxSession mailboxSession) throws MailboxException { if (reset) { if (!isWriteable(mailboxSession)) { throw new ReadOnlyException(getMailboxPath(), mailboxSession.getPathDelimiter()); } } final MessageMapper messageMapper = mapperFactory.getMessageMapper(mailboxSession); return messageMapper.execute(() -> { final List<MessageUid> members = messageMapper.findRecentMessageUidsInMailbox(getMailboxEntity()); // Convert to MessageRanges so we may be able to optimize the // flag update List<MessageRange> ranges = MessageRange.toRanges(members); for (MessageRange range : ranges) { if (reset) { // only call save if we need to messageMapper.updateFlags(getMailboxEntity(), new FlagsUpdateCalculator(new Flags(Flag.RECENT), FlagsUpdateMode.REMOVE), range); } } return members; }); }