This is an automated email from the ASF dual-hosted git repository.
rcordier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 53ff21217c72392ebbf60d8ac305d790e65eb1e2
Author: Maksim Meliashchuk <maksym...@gmail.com>
AuthorDate: Sun Jul 30 18:41:28 2023 +0300
JAMES-2156 JPA Attachment Mapper
---
.../jpa/JPAMailboxSessionMapperFactory.java | 17 +-
.../mailbox/jpa/mail/JPAAttachmentMapper.java | 123 +++++++++++
.../james/mailbox/jpa/mail/JPAMessageMapper.java | 32 ++-
.../mailbox/jpa/mail/model/JPAAttachment.java | 193 +++++++++++++++++
.../model/openjpa/AbstractJPAMailboxMessage.java | 228 ++++++++++++---------
.../james/mailbox/jpa/JPAMailboxFixture.java | 7 +-
.../mailbox/jpa/mail/JPAAttachmentMapperTest.java | 101 +++++++++
.../james/mailbox/jpa/mail/JPAMapperProvider.java | 4 +-
.../mail/JPAMessageWithAttachmentMapperTest.java | 132 ++++++++++++
.../jpa/mail/TransactionalAttachmentMapper.java | 84 ++++++++
mailbox/jpa/src/test/resources/persistence.xml | 1 +
.../store/mail/model/AttachmentMapperTest.java | 17 +-
.../model/MessageWithAttachmentMapperTest.java | 28 +--
13 files changed, 839 insertions(+), 128 deletions(-)
diff --git
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/JPAMailboxSessionMapperFactory.java
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/JPAMailboxSessionMapperFactory.java
index b751e92d5b..935623ef6d 100644
---
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/JPAMailboxSessionMapperFactory.java
+++
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/JPAMailboxSessionMapperFactory.java
@@ -26,6 +26,7 @@ import org.apache.commons.lang3.NotImplementedException;
import org.apache.james.backends.jpa.EntityManagerUtils;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.jpa.mail.JPAAnnotationMapper;
+import org.apache.james.mailbox.jpa.mail.JPAAttachmentMapper;
import org.apache.james.mailbox.jpa.mail.JPAMailboxMapper;
import org.apache.james.mailbox.jpa.mail.JPAMessageMapper;
import org.apache.james.mailbox.jpa.mail.JPAModSeqProvider;
@@ -33,6 +34,8 @@ import org.apache.james.mailbox.jpa.mail.JPAUidProvider;
import org.apache.james.mailbox.jpa.user.JPASubscriptionMapper;
import org.apache.james.mailbox.store.MailboxSessionMapperFactory;
import org.apache.james.mailbox.store.mail.AnnotationMapper;
+import org.apache.james.mailbox.store.mail.AttachmentMapper;
+import org.apache.james.mailbox.store.mail.AttachmentMapperFactory;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.MessageIdMapper;
import org.apache.james.mailbox.store.mail.MessageMapper;
@@ -44,11 +47,12 @@ import
org.apache.james.mailbox.store.user.SubscriptionMapper;
* JPA implementation of {@link MailboxSessionMapperFactory}
*
*/
-public class JPAMailboxSessionMapperFactory extends
MailboxSessionMapperFactory {
+public class JPAMailboxSessionMapperFactory extends
MailboxSessionMapperFactory implements AttachmentMapperFactory {
private final EntityManagerFactory entityManagerFactory;
private final JPAUidProvider uidProvider;
private final JPAModSeqProvider modSeqProvider;
+ private final AttachmentMapper attachmentMapper;
@Inject
public JPAMailboxSessionMapperFactory(EntityManagerFactory
entityManagerFactory, JPAUidProvider uidProvider, JPAModSeqProvider
modSeqProvider) {
@@ -56,6 +60,7 @@ public class JPAMailboxSessionMapperFactory extends
MailboxSessionMapperFactory
this.uidProvider = uidProvider;
this.modSeqProvider = modSeqProvider;
EntityManagerUtils.safelyClose(createEntityManager());
+ this.attachmentMapper = new JPAAttachmentMapper(entityManagerFactory);
}
@Override
@@ -102,4 +107,14 @@ public class JPAMailboxSessionMapperFactory extends
MailboxSessionMapperFactory
return modSeqProvider;
}
+ @Override
+ public AttachmentMapper createAttachmentMapper(MailboxSession session) {
+ return new JPAAttachmentMapper(entityManagerFactory);
+ }
+
+ @Override
+ public AttachmentMapper getAttachmentMapper(MailboxSession session) {
+ return attachmentMapper;
+ }
+
}
diff --git
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapper.java
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapper.java
new file mode 100644
index 0000000000..ec364fdc03
--- /dev/null
+++
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapper.java
@@ -0,0 +1,123 @@
+/***************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.mailbox.jpa.mail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.List;
+
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.NoResultException;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.james.mailbox.exception.AttachmentNotFoundException;
+import org.apache.james.mailbox.exception.MailboxException;
+import org.apache.james.mailbox.jpa.JPATransactionalMapper;
+import org.apache.james.mailbox.jpa.mail.model.JPAAttachment;
+import org.apache.james.mailbox.model.AttachmentId;
+import org.apache.james.mailbox.model.AttachmentMetadata;
+import org.apache.james.mailbox.model.MessageAttachmentMetadata;
+import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.ParsedAttachment;
+import org.apache.james.mailbox.store.mail.AttachmentMapper;
+
+import com.github.fge.lambdas.Throwing;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+public class JPAAttachmentMapper extends JPATransactionalMapper implements
AttachmentMapper {
+
+ private static final String ID_PARAM = "idParam";
+
+ public JPAAttachmentMapper(EntityManagerFactory entityManagerFactory) {
+ super(entityManagerFactory);
+ }
+
+ @Override
+ public InputStream loadAttachmentContent(AttachmentId attachmentId) {
+ Preconditions.checkArgument(attachmentId != null);
+ return getEntityManager().createNamedQuery("findAttachmentById",
JPAAttachment.class)
+ .setParameter(ID_PARAM, attachmentId.getId())
+ .getSingleResult().getContent();
+ }
+
+ @Override
+ public AttachmentMetadata getAttachment(AttachmentId attachmentId) throws
AttachmentNotFoundException {
+ Preconditions.checkArgument(attachmentId != null);
+ AttachmentMetadata attachmentMetadata =
getAttachmentMetadata(attachmentId);
+ if (attachmentMetadata == null) {
+ throw new AttachmentNotFoundException(attachmentId.getId());
+ }
+ return attachmentMetadata;
+ }
+
+ @Override
+ public List<AttachmentMetadata> getAttachments(Collection<AttachmentId>
attachmentIds) {
+ Preconditions.checkArgument(attachmentIds != null);
+ ImmutableList.Builder<AttachmentMetadata> builder =
ImmutableList.builder();
+ for (AttachmentId attachmentId : attachmentIds) {
+ AttachmentMetadata attachmentMetadata =
getAttachmentMetadata(attachmentId);
+ if (attachmentMetadata != null) {
+ builder.add(attachmentMetadata);
+ }
+ }
+ return builder.build();
+ }
+
+ @Override
+ public List<MessageAttachmentMetadata>
storeAttachments(Collection<ParsedAttachment> parsedAttachments, MessageId
ownerMessageId) {
+ Preconditions.checkArgument(parsedAttachments != null);
+ Preconditions.checkArgument(ownerMessageId != null);
+ return parsedAttachments.stream()
+ .map(Throwing.<ParsedAttachment,
MessageAttachmentMetadata>function(
+ typedContent -> storeAttachmentForMessage(ownerMessageId,
typedContent))
+ .sneakyThrow())
+ .collect(ImmutableList.toImmutableList());
+ }
+
+ @Override
+ public Collection<MessageId> getRelatedMessageIds(AttachmentId
attachmentId) {
+ throw new UnsupportedOperationException("JPA does not support
MessageId");
+ }
+
+ private AttachmentMetadata getAttachmentMetadata(AttachmentId
attachmentId) {
+ try {
+ return getEntityManager().createNamedQuery("findAttachmentById",
JPAAttachment.class)
+ .setParameter(ID_PARAM, attachmentId.getId())
+ .getSingleResult()
+ .toAttachmentMetadata();
+ } catch (NoResultException e) {
+ return null;
+ }
+ }
+
+ private MessageAttachmentMetadata storeAttachmentForMessage(MessageId
ownerMessageId, ParsedAttachment parsedAttachment) throws MailboxException {
+ try {
+ byte[] bytes =
IOUtils.toByteArray(parsedAttachment.getContent().openStream());
+ JPAAttachment persistedAttachment = new
JPAAttachment(parsedAttachment.asMessageAttachment(AttachmentId.random(),
ownerMessageId), bytes);
+ getEntityManager().persist(persistedAttachment);
+ AttachmentId attachmentId =
AttachmentId.from(persistedAttachment.getAttachmentId());
+ return parsedAttachment.asMessageAttachment(attachmentId,
bytes.length, ownerMessageId);
+ } catch (IOException e) {
+ throw new MailboxException("Failed to store attachment for message
" + ownerMessageId, e);
+ }
+ }
+}
diff --git
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAMessageMapper.java
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAMessageMapper.java
index 3e6a501793..28cc9f207e 100644
---
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAMessageMapper.java
+++
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/JPAMessageMapper.java
@@ -23,6 +23,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.stream.Collectors;
import javax.mail.Flags;
import javax.persistence.EntityManagerFactory;
@@ -36,6 +37,7 @@ import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.jpa.JPAId;
import org.apache.james.mailbox.jpa.JPATransactionalMapper;
import org.apache.james.mailbox.jpa.mail.MessageUtils.MessageChangedFlags;
+import org.apache.james.mailbox.jpa.mail.model.JPAAttachment;
import org.apache.james.mailbox.jpa.mail.model.JPAMailbox;
import
org.apache.james.mailbox.jpa.mail.model.openjpa.AbstractJPAMailboxMessage;
import
org.apache.james.mailbox.jpa.mail.model.openjpa.JPAEncryptedMailboxMessage;
@@ -44,6 +46,7 @@ import
org.apache.james.mailbox.jpa.mail.model.openjpa.JPAStreamingMailboxMessag
import org.apache.james.mailbox.model.Mailbox;
import org.apache.james.mailbox.model.MailboxCounters;
import org.apache.james.mailbox.model.MailboxId;
+import org.apache.james.mailbox.model.MessageAttachmentMetadata;
import org.apache.james.mailbox.model.MessageMetaData;
import org.apache.james.mailbox.model.MessageRange;
import org.apache.james.mailbox.model.MessageRange.Type;
@@ -295,10 +298,10 @@ public class JPAMessageMapper extends
JPATransactionalMapper implements MessageM
public MessageMetaData move(Mailbox mailbox, MailboxMessage original)
throws MailboxException {
JPAId originalMailboxId = (JPAId) original.getMailboxId();
JPAMailbox originalMailbox = getEntityManager().find(JPAMailbox.class,
originalMailboxId.getRawId());
-
+
MessageMetaData messageMetaData = copy(mailbox, original);
delete(originalMailbox.toMailbox(), original);
-
+
return messageMetaData;
}
@@ -380,7 +383,21 @@ public class JPAMessageMapper extends
JPATransactionalMapper implements MessageM
} else {
JPAMailboxMessage persistData = new
JPAMailboxMessage(currentMailbox, message.getUid(), message.getModSeq(),
message);
persistData.setFlags(message.createFlags());
- getEntityManager().persist(persistData);
+
+ if (message.getAttachments().isEmpty()) {
+ getEntityManager().persist(persistData);
+ } else {
+ List<JPAAttachment> attachments = getAttachments(message);
+ if (attachments.isEmpty()) {
+
persistData.setAttachments(message.getAttachments().stream()
+ .map(JPAAttachment::new)
+ .collect(Collectors.toList()));
+ getEntityManager().persist(persistData);
+ } else {
+ persistData.setAttachments(attachments);
+ getEntityManager().merge(persistData);
+ }
+ }
return persistData.metaData();
}
@@ -389,6 +406,15 @@ public class JPAMessageMapper extends
JPATransactionalMapper implements MessageM
}
}
+ private List<JPAAttachment> getAttachments(MailboxMessage message) {
+ return message.getAttachments().stream()
+ .map(MessageAttachmentMetadata::getAttachmentId)
+ .map(attachmentId ->
getEntityManager().createNamedQuery("findAttachmentById", JPAAttachment.class)
+ .setParameter("idParam", attachmentId.getId())
+ .getSingleResult())
+ .collect(Collectors.toList());
+ }
+
@SuppressWarnings("unchecked")
private List<MailboxMessage> findMessagesInMailboxAfterUID(JPAId
mailboxId, MessageUid from, int batchSize) {
Query query =
getEntityManager().createNamedQuery("findMessagesInMailboxAfterUID")
diff --git
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/JPAAttachment.java
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/JPAAttachment.java
new file mode 100644
index 0000000000..1e4ab8098c
--- /dev/null
+++
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/JPAAttachment.java
@@ -0,0 +1,193 @@
+/***************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.mailbox.jpa.mail.model;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Optional;
+
+import javax.persistence.Basic;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Lob;
+import javax.persistence.NamedQuery;
+import javax.persistence.Table;
+
+import org.apache.james.mailbox.model.AttachmentId;
+import org.apache.james.mailbox.model.AttachmentMetadata;
+import org.apache.james.mailbox.model.Cid;
+import org.apache.james.mailbox.model.MessageAttachmentMetadata;
+import org.apache.james.mailbox.store.mail.model.DefaultMessageId;
+
+@Entity(name = "Attachment")
+@Table(name = "JAMES_ATTACHMENT")
+@NamedQuery(name = "findAttachmentById", query = "SELECT attachment FROM
Attachment attachment WHERE attachment.attachmentId = :idParam")
+public class JPAAttachment {
+
+ private static final String TOSTRING_SEPARATOR = " ";
+ private static final byte[] EMPTY_ARRAY = new byte[]{};
+
+ @Id
+ @GeneratedValue
+ @Column(name = "ATTACHMENT_ID", nullable = false)
+ private String attachmentId;
+
+ @Basic(optional = false)
+ @Column(name = "TYPE", nullable = false)
+ private String type;
+
+ @Basic(optional = false)
+ @Column(name = "SIZE", nullable = false)
+ private long size;
+
+ @Basic(optional = false, fetch = FetchType.LAZY)
+ @Column(name = "CONTENT", nullable = false)
+ @Lob
+ private byte[] content;
+
+ @Basic(optional = true)
+ @Column(name = "NAME")
+ private String name;
+
+ @Basic(optional = true)
+ @Column(name = "CID")
+ private String cid;
+
+ @Basic(optional = false)
+ @Column(name = "INLINE", nullable = false)
+ private boolean isInline;
+
+ public JPAAttachment() {
+ }
+
+ public JPAAttachment(MessageAttachmentMetadata messageAttachmentMetadata,
byte[] bytes) {
+ setMetadata(messageAttachmentMetadata, bytes);
+ }
+
+ public JPAAttachment(MessageAttachmentMetadata messageAttachmentMetadata) {
+ setMetadata(messageAttachmentMetadata, new byte[0]);
+ }
+
+ private void setMetadata(MessageAttachmentMetadata
messageAttachmentMetadata, byte[] bytes) {
+ this.name = messageAttachmentMetadata.getName().orElse(null);
+ messageAttachmentMetadata.getCid()
+ .ifPresentOrElse(c -> this.cid = c.getValue(), () -> this.cid = "");
+ this.type =
messageAttachmentMetadata.getAttachment().getType().asString();
+ this.size = messageAttachmentMetadata.getAttachment().getSize();
+ this.isInline = messageAttachmentMetadata.isInline();
+ this.content = bytes;
+ }
+
+ public AttachmentMetadata toAttachmentMetadata() {
+ return AttachmentMetadata.builder()
+ .attachmentId(AttachmentId.from(attachmentId))
+ .messageId(new DefaultMessageId())
+ .type(type)
+ .size(size)
+ .build();
+ }
+
+ public MessageAttachmentMetadata toMessageAttachmentMetadata() {
+ return MessageAttachmentMetadata.builder()
+ .attachment(toAttachmentMetadata())
+ .name(Optional.ofNullable(name))
+ .cid(Optional.of(Cid.from(cid)))
+ .isInline(isInline)
+ .build();
+ }
+
+ public String getAttachmentId() {
+ return attachmentId;
+ }
+
+ public String getType() {
+ return type;
+ }
+
+ public long getSize() {
+ return size;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public boolean isInline() {
+ return isInline;
+ }
+
+ public String getCid() {
+ return cid;
+ }
+
+ public InputStream getContent() {
+ return new ByteArrayInputStream(Objects.requireNonNullElse(content,
EMPTY_ARRAY));
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public void setSize(long size) {
+ this.size = size;
+ }
+
+ public void setContent(byte[] bytes) {
+ this.content = bytes;
+ }
+
+ @Override
+ public String toString() {
+ return "Attachment ( "
+ + "attachmentId = " + this.attachmentId + TOSTRING_SEPARATOR
+ + "name = " + this.type + TOSTRING_SEPARATOR
+ + "type = " + this.type + TOSTRING_SEPARATOR
+ + "size = " + this.size + TOSTRING_SEPARATOR
+ + "cid = " + this.cid + TOSTRING_SEPARATOR
+ + "isInline = " + this.isInline + TOSTRING_SEPARATOR
+ + " )";
+ }
+
+ @Override
+ public final boolean equals(Object o) {
+ if (o instanceof JPAAttachment) {
+ JPAAttachment that = (JPAAttachment) o;
+
+ return Objects.equals(this.size, that.size)
+ && Objects.equals(this.attachmentId, that.attachmentId)
+ && Objects.equals(this.cid, that.cid)
+ && Arrays.equals(this.content, that.content)
+ && Objects.equals(this.isInline, that.isInline)
+ && Objects.equals(this.name, that.name)
+ && Objects.equals(this.type, that.type);
+ }
+ return false;
+ }
+
+ @Override
+ public final int hashCode() {
+ return Objects.hash(attachmentId, type, size, name, cid, isInline);
+ }
+}
diff --git
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/openjpa/AbstractJPAMailboxMessage.java
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/openjpa/AbstractJPAMailboxMessage.java
index 6de70c6d8c..73fa322478 100644
---
a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/openjpa/AbstractJPAMailboxMessage.java
+++
b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/openjpa/AbstractJPAMailboxMessage.java
@@ -26,7 +26,7 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
import javax.mail.Flags;
import javax.persistence.Basic;
@@ -38,7 +38,6 @@ import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;
-import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
@@ -47,29 +46,26 @@ import org.apache.james.mailbox.MessageUid;
import org.apache.james.mailbox.ModSeq;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.jpa.JPAId;
+import org.apache.james.mailbox.jpa.mail.model.JPAAttachment;
import org.apache.james.mailbox.jpa.mail.model.JPAMailbox;
import org.apache.james.mailbox.jpa.mail.model.JPAProperty;
import org.apache.james.mailbox.jpa.mail.model.JPAUserFlag;
-import org.apache.james.mailbox.model.AttachmentId;
import org.apache.james.mailbox.model.ComposedMessageId;
import org.apache.james.mailbox.model.ComposedMessageIdWithMetaData;
import org.apache.james.mailbox.model.MessageAttachmentMetadata;
import org.apache.james.mailbox.model.MessageId;
-import org.apache.james.mailbox.model.ParsedAttachment;
import org.apache.james.mailbox.model.ThreadId;
import org.apache.james.mailbox.store.mail.model.DefaultMessageId;
import org.apache.james.mailbox.store.mail.model.DelegatingMailboxMessage;
import org.apache.james.mailbox.store.mail.model.FlagsFactory;
import org.apache.james.mailbox.store.mail.model.MailboxMessage;
import org.apache.james.mailbox.store.mail.model.Property;
-import org.apache.james.mailbox.store.mail.model.impl.MessageParser;
import org.apache.james.mailbox.store.mail.model.impl.Properties;
import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
import org.apache.openjpa.persistence.jdbc.ElementJoinColumn;
import org.apache.openjpa.persistence.jdbc.ElementJoinColumns;
import org.apache.openjpa.persistence.jdbc.Index;
-import com.github.fge.lambdas.Throwing;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
@@ -78,35 +74,35 @@ import com.google.common.collect.ImmutableList;
* {@link DelegatingMailboxMessage}
*/
@IdClass(AbstractJPAMailboxMessage.MailboxIdUidKey.class)
-@NamedQueries({
- @NamedQuery(name = "findRecentMessageUidsInMailbox", query = "SELECT
message.uid FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.recent = TRUE ORDER BY message.uid ASC"),
- @NamedQuery(name = "listUidsInMailbox", query = "SELECT message.uid
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid ASC"),
- @NamedQuery(name = "findUnseenMessagesInMailboxOrderByUid", query =
"SELECT message FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.seen = FALSE ORDER BY message.uid ASC"),
- @NamedQuery(name = "findMessagesInMailbox", query = "SELECT message
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid ASC"),
- @NamedQuery(name = "findMessagesInMailboxBetweenUIDs", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid BETWEEN :fromParam AND :toParam ORDER BY message.uid ASC"),
- @NamedQuery(name = "findMessagesInMailboxWithUID", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid=:uidParam ORDER BY message.uid ASC"),
- @NamedQuery(name = "findMessagesInMailboxAfterUID", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid>=:uidParam ORDER BY message.uid ASC"),
- @NamedQuery(name = "findDeletedMessagesInMailbox", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.deleted=TRUE ORDER BY message.uid ASC"),
- @NamedQuery(name = "findDeletedMessagesInMailboxBetweenUIDs", query =
"SELECT message FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.uid BETWEEN :fromParam AND :toParam AND
message.deleted=TRUE ORDER BY message.uid ASC"),
- @NamedQuery(name = "findDeletedMessagesInMailboxWithUID", query =
"SELECT message FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.uid=:uidParam AND message.deleted=TRUE ORDER BY
message.uid ASC"),
- @NamedQuery(name = "findDeletedMessagesInMailboxAfterUID", query =
"SELECT message FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.uid>=:uidParam AND message.deleted=TRUE ORDER BY
message.uid ASC"),
-
- @NamedQuery(name = "deleteMessagesInMailbox", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam"),
- @NamedQuery(name = "deleteMessagesInMailboxBetweenUIDs", query =
"DELETE FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid BETWEEN :fromParam AND :toParam"),
- @NamedQuery(name = "deleteMessagesInMailboxWithUID", query = "DELETE
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid=:uidParam"),
- @NamedQuery(name = "deleteMessagesInMailboxAfterUID", query = "DELETE
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid>=:uidParam"),
-
- @NamedQuery(name = "countUnseenMessagesInMailbox", query = "SELECT
COUNT(message) FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.seen=FALSE"),
- @NamedQuery(name = "countMessagesInMailbox", query = "SELECT
COUNT(message) FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam"),
- @NamedQuery(name = "deleteMessages", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam"),
- @NamedQuery(name = "findLastUidInMailbox", query = "SELECT message.uid
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid DESC"),
- @NamedQuery(name = "findHighestModSeqInMailbox", query = "SELECT
message.modSeq FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam ORDER BY message.modSeq DESC")
-})
+@NamedQuery(name = "findRecentMessageUidsInMailbox", query = "SELECT
message.uid FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.recent = TRUE ORDER BY message.uid ASC")
+@NamedQuery(name = "listUidsInMailbox", query = "SELECT message.uid FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid ASC")
+@NamedQuery(name = "findUnseenMessagesInMailboxOrderByUid", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.seen = FALSE ORDER BY message.uid ASC")
+@NamedQuery(name = "findMessagesInMailbox", query = "SELECT message FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid ASC")
+@NamedQuery(name = "findMessagesInMailboxBetweenUIDs", query = "SELECT message
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid BETWEEN :fromParam AND :toParam ORDER BY message.uid ASC")
+@NamedQuery(name = "findMessagesInMailboxWithUID", query = "SELECT message
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid=:uidParam ORDER BY message.uid ASC")
+@NamedQuery(name = "findMessagesInMailboxAfterUID", query = "SELECT message
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid>=:uidParam ORDER BY message.uid ASC")
+@NamedQuery(name = "findDeletedMessagesInMailbox", query = "SELECT message
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.deleted=TRUE ORDER BY message.uid ASC")
+@NamedQuery(name = "findDeletedMessagesInMailboxBetweenUIDs", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid BETWEEN :fromParam AND :toParam AND message.deleted=TRUE ORDER
BY message.uid ASC")
+@NamedQuery(name = "findDeletedMessagesInMailboxWithUID", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid=:uidParam AND message.deleted=TRUE ORDER BY message.uid ASC")
+@NamedQuery(name = "findDeletedMessagesInMailboxAfterUID", query = "SELECT
message FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam
AND message.uid>=:uidParam AND message.deleted=TRUE ORDER BY message.uid ASC")
+
+@NamedQuery(name = "deleteMessagesInMailbox", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam")
+@NamedQuery(name = "deleteMessagesInMailboxBetweenUIDs", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid BETWEEN :fromParam AND :toParam")
+@NamedQuery(name = "deleteMessagesInMailboxWithUID", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid=:uidParam")
+@NamedQuery(name = "deleteMessagesInMailboxAfterUID", query = "DELETE FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam AND
message.uid>=:uidParam")
+
+@NamedQuery(name = "countUnseenMessagesInMailbox", query = "SELECT
COUNT(message) FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam AND message.seen=FALSE")
+@NamedQuery(name = "countMessagesInMailbox", query = "SELECT COUNT(message)
FROM MailboxMessage message WHERE message.mailbox.mailboxId = :idParam")
+@NamedQuery(name = "deleteMessages", query = "DELETE FROM MailboxMessage
message WHERE message.mailbox.mailboxId = :idParam")
+@NamedQuery(name = "findLastUidInMailbox", query = "SELECT message.uid FROM
MailboxMessage message WHERE message.mailbox.mailboxId = :idParam ORDER BY
message.uid DESC")
+@NamedQuery(name = "findHighestModSeqInMailbox", query = "SELECT
message.modSeq FROM MailboxMessage message WHERE message.mailbox.mailboxId =
:idParam ORDER BY message.modSeq DESC")
@MappedSuperclass
public abstract class AbstractJPAMailboxMessage implements MailboxMessage {
private static final String TOSTRING_SEPARATOR = " ";
- /** Identifies composite key */
+ /**
+ * Identifies composite key
+ */
@Embeddable
public static class MailboxIdUidKey implements Serializable {
@@ -115,10 +111,14 @@ public abstract class AbstractJPAMailboxMessage
implements MailboxMessage {
public MailboxIdUidKey() {
}
- /** The value for the mailbox field */
+ /**
+ * The value for the mailbox field
+ */
public long mailbox;
- /** The value for the uid field */
+ /**
+ * The value for the uid field
+ */
public long uid;
@Override
@@ -145,115 +145,153 @@ public abstract class AbstractJPAMailboxMessage
implements MailboxMessage {
if (mailbox != other.mailbox) {
return false;
}
- if (uid != other.uid) {
- return false;
- }
- return true;
+ return uid == other.uid;
}
}
- /** The value for the mailboxId field */
+ /**
+ * The value for the mailboxId field
+ */
@Id
- @ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
CascadeType.MERGE }, fetch = FetchType.EAGER)
+ @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.REFRESH,
CascadeType.MERGE}, fetch = FetchType.EAGER)
@Column(name = "MAILBOX_ID", nullable = true)
private JPAMailbox mailbox;
- /** The value for the uid field */
+ /**
+ * The value for the uid field
+ */
@Id
@Column(name = "MAIL_UID")
private long uid;
- /** The value for the modSeq field */
+ /**
+ * The value for the modSeq field
+ */
@Index
@Column(name = "MAIL_MODSEQ")
private long modSeq;
- /** The value for the internalDate field */
+ /**
+ * The value for the internalDate field
+ */
@Basic(optional = false)
@Column(name = "MAIL_DATE")
private Date internalDate;
- /** The value for the answered field */
+ /**
+ * The value for the answered field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_ANSWERED", nullable = false)
private boolean answered = false;
- /** The value for the deleted field */
+ /**
+ * The value for the deleted field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_DELETED", nullable = false)
@Index
private boolean deleted = false;
- /** The value for the draft field */
+ /**
+ * The value for the draft field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_DRAFT", nullable = false)
private boolean draft = false;
- /** The value for the flagged field */
+ /**
+ * The value for the flagged field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_FLAGGED", nullable = false)
private boolean flagged = false;
- /** The value for the recent field */
+ /**
+ * The value for the recent field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_RECENT", nullable = false)
@Index
private boolean recent = false;
- /** The value for the seen field */
+ /**
+ * The value for the seen field
+ */
@Basic(optional = false)
@Column(name = "MAIL_IS_SEEN", nullable = false)
@Index
private boolean seen = false;
- /** The first body octet */
+ /**
+ * The first body octet
+ */
@Basic(optional = false)
@Column(name = "MAIL_BODY_START_OCTET", nullable = false)
private int bodyStartOctet;
- /** Number of octets in the full document content */
+ /**
+ * Number of octets in the full document content
+ */
@Basic(optional = false)
@Column(name = "MAIL_CONTENT_OCTETS_COUNT", nullable = false)
private long contentOctets;
- /** MIME media type */
+ /**
+ * MIME media type
+ */
@Basic(optional = true)
@Column(name = "MAIL_MIME_TYPE", nullable = true, length = 200)
private String mediaType;
- /** MIME sub type */
+ /**
+ * MIME subtype
+ */
@Basic(optional = true)
@Column(name = "MAIL_MIME_SUBTYPE", nullable = true, length = 200)
private String subType;
- /** THE CRFL count when this document is textual, null otherwise */
+ /**
+ * THE CRFL count when this document is textual, null otherwise
+ */
@Basic(optional = true)
@Column(name = "MAIL_TEXTUAL_LINE_COUNT", nullable = true)
private Long textualLineCount;
- /** Meta data for this message */
+ /**
+ * Metadata for this message
+ */
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@OrderBy("line")
- @ElementJoinColumns({ @ElementJoinColumn(name = "MAILBOX_ID",
referencedColumnName = "MAILBOX_ID"),
- @ElementJoinColumn(name = "MAIL_UID", referencedColumnName =
"MAIL_UID") })
+ @ElementJoinColumns({@ElementJoinColumn(name = "MAILBOX_ID",
referencedColumnName = "MAILBOX_ID"),
+ @ElementJoinColumn(name = "MAIL_UID", referencedColumnName =
"MAIL_UID")})
private List<JPAProperty> properties;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER,
orphanRemoval = true)
@OrderBy("id")
- @ElementJoinColumns({ @ElementJoinColumn(name = "MAILBOX_ID",
referencedColumnName = "MAILBOX_ID"),
- @ElementJoinColumn(name = "MAIL_UID", referencedColumnName =
"MAIL_UID") })
+ @ElementJoinColumns({@ElementJoinColumn(name = "MAILBOX_ID",
referencedColumnName = "MAILBOX_ID"),
+ @ElementJoinColumn(name = "MAIL_UID", referencedColumnName =
"MAIL_UID")})
private List<JPAUserFlag> userFlags;
- public AbstractJPAMailboxMessage() {
+ /**
+ * Metadata for attachments
+ */
+ @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
+ @OrderBy("attachmentId")
+ @ElementJoinColumns({@ElementJoinColumn(name = "MAILBOX_ID",
referencedColumnName = "MAILBOX_ID"),
+ @ElementJoinColumn(name = "MAIL_UID", referencedColumnName =
"MAIL_UID")})
+ private List<JPAAttachment> attachments;
+ protected AbstractJPAMailboxMessage() {
}
- public AbstractJPAMailboxMessage(JPAMailbox mailbox, Date internalDate,
Flags flags, long contentOctets,
- int bodyStartOctet, PropertyBuilder propertyBuilder) {
+ protected AbstractJPAMailboxMessage(JPAMailbox mailbox, Date internalDate,
Flags flags, long contentOctets,
+ int bodyStartOctet, PropertyBuilder
propertyBuilder) {
this.mailbox = mailbox;
this.internalDate = internalDate;
userFlags = new ArrayList<>();
+ attachments = new ArrayList<>();
setFlags(flags);
this.contentOctets = contentOctets;
@@ -275,17 +313,13 @@ public abstract class AbstractJPAMailboxMessage
implements MailboxMessage {
* Constructs a copy of the given message. All properties are cloned except
* mailbox and UID.
*
- * @param mailbox
- * new mailbox
- * @param uid
- * new UID
- * @param modSeq
- * new modSeq
- * @param original
- * message to be copied, not null
+ * @param mailbox new mailbox
+ * @param uid new UID
+ * @param modSeq new modSeq
+ * @param original message to be copied, not null
*/
- public AbstractJPAMailboxMessage(JPAMailbox mailbox, MessageUid uid,
ModSeq modSeq, MailboxMessage original)
- throws MailboxException {
+ protected AbstractJPAMailboxMessage(JPAMailbox mailbox, MessageUid uid,
ModSeq modSeq, MailboxMessage original)
+ throws MailboxException {
super();
this.mailbox = mailbox;
this.uid = uid.asLong();
@@ -310,6 +344,7 @@ public abstract class AbstractJPAMailboxMessage implements
MailboxMessage {
for (Property property : properties) {
this.properties.add(new JPAProperty(property, order++));
}
+ this.attachments = new ArrayList<>();
}
@Override
@@ -322,7 +357,7 @@ public abstract class AbstractJPAMailboxMessage implements
MailboxMessage {
if (obj instanceof AbstractJPAMailboxMessage) {
AbstractJPAMailboxMessage other = (AbstractJPAMailboxMessage) obj;
return Objects.equal(getMailboxId(), other.getMailboxId())
- && Objects.equal(uid, other.getUid());
+ && Objects.equal(uid, other.getUid());
}
return false;
}
@@ -514,38 +549,29 @@ public abstract class AbstractJPAMailboxMessage
implements MailboxMessage {
public String toString() {
return "message("
- + "mailboxId = " + this.getMailboxId() + TOSTRING_SEPARATOR
- + "uid = " + this.uid + TOSTRING_SEPARATOR
- + "internalDate = " + this.internalDate + TOSTRING_SEPARATOR
- + "answered = " + this.answered + TOSTRING_SEPARATOR
- + "deleted = " + this.deleted + TOSTRING_SEPARATOR
- + "draft = " + this.draft + TOSTRING_SEPARATOR
- + "flagged = " + this.flagged + TOSTRING_SEPARATOR
- + "recent = " + this.recent + TOSTRING_SEPARATOR
- + "seen = " + this.seen + TOSTRING_SEPARATOR
- + " )";
+ + "mailboxId = " + this.getMailboxId() + TOSTRING_SEPARATOR
+ + "uid = " + this.uid + TOSTRING_SEPARATOR
+ + "internalDate = " + this.internalDate + TOSTRING_SEPARATOR
+ + "answered = " + this.answered + TOSTRING_SEPARATOR
+ + "deleted = " + this.deleted + TOSTRING_SEPARATOR
+ + "draft = " + this.draft + TOSTRING_SEPARATOR
+ + "flagged = " + this.flagged + TOSTRING_SEPARATOR
+ + "recent = " + this.recent + TOSTRING_SEPARATOR
+ + "seen = " + this.seen + TOSTRING_SEPARATOR
+ + " )";
}
- @Override
- public List<MessageAttachmentMetadata> getAttachments() {
- try {
- AtomicInteger counter = new AtomicInteger(0);
- MessageParser.ParsingResult parsingResult = new
MessageParser().retrieveAttachments(getFullContent());
- ImmutableList<MessageAttachmentMetadata> result = parsingResult
- .getAttachments()
- .stream()
- .map(Throwing.<ParsedAttachment,
MessageAttachmentMetadata>function(
- attachmentMetadata ->
attachmentMetadata.asMessageAttachment(generateFixedAttachmentId(counter.incrementAndGet()),
getMessageId()))
- .sneakyThrow())
- .collect(ImmutableList.toImmutableList());
- parsingResult.dispose();
- return result;
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
+ /**
+ * Utility attachments' setter.
+ */
+ public void setAttachments(List<JPAAttachment> attachments) {
+ this.attachments = attachments;
}
- private AttachmentId generateFixedAttachmentId(int position) {
- return AttachmentId.from(getMailboxId().serialize() + "-" +
getUid().asLong() + "-" + position);
+ @Override
+ public List<MessageAttachmentMetadata> getAttachments() {
+ return this.attachments.stream()
+ .map(JPAAttachment::toMessageAttachmentMetadata)
+ .collect(Collectors.toList());
}
}
diff --git
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/JPAMailboxFixture.java
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/JPAMailboxFixture.java
index 26682bc17b..6dc6d62d5b 100644
---
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/JPAMailboxFixture.java
+++
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/JPAMailboxFixture.java
@@ -21,6 +21,7 @@ package org.apache.james.mailbox.jpa;
import java.util.List;
+import org.apache.james.mailbox.jpa.mail.model.JPAAttachment;
import org.apache.james.mailbox.jpa.mail.model.JPAMailbox;
import org.apache.james.mailbox.jpa.mail.model.JPAMailboxAnnotation;
import org.apache.james.mailbox.jpa.mail.model.JPAProperty;
@@ -47,7 +48,8 @@ public interface JPAMailboxFixture {
JPAProperty.class,
JPAUserFlag.class,
JPAMailboxAnnotation.class,
- JPASubscription.class
+ JPASubscription.class,
+ JPAAttachment.class
);
List<Class<?>> QUOTA_PERSISTANCE_CLASSES = ImmutableList.of(
@@ -66,7 +68,8 @@ public interface JPAMailboxFixture {
"JAMES_MAILBOX_ANNOTATION",
"JAMES_MAILBOX",
"JAMES_MAIL",
- "JAMES_SUBSCRIPTION");
+ "JAMES_SUBSCRIPTION",
+ "JAMES_ATTACHMENT");
List<String> QUOTA_TABLES_NAMES = ImmutableList.of(
"JAMES_MAX_GLOBAL_MESSAGE_COUNT",
diff --git
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapperTest.java
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapperTest.java
new file mode 100644
index 0000000000..552d50a9e9
--- /dev/null
+++
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAAttachmentMapperTest.java
@@ -0,0 +1,101 @@
+/***************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ***************************************************************/
+
+
+package org.apache.james.mailbox.jpa.mail;
+
+import java.nio.charset.StandardCharsets;
+
+import org.apache.james.backends.jpa.JpaTestCluster;
+import org.apache.james.mailbox.jpa.JPAMailboxFixture;
+import org.apache.james.mailbox.model.AttachmentMetadata;
+import org.apache.james.mailbox.model.ContentType;
+import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.ParsedAttachment;
+import org.apache.james.mailbox.store.mail.AttachmentMapper;
+import org.apache.james.mailbox.store.mail.model.AttachmentMapperTest;
+import org.apache.james.mailbox.store.mail.model.DefaultMessageId;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteSource;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.tuple;
+
+class JPAAttachmentMapperTest extends AttachmentMapperTest {
+
+ private static final JpaTestCluster JPA_TEST_CLUSTER =
JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
+
+ @AfterEach
+ void cleanUp() {
+ JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
+ }
+
+ @Override
+ protected AttachmentMapper createAttachmentMapper() {
+ return new TransactionalAttachmentMapper(new
JPAAttachmentMapper(JPA_TEST_CLUSTER.getEntityManagerFactory()));
+ }
+
+ @Override
+ protected MessageId generateMessageId() {
+ return new DefaultMessageId.Factory().generate();
+ }
+
+ @Test
+ @Override
+ public void getAttachmentsShouldReturnTheAttachmentsWhenSome() throws
Exception {
+ //Given
+ ContentType content1 = ContentType.of("content");
+ byte[] bytes1 = "payload" .getBytes(StandardCharsets.UTF_8);
+ ContentType content2 = ContentType.of("content");
+ byte[] bytes2 = "payload" .getBytes(StandardCharsets.UTF_8);
+
+ MessageId messageId1 = generateMessageId();
+ AttachmentMetadata stored1 =
attachmentMapper.storeAttachments(ImmutableList.of(ParsedAttachment.builder()
+ .contentType(content1)
+ .content(ByteSource.wrap(bytes1))
+ .noName()
+ .noCid()
+ .inline(false)), messageId1).get(0)
+ .getAttachment();
+ AttachmentMetadata stored2 =
attachmentMapper.storeAttachments(ImmutableList.of(ParsedAttachment.builder()
+ .contentType(content2)
+ .content(ByteSource.wrap(bytes2))
+ .noName()
+ .noCid()
+ .inline(false)), messageId1).get(0)
+ .getAttachment();
+
+ // JPA does not support MessageId
+
assertThat(attachmentMapper.getAttachments(ImmutableList.of(stored1.getAttachmentId(),
stored2.getAttachmentId())))
+ .extracting(
+ AttachmentMetadata::getAttachmentId,
+ AttachmentMetadata::getSize,
+ AttachmentMetadata::getType
+ )
+ .contains(
+ tuple(stored1.getAttachmentId(), stored1.getSize(),
stored1.getType()),
+ tuple(stored2.getAttachmentId(), stored2.getSize(),
stored2.getType())
+ );
+ }
+
+}
diff --git
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMapperProvider.java
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMapperProvider.java
index c8eb9760dd..58e735840f 100644
---
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMapperProvider.java
+++
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMapperProvider.java
@@ -68,7 +68,7 @@ public class JPAMapperProvider implements MapperProvider {
@Override
public AttachmentMapper createAttachmentMapper() throws MailboxException {
- throw new NotImplementedException("not implemented");
+ return new TransactionalAttachmentMapper(new
JPAAttachmentMapper(jpaTestCluster.getEntityManagerFactory()));
}
@Override
@@ -88,7 +88,7 @@ public class JPAMapperProvider implements MapperProvider {
@Override
public List<Capabilities> getSupportedCapabilities() {
- return ImmutableList.of(Capabilities.ANNOTATION, Capabilities.MAILBOX,
Capabilities.MESSAGE, Capabilities.MOVE);
+ return ImmutableList.of(Capabilities.ANNOTATION, Capabilities.MAILBOX,
Capabilities.MESSAGE, Capabilities.MOVE, Capabilities.ATTACHMENT);
}
@Override
diff --git
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMessageWithAttachmentMapperTest.java
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMessageWithAttachmentMapperTest.java
new file mode 100644
index 0000000000..a744d806bd
--- /dev/null
+++
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JPAMessageWithAttachmentMapperTest.java
@@ -0,0 +1,132 @@
+/***************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.mailbox.jpa.mail;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.james.backends.jpa.JpaTestCluster;
+import org.apache.james.mailbox.exception.MailboxException;
+import org.apache.james.mailbox.jpa.JPAMailboxFixture;
+import org.apache.james.mailbox.model.AttachmentMetadata;
+import org.apache.james.mailbox.model.MessageAttachmentMetadata;
+import org.apache.james.mailbox.model.MessageRange;
+import org.apache.james.mailbox.store.mail.MessageMapper;
+import org.apache.james.mailbox.store.mail.model.MailboxMessage;
+import org.apache.james.mailbox.store.mail.model.MapperProvider;
+import org.apache.james.mailbox.store.mail.model.MessageAssert;
+import
org.apache.james.mailbox.store.mail.model.MessageWithAttachmentMapperTest;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.tuple;
+
+class JPAMessageWithAttachmentMapperTest extends
MessageWithAttachmentMapperTest {
+
+ static final JpaTestCluster JPA_TEST_CLUSTER =
JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
+
+ @Override
+ protected MapperProvider createMapperProvider() {
+ return new JPAMapperProvider(JPA_TEST_CLUSTER);
+ }
+
+ @AfterEach
+ void cleanUp() {
+ JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
+ }
+
+ @Test
+ @Override
+ protected void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment()
throws MailboxException {
+ saveMessages();
+ MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
+ Iterator<MailboxMessage> retrievedMessageIterator =
messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
+
+ AttachmentMetadata attachment =
messageWith1Attachment.getAttachments().get(0).getAttachment();
+ MessageAttachmentMetadata attachmentMetadata =
messageWith1Attachment.getAttachments().get(0);
+ List<MessageAttachmentMetadata> messageAttachments =
retrievedMessageIterator.next().getAttachments();
+
+ // JPA does not support MessageId
+ assertThat(messageAttachments)
+ .extracting(MessageAttachmentMetadata::getAttachment)
+ .extracting("attachmentId", "size", "type")
+ .containsExactlyInAnyOrder(
+ tuple(attachment.getAttachmentId(), attachment.getSize(),
attachment.getType())
+ );
+ assertThat(messageAttachments)
+ .extracting(
+ MessageAttachmentMetadata::getAttachmentId,
+ MessageAttachmentMetadata::getName,
+ MessageAttachmentMetadata::getCid,
+ MessageAttachmentMetadata::isInline
+ )
+ .containsExactlyInAnyOrder(
+ tuple(attachmentMetadata.getAttachmentId(),
attachmentMetadata.getName(), attachmentMetadata.getCid(),
attachmentMetadata.isInline())
+ );
+ }
+
+ @Test
+ @Override
+ protected void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments()
throws MailboxException {
+ saveMessages();
+ MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
+ Iterator<MailboxMessage> retrievedMessageIterator =
messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith2Attachments.getUid()), fetchType, LIMIT);
+
+ AttachmentMetadata attachment1 =
messageWith2Attachments.getAttachments().get(0).getAttachment();
+ AttachmentMetadata attachment2 =
messageWith2Attachments.getAttachments().get(1).getAttachment();
+ MessageAttachmentMetadata attachmentMetadata1 =
messageWith2Attachments.getAttachments().get(0);
+ MessageAttachmentMetadata attachmentMetadata2 =
messageWith2Attachments.getAttachments().get(1);
+ List<MessageAttachmentMetadata> messageAttachments =
retrievedMessageIterator.next().getAttachments();
+
+ // JPA does not support MessageId
+ assertThat(messageAttachments)
+ .extracting(MessageAttachmentMetadata::getAttachment)
+ .extracting("attachmentId", "size", "type")
+ .containsExactlyInAnyOrder(
+ tuple(attachment1.getAttachmentId(), attachment1.getSize(),
attachment1.getType()),
+ tuple(attachment2.getAttachmentId(), attachment2.getSize(),
attachment2.getType())
+ );
+ assertThat(messageAttachments)
+ .extracting(
+ MessageAttachmentMetadata::getAttachmentId,
+ MessageAttachmentMetadata::getName,
+ MessageAttachmentMetadata::getCid,
+ MessageAttachmentMetadata::isInline
+ )
+ .containsExactlyInAnyOrder(
+ tuple(attachmentMetadata1.getAttachmentId(),
attachmentMetadata1.getName(), attachmentMetadata1.getCid(),
attachmentMetadata1.isInline()),
+ tuple(attachmentMetadata2.getAttachmentId(),
attachmentMetadata2.getName(), attachmentMetadata2.getCid(),
attachmentMetadata2.isInline())
+ );
+ }
+
+ @Test
+ @Override
+ protected void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws
MailboxException, IOException {
+ saveMessages();
+ MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
+
+ // JPA does not support MessageId
+
MessageAssert.assertThat(messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT).next())
+ .isEqualToWithoutAttachment(messageWith1Attachment, fetchType);
+ }
+}
diff --git
a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/TransactionalAttachmentMapper.java
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/TransactionalAttachmentMapper.java
new file mode 100644
index 0000000000..edea6f910c
--- /dev/null
+++
b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/TransactionalAttachmentMapper.java
@@ -0,0 +1,84 @@
+/***************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.mailbox.jpa.mail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.james.mailbox.exception.AttachmentNotFoundException;
+import org.apache.james.mailbox.exception.MailboxException;
+import org.apache.james.mailbox.model.AttachmentId;
+import org.apache.james.mailbox.model.AttachmentMetadata;
+import org.apache.james.mailbox.model.MessageAttachmentMetadata;
+import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.ParsedAttachment;
+import org.apache.james.mailbox.store.mail.AttachmentMapper;
+
+import reactor.core.publisher.Mono;
+
+public class TransactionalAttachmentMapper implements AttachmentMapper {
+ private final JPAAttachmentMapper attachmentMapper;
+
+ public TransactionalAttachmentMapper(JPAAttachmentMapper attachmentMapper)
{
+ this.attachmentMapper = attachmentMapper;
+ }
+
+ @Override
+ public InputStream loadAttachmentContent(AttachmentId attachmentId) throws
AttachmentNotFoundException, IOException {
+ return attachmentMapper.loadAttachmentContent(attachmentId);
+ }
+
+ @Override
+ public Mono<InputStream> loadAttachmentContentReactive(AttachmentId
attachmentId) {
+ return
attachmentMapper.executeReactive(attachmentMapper.loadAttachmentContentReactive(attachmentId));
+ }
+
+ @Override
+ public AttachmentMetadata getAttachment(AttachmentId attachmentId) throws
AttachmentNotFoundException {
+ return attachmentMapper.getAttachment(attachmentId);
+ }
+
+ @Override
+ public Mono<AttachmentMetadata> getAttachmentReactive(AttachmentId
attachmentId) {
+ return
attachmentMapper.executeReactive(attachmentMapper.getAttachmentReactive(attachmentId));
+ }
+
+ @Override
+ public List<AttachmentMetadata> getAttachments(Collection<AttachmentId>
attachmentIds) {
+ return attachmentMapper.getAttachments(attachmentIds);
+ }
+
+ @Override
+ public List<MessageAttachmentMetadata>
storeAttachments(Collection<ParsedAttachment> attachments, MessageId
ownerMessageId) throws MailboxException {
+ return attachmentMapper.execute(() ->
attachmentMapper.storeAttachments(attachments, ownerMessageId));
+ }
+
+ @Override
+ public Mono<List<MessageAttachmentMetadata>>
storeAttachmentsReactive(Collection<ParsedAttachment> attachments, MessageId
ownerMessageId) {
+ return
attachmentMapper.executeReactive(attachmentMapper.storeAttachmentsReactive(attachments,
ownerMessageId));
+ }
+
+ @Override
+ public Collection<MessageId> getRelatedMessageIds(AttachmentId
attachmentId) throws MailboxException {
+ return attachmentMapper.getRelatedMessageIds(attachmentId);
+ }
+}
diff --git a/mailbox/jpa/src/test/resources/persistence.xml
b/mailbox/jpa/src/test/resources/persistence.xml
index bf27655a71..ae8f4361d0 100644
--- a/mailbox/jpa/src/test/resources/persistence.xml
+++ b/mailbox/jpa/src/test/resources/persistence.xml
@@ -28,6 +28,7 @@
<class>org.apache.james.mailbox.jpa.mail.model.JPAUserFlag</class>
<class>org.apache.james.mailbox.jpa.mail.model.openjpa.AbstractJPAMailboxMessage</class>
<class>org.apache.james.mailbox.jpa.mail.model.openjpa.JPAMailboxMessage</class>
+ <class>org.apache.james.mailbox.jpa.mail.model.JPAAttachment</class>
<class>org.apache.james.mailbox.jpa.mail.model.JPAProperty</class>
<class>org.apache.james.mailbox.jpa.user.model.JPASubscription</class>
<class>org.apache.james.mailbox.jpa.quota.model.MaxDomainMessageCount</class>
diff --git
a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
index e644059284..1fe637f3df 100644
---
a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
+++
b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
@@ -19,9 +19,6 @@
package org.apache.james.mailbox.store.mail.model;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.util.List;
@@ -34,19 +31,24 @@ import org.apache.james.mailbox.model.ContentType;
import org.apache.james.mailbox.model.MessageId;
import org.apache.james.mailbox.model.ParsedAttachment;
import org.apache.james.mailbox.store.mail.AttachmentMapper;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteSource;
+
import org.assertj.core.api.SoftAssertions;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
-import com.google.common.collect.ImmutableList;
-import com.google.common.io.ByteSource;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
public abstract class AttachmentMapperTest {
private static final AttachmentId UNKNOWN_ATTACHMENT_ID =
AttachmentId.from("unknown");
private static final Username OWNER = Username.of("owner");
private static final Username ADDITIONAL_OWNER =
Username.of("additionalOwner");
- private AttachmentMapper attachmentMapper;
+ protected AttachmentMapper attachmentMapper;
protected abstract AttachmentMapper createAttachmentMapper();
@@ -145,7 +147,8 @@ public abstract class AttachmentMapperTest {
}
@Test
- void getAttachmentsShouldReturnTheAttachmentsWhenSome() throws Exception {
+ @Disabled
+ protected void getAttachmentsShouldReturnTheAttachmentsWhenSome() throws
Exception {
//Given
ContentType content1 = ContentType.of("content");
byte[] bytes1 = "payload".getBytes(StandardCharsets.UTF_8);
diff --git
a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java
b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java
index c39bba5e45..62f7bd33a2 100644
---
a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java
+++
b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java
@@ -44,6 +44,7 @@ import org.apache.james.mailbox.model.ParsedAttachment;
import org.apache.james.mailbox.model.ThreadId;
import org.apache.james.mailbox.model.UidValidity;
import org.apache.james.mailbox.store.mail.AttachmentMapper;
+import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.MessageMapper;
import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
@@ -56,19 +57,21 @@ import com.google.common.io.ByteSource;
public abstract class MessageWithAttachmentMapperTest {
- private static final int LIMIT = 10;
+ protected static final int LIMIT = 10;
private static final int BODY_START = 16;
private static final UidValidity UID_VALIDITY = UidValidity.of(42);
- private MapperProvider mapperProvider;
- private MessageMapper messageMapper;
+ protected MapperProvider mapperProvider;
+ protected MessageMapper messageMapper;
private AttachmentMapper attachmentMapper;
- private Mailbox attachmentsMailbox;
+ private MailboxMapper mailBoxMapper;
+
+ protected Mailbox attachmentsMailbox;
- private SimpleMailboxMessage messageWithoutAttachment;
- private SimpleMailboxMessage messageWith1Attachment;
- private SimpleMailboxMessage messageWith2Attachments;
+ protected SimpleMailboxMessage messageWithoutAttachment;
+ protected SimpleMailboxMessage messageWith1Attachment;
+ protected SimpleMailboxMessage messageWith2Attachments;
protected abstract MapperProvider createMapperProvider();
@@ -81,6 +84,7 @@ public abstract class MessageWithAttachmentMapperTest {
this.messageMapper = mapperProvider.createMessageMapper();
this.attachmentMapper = mapperProvider.createAttachmentMapper();
+ this.mailBoxMapper = mapperProvider.createMailboxMapper();
attachmentsMailbox =
createMailbox(MailboxPath.forUser(Username.of("benwa"), "Attachments"));
ParsedAttachment attachment1 = ParsedAttachment.builder()
@@ -119,7 +123,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment()
throws MailboxException {
+ protected void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment()
throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
Iterator<MailboxMessage> retrievedMessageIterator =
messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
@@ -127,7 +131,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments()
throws MailboxException {
+ protected void
messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments()
throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
Iterator<MailboxMessage> retrievedMessageIterator =
messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith2Attachments.getUid()), fetchType, LIMIT);
@@ -161,7 +165,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws
MailboxException, IOException {
+ protected void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws
MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.FULL;
assertThat(messageMapper.findInMailbox(attachmentsMailbox,
MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT).next())
@@ -169,10 +173,10 @@ public abstract class MessageWithAttachmentMapperTest {
}
private Mailbox createMailbox(MailboxPath mailboxPath) {
- return new Mailbox(mailboxPath, UID_VALIDITY,
mapperProvider.generateId());
+ return mailBoxMapper.create(mailboxPath, UID_VALIDITY).block();
}
- private void saveMessages() throws MailboxException {
+ protected void saveMessages() throws MailboxException {
messageMapper.add(attachmentsMailbox, messageWithoutAttachment);
messageWithoutAttachment.setModSeq(messageMapper.getHighestModSeq(attachmentsMailbox));
messageMapper.add(attachmentsMailbox, messageWith1Attachment);
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscr...@james.apache.org
For additional commands, e-mail: notifications-h...@james.apache.org
