You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by bt...@apache.org on 2023/02/21 01:17:57 UTC
[james-project] 01/02: JAMES-3440 Email/query (EmailQueryView usage case) should filter share mailboxes
This is an automated email from the ASF dual-hosted git repository.
btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit bc6fed8ebb10ab516259849c68a2e4b97665f106
Author: Quan Tran <hq...@linagora.com>
AuthorDate: Mon Feb 20 17:23:03 2023 +0700
JAMES-3440 Email/query (EmailQueryView usage case) should filter share mailboxes
---
.../contract/EmailQueryMethodContract.scala | 592 +++++++++++++++++++++
.../james/jmap/method/EmailQueryMethod.scala | 41 +-
2 files changed, 617 insertions(+), 16 deletions(-)
diff --git a/server/protocols/jmap-rfc-8621-integration-tests/jmap-rfc-8621-integration-tests-common/src/main/scala/org/apache/james/jmap/rfc8621/contract/EmailQueryMethodContract.scala b/server/protocols/jmap-rfc-8621-integration-tests/jmap-rfc-8621-integration-tests-common/src/main/scala/org/apache/james/jmap/rfc8621/contract/EmailQueryMethodContract.scala
index 480d078406..2773022055 100644
--- a/server/protocols/jmap-rfc-8621-integration-tests/jmap-rfc-8621-integration-tests-common/src/main/scala/org/apache/james/jmap/rfc8621/contract/EmailQueryMethodContract.scala
+++ b/server/protocols/jmap-rfc-8621-integration-tests/jmap-rfc-8621-integration-tests-common/src/main/scala/org/apache/james/jmap/rfc8621/contract/EmailQueryMethodContract.scala
@@ -710,6 +710,304 @@ trait EmailQueryMethodContract {
}
}
+ @Test
+ def inMailboxFilterWithSortedByReceivedAtShouldReturnEmptyForSharedMailboxesWhenNoSharesExtension(server: GuiceJamesServer): Unit = {
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "receivedAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState()}",
+ | "canCalculateChanges": false,
+ | "ids": [
+ |
+ | ],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin)
+ }
+
+ @Test
+ def inMailboxFilterWithSortedByReceivedAtShouldAcceptSharedMailboxesWhenSharesExtension(server: GuiceJamesServer): Unit = {
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ val messageId1: MessageId = mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail",
+ | "urn:apache:james:params:jmap:mail:shares"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "receivedAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ awaitAtMostTenSeconds.untilAsserted { () =>
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState(messageId1)}",
+ | "canCalculateChanges": false,
+ | "position": 0,
+ | "limit": 256,
+ | "ids": ["${messageId1.serialize()}"]
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+ }
+
+ @Test
+ def inMailboxFilterWithSortedBySentAtShouldReturnEmptyForSharedMailboxesWhenNoSharesExtension(server: GuiceJamesServer): Unit = {
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "sentAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState()}",
+ | "canCalculateChanges": false,
+ | "ids": [
+ |
+ | ],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin)
+ }
+
+ @Test
+ def inMailboxFilterWithSortedBySentAtShouldAcceptSharedMailboxesWhenSharesExtension(server: GuiceJamesServer): Unit = {
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ val messageId1: MessageId = mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail",
+ | "urn:apache:james:params:jmap:mail:shares"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "sentAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ awaitAtMostTenSeconds.untilAsserted { () =>
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState(messageId1)}",
+ | "canCalculateChanges": false,
+ | "position": 0,
+ | "limit": 256,
+ | "ids": ["${messageId1.serialize()}"]
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+ }
+
@Test
def inMailboxOtherThanFilterShouldReturnEmptyForSharedMailboxesWhenNoExtension(server: GuiceJamesServer): Unit = {
val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
@@ -771,6 +1069,300 @@ trait EmailQueryMethodContract {
|}""".stripMargin)
}
+ @Test
+ def inMailboxAfterWithSortedBySentAtShouldReturnEmptyForSharedMailboxesWhenNoSharesExtension(server: GuiceJamesServer): Unit = {
+ val requestDate = ZonedDateTime.now().minusDays(1)
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}",
+ | "after": "${UTCDate(requestDate).asUTC.format(UTC_DATE_FORMAT)}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "sentAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState()}",
+ | "canCalculateChanges": false,
+ | "ids": [],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+
+ @Test
+ def inMailboxAfterWithSortedBySentAtShouldAcceptSharedMailboxesWhenSharesExtension(server: GuiceJamesServer): Unit = {
+ val requestDate = ZonedDateTime.now().minusDays(1)
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ val messageId1: MessageId = mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail",
+ | "urn:apache:james:params:jmap:mail:shares"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}",
+ | "after": "${UTCDate(requestDate).asUTC.format(UTC_DATE_FORMAT)}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "sentAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState(messageId1)}",
+ | "canCalculateChanges": false,
+ | "ids": ["${messageId1.serialize()}"],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+
+ @Test
+ def inMailboxAfterWithSortedByReceivedAtShouldReturnEmptyForSharedMailboxesWhenNoSharesExtension(server: GuiceJamesServer): Unit = {
+ val requestDate = ZonedDateTime.now().minusDays(1)
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}",
+ | "after": "${UTCDate(requestDate).asUTC.format(UTC_DATE_FORMAT)}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "receivedAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState()}",
+ | "canCalculateChanges": false,
+ | "ids": [],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+
+ @Test
+ def inMailboxAfterWithSortedByReceivedAtShouldAcceptSharedMailboxesWhenSharesExtension(server: GuiceJamesServer): Unit = {
+ val requestDate = ZonedDateTime.now().minusDays(1)
+ val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
+ val andreInboxId = mailboxProbe.createMailbox(inbox(ANDRE))
+ val messageId1: MessageId = mailboxProbe
+ .appendMessage(ANDRE.asString, inbox(ANDRE),
+ AppendCommand.from(
+ Message.Builder
+ .of
+ .setSubject("test")
+ .setBody("testmail", StandardCharsets.UTF_8)
+ .build))
+ .getMessageId
+
+ server.getProbe(classOf[ACLProbeImpl])
+ .addRights(inbox(ANDRE), BOB.asString, new MailboxACL.Rfc4314Rights(Right.Read, Right.Lookup))
+
+ val request =
+ s"""{
+ | "using": [
+ | "urn:ietf:params:jmap:core",
+ | "urn:ietf:params:jmap:mail",
+ | "urn:apache:james:params:jmap:mail:shares"
+ | ],
+ | "methodCalls": [
+ | [
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "filter": {
+ | "inMailbox": "${andreInboxId.serialize()}",
+ | "after": "${UTCDate(requestDate).asUTC.format(UTC_DATE_FORMAT)}"
+ | },
+ | "sort": [{
+ | "isAscending": false,
+ | "property": "receivedAt"
+ | }]
+ | },
+ | "c1"
+ | ]
+ | ]
+ |}""".stripMargin
+
+ val response = `given`
+ .header(ACCEPT.toString, ACCEPT_RFC8621_VERSION_HEADER)
+ .body(request)
+ .when
+ .post
+ .`then`
+ .statusCode(SC_OK)
+ .contentType(JSON)
+ .extract
+ .body
+ .asString
+
+ assertThatJson(response).isEqualTo(
+ s"""{
+ | "sessionState": "${SESSION_STATE.value}",
+ | "methodResponses": [[
+ | "Email/query",
+ | {
+ | "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+ | "queryState": "${generateQueryState(messageId1)}",
+ | "canCalculateChanges": false,
+ | "ids": ["${messageId1.serialize()}"],
+ | "position": 0,
+ | "limit": 256
+ | },
+ | "c1"
+ | ]]
+ |}""".stripMargin)
+ }
+
@Test
def inMailboxOtherThanFilterShouldAcceptSharedMailboxesWhenExtension(server: GuiceJamesServer): Unit = {
val mailboxProbe = server.getProbe(classOf[MailboxProbeImpl])
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/EmailQueryMethod.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/EmailQueryMethod.scala
index 7bd1e09ad7..29692e118f 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/EmailQueryMethod.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/EmailQueryMethod.scala
@@ -18,8 +18,12 @@
****************************************************************/
package org.apache.james.jmap.method
+import java.time.ZonedDateTime
+
import cats.implicits._
import eu.timepit.refined.auto._
+import javax.inject.Inject
+import javax.mail.Flags.Flag.DELETED
import org.apache.james.jmap.JMAPConfiguration
import org.apache.james.jmap.api.projections.EmailQueryView
import org.apache.james.jmap.core.CapabilityIdentifier.{CapabilityIdentifier, JMAP_CORE, JMAP_MAIL}
@@ -33,15 +37,12 @@ import org.apache.james.jmap.routes.SessionSupplier
import org.apache.james.jmap.utils.search.MailboxFilter
import org.apache.james.jmap.utils.search.MailboxFilter.QueryFilter
import org.apache.james.mailbox.exception.MailboxNotFoundException
+import org.apache.james.mailbox.model.MultimailboxesSearchQuery.Namespace
import org.apache.james.mailbox.model.{MailboxId, MessageId, MultimailboxesSearchQuery, SearchQuery}
import org.apache.james.mailbox.{MailboxManager, MailboxSession}
import org.apache.james.metrics.api.MetricFactory
import org.apache.james.util.streams.{Limit => JavaLimit}
import reactor.core.scala.publisher.{SFlux, SMono}
-import java.time.ZonedDateTime
-
-import javax.inject.Inject
-import javax.mail.Flags.Flag.DELETED
import scala.jdk.CollectionConverters._
@@ -93,73 +94,81 @@ class EmailQueryMethod @Inject() (serializer: EmailQuerySerializer,
private def executeQuery(session: MailboxSession, request: EmailQueryRequest, searchQuery: MultimailboxesSearchQuery, position: Position, limit: Limit): SMono[EmailQueryResponse] = {
val ids: SMono[Seq[MessageId]] = request match {
case request: EmailQueryRequest if matchesInMailboxSortedBySentAt(request) =>
- queryViewForListingSortedBySentAt(session, position, limit, request)
+ queryViewForListingSortedBySentAt(session, position, limit, request, searchQuery.getNamespace)
case request: EmailQueryRequest if matchesInMailboxAfterSortedBySentAt(request) =>
- queryViewForContentAfterSortedBySentAt(session, position, limit, request)
+ queryViewForContentAfterSortedBySentAt(session, position, limit, request, searchQuery.getNamespace)
case request: EmailQueryRequest if matchesInMailboxSortedByReceivedAt(request) =>
- queryViewForListingSortedByReceivedAt(session, position, limit, request)
+ queryViewForListingSortedByReceivedAt(session, position, limit, request, searchQuery.getNamespace)
case request: EmailQueryRequest if matchesInMailboxAfterSortedByReceivedAt(request) =>
- queryViewForContentAfterSortedByReceivedAt(session, position, limit, request)
+ queryViewForContentAfterSortedByReceivedAt(session, position, limit, request, searchQuery.getNamespace)
case _ => executeQueryAgainstSearchIndex(session, searchQuery, position, limit)
}
ids.map(ids => toResponse(request, position, limit, ids))
}
- private def queryViewForContentAfterSortedBySentAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest): SMono[Seq[MessageId]] = {
+ private def queryViewForContentAfterSortedBySentAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest, namespace: Namespace): SMono[Seq[MessageId]] = {
val condition: FilterCondition = request.filter.get.asInstanceOf[FilterCondition]
val mailboxId: MailboxId = condition.inMailbox.get
val after: ZonedDateTime = condition.after.get.asUTC
SMono(mailboxManager.getMailboxReactive(mailboxId, mailboxSession))
- .`then`(SFlux.fromPublisher(
+ .filter(messageManager => namespace.keepAccessible(messageManager.getMailboxEntity))
+ .flatMap(_ => SFlux.fromPublisher(
emailQueryView.listMailboxContentSinceReceivedAt(mailboxId, after, JavaLimit.from(limitToUse.value + position.value)))
.drop(position.value)
.take(limitToUse.value)
.collectSeq())
+ .switchIfEmpty(SMono.just[Seq[MessageId]](Seq()))
.onErrorResume({
case _: MailboxNotFoundException => SMono.just[Seq[MessageId]](Seq())
case e => SMono.error[Seq[MessageId]](e)
})
}
- private def queryViewForContentAfterSortedByReceivedAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest): SMono[Seq[MessageId]] = {
+ private def queryViewForContentAfterSortedByReceivedAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest, namespace: Namespace): SMono[Seq[MessageId]] = {
val condition: FilterCondition = request.filter.get.asInstanceOf[FilterCondition]
val mailboxId: MailboxId = condition.inMailbox.get
val after: ZonedDateTime = condition.after.get.asUTC
SMono(mailboxManager.getMailboxReactive(mailboxId, mailboxSession))
- .`then`(SFlux.fromPublisher(
+ .filter(messageManager => namespace.keepAccessible(messageManager.getMailboxEntity))
+ .flatMap(_ => SFlux.fromPublisher(
emailQueryView.listMailboxContentSinceReceivedAtSortedByReceivedAt(mailboxId, after, JavaLimit.from(limitToUse.value + position.value)))
.drop(position.value)
.take(limitToUse.value)
.collectSeq())
+ .switchIfEmpty(SMono.just[Seq[MessageId]](Seq()))
.onErrorResume({
case _: MailboxNotFoundException => SMono.just[Seq[MessageId]](Seq())
case e => SMono.error[Seq[MessageId]](e)
})
}
- private def queryViewForListingSortedBySentAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest): SMono[Seq[MessageId]] = {
+ private def queryViewForListingSortedBySentAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest, namespace: Namespace): SMono[Seq[MessageId]] = {
val mailboxId: MailboxId = request.filter.get.asInstanceOf[FilterCondition].inMailbox.get
SMono(mailboxManager.getMailboxReactive(mailboxId, mailboxSession))
- .`then`(SFlux.fromPublisher(
+ .filter(messageManager => namespace.keepAccessible(messageManager.getMailboxEntity))
+ .flatMap(_ => SFlux.fromPublisher(
emailQueryView.listMailboxContent(mailboxId, JavaLimit.from(limitToUse.value + position.value)))
.drop(position.value)
.take(limitToUse.value)
.collectSeq())
+ .switchIfEmpty(SMono.just[Seq[MessageId]](Seq()))
.onErrorResume({
case _: MailboxNotFoundException => SMono.just[Seq[MessageId]](Seq())
case e => SMono.error[Seq[MessageId]](e)
})
}
- private def queryViewForListingSortedByReceivedAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest): SMono[Seq[MessageId]] = {
+ private def queryViewForListingSortedByReceivedAt(mailboxSession: MailboxSession, position: Position, limitToUse: Limit, request: EmailQueryRequest, namespace: Namespace): SMono[Seq[MessageId]] = {
val mailboxId: MailboxId = request.filter.get.asInstanceOf[FilterCondition].inMailbox.get
SMono(mailboxManager.getMailboxReactive(mailboxId, mailboxSession))
- .`then`(SFlux.fromPublisher(
+ .filter(messageManager => namespace.keepAccessible(messageManager.getMailboxEntity))
+ .flatMap(_ => SFlux.fromPublisher(
emailQueryView.listMailboxContentSortedByReceivedAt(mailboxId, JavaLimit.from(limitToUse.value + position.value)))
.drop(position.value)
.take(limitToUse.value)
.collectSeq())
+ .switchIfEmpty(SMono.just[Seq[MessageId]](Seq()))
.onErrorResume({
case _: MailboxNotFoundException => SMono.just[Seq[MessageId]](Seq())
case e => SMono.error[Seq[MessageId]](e)
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org