private Map<MessageUid, MessageMetaData> createMetaData(List<MailboxMessage> uids) { final Map<MessageUid, MessageMetaData> data = new HashMap<>(); for (MailboxMessage m : uids) { data.put(m.getUid(), new SimpleMessageMetaData(m)); } return data; }
private void addMessage(final MailboxSession session, final Mailbox mailbox, MailboxMessage message) { try { add(session, mailbox, message); } catch (MailboxException e) { LOGGER.error("Unable to index message {} for mailbox {}", message.getUid(), mailbox, e); } }
@Override public int compareTo(MailboxMessage other) { return this.getUid().compareTo(other.getUid()); }
private boolean matches(SearchQuery.UidCriterion criterion, MailboxMessage message) { SearchQuery.UidInOperator operator = criterion.getOperator(); UidRange[] ranges = operator.getRange(); MessageUid uid = message.getUid(); return Arrays.stream(ranges) .anyMatch(numericRange -> numericRange.isIn(uid)); }
private MailboxMessage mockedMessage(MessageUid messageId) throws IOException { MailboxMessage message = mock(MailboxMessage.class); when(message.getUid()) .thenReturn(messageId); return message; }
private CompletableFuture<Void> addRecentOnSave(CassandraId mailboxId, MailboxMessage message) { if (message.createFlags().contains(Flags.Flag.RECENT)) { return mailboxRecentDAO.addToRecent(mailboxId, message.getUid()); } return CompletableFuture.completedFuture(null); }
private void applyMessageMoveNoMailboxChecks(MailboxSession mailboxSession, List<MailboxMessage> currentMailboxMessages, MessageMoves messageMoves) throws MailboxException { MailboxMessage mailboxMessage = currentMailboxMessages.stream().findAny().orElseThrow(() -> new MailboxNotFoundException("can't load message")); validateQuota(messageMoves, mailboxSession, mailboxMessage); addMessageToMailboxes(mailboxMessage, messageMoves.addedMailboxIds(), mailboxSession); removeMessageFromMailboxes(mailboxMessage, messageMoves.removedMailboxIds(), mailboxSession); dispatcher.moved(mailboxSession, messageMoves, ImmutableMap.of(mailboxMessage.getUid(), mailboxMessage)); }
@Override public MessageMetaData save(Mailbox mailbox, MailboxMessage message) throws MailboxException { SimpleMailboxMessage copy = SimpleMailboxMessage.copy(mailbox.getMailboxId(), message); copy.setUid(message.getUid()); copy.setModSeq(message.getModSeq()); getMembershipByUidForMailbox(mailbox).put(message.getUid(), copy); return new SimpleMessageMetaData(message); }
public CompletableFuture<Void> updateIndexOnAdd(MailboxMessage message, CassandraId mailboxId) { Flags flags = message.createFlags(); return CompletableFuture.allOf( checkDeletedOnAdd(mailboxId, message.createFlags(), message.getUid()), updateFirstUnseenOnAdd(mailboxId, message.createFlags(), message.getUid()), addRecentOnSave(mailboxId, message), incrementUnseenOnSave(mailboxId, flags), mailboxCounterDAO.incrementCount(mailboxId), applicableFlagDAO.updateApplicableFlags(mailboxId, ImmutableSet.copyOf(flags.getUserFlags()))); }
@Test void updateIndexOnAddShouldUpdateFirstUnseenWhenUnseen() { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags()); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join(); assertThat(actual.isPresent()).isTrue(); assertThat(actual.get()).isEqualTo(MESSAGE_UID); }
@Test void updateIndexOnAddShouldIncrementUnseenMessageCountWhenUnseen() throws Exception { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags()); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join(); assertThat(actual.isPresent()).isTrue(); assertThat(actual.get()).isEqualTo(1); }
@Test void updateIndexOnAddShouldNotIncrementUnseenMessageCountWhenSeen() throws Exception { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN)); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join(); assertThat(actual.isPresent()).isTrue(); assertThat(actual.get()).isEqualTo(0); }
private AbstractJPAMailboxMessage.MailboxIdUidKey buildKey(Mailbox mailbox, MailboxMessage message) { JPAId mailboxId = (JPAId) mailbox.getMailboxId(); AbstractJPAMailboxMessage.MailboxIdUidKey key = new AbstractJPAMailboxMessage.MailboxIdUidKey(); key.mailbox = mailboxId.getRawId(); key.uid = message.getUid().asLong(); return key; }
public void added(MailboxSession session, Mailbox mailbox, MailboxMessage mailboxMessage) { SimpleMessageMetaData messageMetaData = new SimpleMessageMetaData(mailboxMessage); SortedMap<MessageUid, MessageMetaData> metaDataMap = ImmutableSortedMap.<MessageUid, MessageMetaData>naturalOrder() .put(messageMetaData.getUid(), messageMetaData) .build(); added(session, metaDataMap, mailbox, ImmutableMap.of(mailboxMessage.getUid(), mailboxMessage)); }
@Test void updateIndexOnAddShouldNotUpdateFirstUnseenWhenSeen() { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN)); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join(); assertThat(actual.isPresent()).isFalse(); }
@Test void updateIndexOnAddShouldUpdateApplicableFlag() { Flags customFlags = new Flags("custom"); MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(customFlags); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).join().get(); assertThat(applicableFlag).isEqualTo(customFlags); }
@Test void updateIndexOnAddShouldNotAddRecentWhenNoRecent() { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags()); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join() .collect(Guavate.toImmutableList())) .isEmpty(); }
@Test void updateIndexOnAddShouldAddRecentWhenRecent() { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags(Flags.Flag.RECENT)); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join() .collect(Guavate.toImmutableList())) .containsOnly(MESSAGE_UID); }
@Test void updateIndexOnDeleteShouldUpdateFirstUnseenWhenUnseen() { MailboxMessage message = mock(MailboxMessage.class); when(message.createFlags()).thenReturn(new Flags()); when(message.getUid()).thenReturn(MESSAGE_UID); testee.updateIndexOnAdd(message, MAILBOX_ID).join(); testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData( new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID), new Flags(), MODSEQ), MAILBOX_ID).join(); Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join(); assertThat(actual.isPresent()).isFalse(); }
private CompletableFuture<Void> insertIds(MailboxMessage message, CassandraId mailboxId) { ComposedMessageIdWithMetaData composedMessageIdWithMetaData = ComposedMessageIdWithMetaData.builder() .composedMessageId(new ComposedMessageId(mailboxId, message.getMessageId(), message.getUid())) .flags(message.createFlags()) .modSeq(message.getModSeq()) .build(); return CompletableFuture.allOf(messageIdDAO.insert(composedMessageIdWithMetaData), imapUidDAO.insert(composedMessageIdWithMetaData)); }