private Optional<MessageAttachment> messageAttachment(MailboxSession session, Attachment attachment) throws MailboxException { try { return Optional.of(MessageAttachment.builder() .attachment(attachmentManager.getAttachment(AttachmentId.from(attachment.getBlobId().getRawValue()), session)) .name(attachment.getName().orElse(null)) .cid(attachment.getCid().map(Cid::from).orElse(null)) .isInline(attachment.isIsInline()) .build()); } catch (AttachmentNotFoundException e) { LOGGER.error(String.format("Attachment %s not found", attachment.getBlobId()), e); return Optional.empty(); } catch (IllegalStateException e) { LOGGER.error(String.format("Attachment %s is not well-formed", attachment.getBlobId()), e); return Optional.empty(); } } }
public MessageAttachment build() { Preconditions.checkState(attachment != null, "'attachment' is mandatory"); return new MessageAttachment(attachment, name, cid, isInline.orElse(false)); } }
private UDTValue toUDT(MessageAttachment messageAttachment) { return typesProvider.getDefinedUserType(ATTACHMENTS) .newValue() .setString(Attachments.ID, messageAttachment.getAttachmentId().getId()) .setString(Attachments.NAME, messageAttachment.getName().orElse(null)) .setString(Attachments.CID, messageAttachment.getCid().map(Cid::getValue).orElse(null)) .setBool(Attachments.IS_INLINE, messageAttachment.isInline()); }
private ContentTypeField contentTypeField(MessageAttachment att) { Builder<String, String> parameters = ImmutableMap.builder(); if (att.getName().isPresent()) { parameters.put("name", encode(att.getName().get())); } String type = att.getAttachment().getType(); if (type.contains(FIELD_PARAMETERS_SEPARATOR)) { return Fields.contentType(contentTypeWithoutParameters(type), parameters.build()); } return Fields.contentType(type, parameters.build()); }
@Test void retrieveAllMessageIdAttachmentIdsShouldReturnOneWhenStored() throws Exception { //Given MessageAttachment attachment = MessageAttachment.builder() .attachment(Attachment.builder() .bytes("content".getBytes(StandardCharsets.UTF_8)) .type("type") .build()) .build(); SimpleMailboxMessage message1 = createMessage(messageId, CONTENT, BODY_START, new PropertyBuilder(), ImmutableList.of(attachment)); testee.save(message1).join(); MessageIdAttachmentIds expected = new MessageIdAttachmentIds(messageId, ImmutableSet.of(attachment.getAttachmentId())); //When Stream<MessageIdAttachmentIds> actual = testee.retrieveAllMessageIdAttachmentIds().join(); //Then assertThat(actual).containsOnly(expected); }
@Test public void isInlinedWithCidShouldReturnFalseWhenIsInlineButNoCid() throws Exception { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .name("name") .isInline(true) .build(); assertThat(messageAttachment.isInlinedWithCid()).isFalse(); } }
@Test public void buildShouldWorkWhenMandatoryAttributesAreGiven() { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment expectedMessageAttachment = new MessageAttachment(attachment, Optional.empty(), Optional.empty(), false); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .build(); assertThat(messageAttachment).isEqualTo(expectedMessageAttachment); }
@Test public void buildShouldAcceptIsInlineAndNoCid() { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .isInline(true) .build(); assertThat(messageAttachment.isInline()).isTrue(); }
private BodyPart attachmentBodyPart(MessageAttachment att) throws IOException { BodyPartBuilder builder = BodyPartBuilder.create() .use(bodyFactory) .setBody(new BasicBodyFactory().binaryBody(ByteStreams.toByteArray(att.getAttachment().getStream()))) .setField(contentTypeField(att)) .setField(contentDispositionField(att.isInline())) .setContentTransferEncoding(BASE64); contentId(builder, att); return builder.build(); }
@Test void migrationShouldCreateAttachmentIdOnAttachmentMessageIdTableFromMessage() throws Exception { MessageAttachment attachment = createAttachment(); message = createMessage(messageId, ImmutableList.of(attachment)); cassandraMessageDAO.save(message).join(); migration.run(); assertThat(attachmentMessageIdDAO.getOwnerMessageIds(attachment.getAttachmentId()).join()) .containsExactly(messageId); }
private boolean hasNonInlinedAttachment(List<MessageAttachment> attachments) { return attachments.stream() .anyMatch(messageAttachment -> !messageAttachment.isInlinedWithCid()); }
@Test void retrieveAllMessageIdAttachmentIdsShouldReturnOneWhenStoredWithTwoAttachments() throws Exception { //Given MessageAttachment attachment1 = MessageAttachment.builder() .attachment(Attachment.builder() .bytes("content".getBytes(StandardCharsets.UTF_8)) .type("type") .build()) .build(); MessageAttachment attachment2 = MessageAttachment.builder() .attachment(Attachment.builder() .bytes("other content".getBytes(StandardCharsets.UTF_8)) .type("type") .build()) .build(); SimpleMailboxMessage message1 = createMessage(messageId, CONTENT, BODY_START, new PropertyBuilder(), ImmutableList.of(attachment1, attachment2)); testee.save(message1).join(); MessageIdAttachmentIds expected = new MessageIdAttachmentIds(messageId, ImmutableSet.of(attachment1.getAttachmentId(), attachment2.getAttachmentId())); //When Stream<MessageIdAttachmentIds> actual = testee.retrieveAllMessageIdAttachmentIds().join(); //Then assertThat(actual).containsOnly(expected); }
@Test public void isInlinedWithCidShouldReturnTrueWhenIsInlineAndHasCid() throws Exception { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .name("name") .cid(Cid.from("cid")) .isInline(true) .build(); assertThat(messageAttachment.isInlinedWithCid()).isTrue(); }
@Test public void buildShouldSetAttributesWhenAllAreGiven() { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment expectedMessageAttachment = new MessageAttachment(attachment, Optional.of("name"), Optional.of(Cid.from("cid")), true); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .name("name") .cid(Cid.from("cid")) .isInline(true) .build(); assertThat(messageAttachment).isEqualTo(expectedMessageAttachment); }
@Test(expected = IllegalArgumentException.class) public void builderShouldThrowWhenAttachmentIsNull() { MessageAttachment.builder() .attachment(null); }
MessageAttachment attachment1 = MessageAttachment.builder() .attachment(Attachment.builder() .bytes("content".getBytes(StandardCharsets.UTF_8)) .build()) .build(); MessageAttachment attachment2 = MessageAttachment.builder() .attachment(Attachment.builder() .bytes("other content".getBytes(StandardCharsets.UTF_8)) testee.save(message1).join(); testee.save(message2).join(); MessageIdAttachmentIds expected1 = new MessageIdAttachmentIds(messageId1, ImmutableSet.of(attachment1.getAttachmentId())); MessageIdAttachmentIds expected2 = new MessageIdAttachmentIds(messageId2, ImmutableSet.of(attachment2.getAttachmentId()));
private Attachment fromMailboxAttachment(MessageAttachment attachment) { return Attachment.builder() .blobId(BlobId.of(attachment.getAttachmentId().getId())) .type(attachment.getAttachment().getType()) .size(attachment.getAttachment().getSize()) .name(attachment.getName()) .cid(attachment.getCid().map(Cid::getValue)) .isInline(attachment.isInline()) .build(); }
@Test public void isInlinedWithCidShouldReturnFalseWhenIsNotInline() throws Exception { Attachment attachment = Attachment.builder() .bytes("content".getBytes()) .type("type") .build(); MessageAttachment messageAttachment = MessageAttachment.builder() .attachment(attachment) .name("name") .cid(Cid.from("cid")) .isInline(false) .build(); assertThat(messageAttachment.isInlinedWithCid()).isFalse(); }
@Test public void getAttachmentsShouldWorkWithDuplicatedIds() { AttachmentId attachmentId = AttachmentId.from("1"); Set<AttachmentId> attachmentIds = ImmutableSet.of(attachmentId); Attachment attachment = Attachment.builder() .attachmentId(attachmentId) .bytes("attachment".getBytes()) .type("type") .build(); when(attachmentMapper.getAttachmentsAsFuture(attachmentIds)) .thenReturn(CompletableFuture.completedFuture(ImmutableList.of(attachment))); Optional<String> name1 = Optional.of("name1"); Optional<String> name2 = Optional.of("name2"); Optional<Cid> cid = Optional.empty(); boolean isInlined = false; MessageAttachmentRepresentation attachmentRepresentation1 = new MessageAttachmentRepresentation(attachmentId, name1, cid, isInlined); MessageAttachmentRepresentation attachmentRepresentation2 = new MessageAttachmentRepresentation(attachmentId, name2, cid, isInlined); Collection<MessageAttachment> attachments = testee.getAttachments(ImmutableList.of(attachmentRepresentation1, attachmentRepresentation2)) .join(); assertThat(attachments).hasSize(2) .containsOnly(new MessageAttachment(attachment, name1, cid, isInlined), new MessageAttachment(attachment, name2, cid, isInlined)); }