You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2020/10/02 08:48:38 UTC

[james-project] 02/08: JAMES-3390 Implement FilterOperator AND

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 1e9368c502a6f8e9e8524667a40f638af0286bd7
Author: duc91 <vd...@linagora.com>
AuthorDate: Tue Sep 29 13:43:10 2020 +0700

    JAMES-3390 Implement FilterOperator AND
    
    No operator nesting yet
---
 .../contract/EmailQueryMethodContract.scala        | 114 +++++++++
 .../james/jmap/json/EmailQuerySerializer.scala     |  15 +-
 .../org/apache/james/jmap/mail/EmailQuery.scala    |  13 +-
 .../james/jmap/utils/search/MailboxFilter.scala    | 272 ++++++++++++---------
 4 files changed, 291 insertions(+), 123 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 2ee44ba..9ab093d 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
@@ -40,6 +40,7 @@ import org.apache.james.GuiceJamesServer
 import org.apache.james.jmap.http.UserCredential
 import org.apache.james.jmap.model.UTCDate
 import org.apache.james.jmap.rfc8621.contract.Fixture.{ACCEPT_RFC8621_VERSION_HEADER, ANDRE, ANDRE_PASSWORD, BOB, BOB_PASSWORD, DOMAIN, authScheme, baseRequestSpecBuilder}
+import org.apache.james.mailbox.FlagsBuilder
 import org.apache.james.mailbox.MessageManager.AppendCommand
 import org.apache.james.mailbox.model.MailboxACL.Right
 import org.apache.james.mailbox.model.MailboxPath.inbox
@@ -4984,6 +4985,60 @@ trait EmailQueryMethodContract {
   }
 
   @Test
+  def emailQueryShouldSupportAndOperator(server: GuiceJamesServer): Unit = {
+    val message: Message = buildTestMessage
+    server.getProbe(classOf[MailboxProbeImpl]).createMailbox(MailboxPath.inbox(BOB))
+    val messageId1 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new Flags("custom")).build(message))
+      .getMessageId
+
+    val messageId2 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new Flags("another_custom")).build(message))
+      .getMessageId
+
+    val messageId3 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new FlagsBuilder().add("custom", "another_custom").build()).build(message))
+      .getMessageId
+
+    val request =
+      s"""{
+         |  "using": [
+         |    "urn:ietf:params:jmap:core",
+         |    "urn:ietf:params:jmap:mail"],
+         |  "methodCalls": [[
+         |    "Email/query",
+         |    {
+         |      "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+         |      "filter" : {
+         |        "operator": "AND",
+         |        "conditions": [
+         |          { "hasKeyword": "custom" }, { "hasKeyword": "another_custom" }
+         |        ]
+         |      }
+         |    },
+         |    "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)
+        .inPath("$.methodResponses[0][1].ids")
+        .isEqualTo(s"""["${messageId3.serialize}"]""")
+    }
+  }
+
+  @Test
   def emailQueryFilterByTextShouldIgnoreAttachmentContent(server: GuiceJamesServer): Unit = {
     server.getProbe(classOf[MailboxProbeImpl]).createMailbox(inbox(BOB))
     server.getProbe(classOf[MailboxProbeImpl])
@@ -5027,6 +5082,65 @@ trait EmailQueryMethodContract {
     }
   }
 
+  @Test
+  def nestedOperatorsShouldBeSupported(server: GuiceJamesServer): Unit = {
+    val message: Message = buildTestMessage
+    server.getProbe(classOf[MailboxProbeImpl]).createMailbox(MailboxPath.inbox(BOB))
+    val messageId1 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new Flags("custom")).build(message))
+      .getMessageId
+
+    val messageId2 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new Flags("another_custom")).build(message))
+      .getMessageId
+
+    val messageId3 = server.getProbe(classOf[MailboxProbeImpl])
+      .appendMessage(BOB.asString, MailboxPath.inbox(BOB), AppendCommand.builder().withFlags(new FlagsBuilder().add("custom", "another_custom").build()).build(message))
+      .getMessageId
+
+    val request =
+      s"""{
+         |  "using": [
+         |    "urn:ietf:params:jmap:core",
+         |    "urn:ietf:params:jmap:mail"],
+         |  "methodCalls": [[
+         |    "Email/query",
+         |    {
+         |      "accountId": "29883977c13473ae7cb7678ef767cbfbaffc8a44a6e463d971d23a65c1dc4af6",
+         |      "filter" : {
+         |        "operator": "AND",
+         |        "conditions": [
+         |          {
+         |            "operator": "AND",
+         |            "conditions": [
+         |              { "hasKeyword": "custom" }, { "hasKeyword": "another_custom" }
+         |            ]
+         |          }
+         |        ]
+         |      }
+         |    },
+         |    "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)
+        .inPath("$.methodResponses[0][1].ids")
+        .isEqualTo(s"""["${messageId3.serialize}"]""")
+    }
+  }
+
   private def sendMessageToBobInbox(server: GuiceJamesServer, message: Message, requestDate: Date): MessageId = {
     server.getProbe(classOf[MailboxProbeImpl])
       .appendMessage(BOB.asString, MailboxPath.inbox(BOB),
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/json/EmailQuerySerializer.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/json/EmailQuerySerializer.scala
index f137959..de6f5f3 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/json/EmailQuerySerializer.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/json/EmailQuerySerializer.scala
@@ -20,7 +20,7 @@
 package org.apache.james.jmap.json
 
 import javax.inject.Inject
-import org.apache.james.jmap.mail.{AllInThreadHaveKeywordSortProperty, Anchor, AnchorOffset, Bcc, Body, Cc, CollapseThreads, Collation, Comparator, EmailQueryRequest, EmailQueryResponse, FilterCondition, From, FromSortProperty, HasAttachment, HasKeywordSortProperty, Header, HeaderContains, HeaderExist, IsAscending, ReceivedAtSortProperty, SentAtSortProperty, SizeSortProperty, SomeInThreadHaveKeywordSortProperty, SortProperty, Subject, SubjectSortProperty, Text, To, ToSortProperty}
+import org.apache.james.jmap.mail.{AllInThreadHaveKeywordSortProperty, Anchor, AnchorOffset, And, Bcc, Body, Cc, CollapseThreads, Collation, Comparator, EmailQueryRequest, EmailQueryResponse, FilterCondition, FilterOperator, FilterQuery, From, FromSortProperty, HasAttachment, HasKeywordSortProperty, Header, HeaderContains, HeaderExist, IsAscending, Operator, ReceivedAtSortProperty, SentAtSortProperty, SizeSortProperty, SomeInThreadHaveKeywordSortProperty, SortProperty, Subject, SubjectSo [...]
 import org.apache.james.jmap.model.{AccountId, CanCalculateChanges, Keyword, LimitUnparsed, PositionUnparsed, QueryState}
 import org.apache.james.mailbox.model.{MailboxId, MessageId}
 import play.api.libs.json._
@@ -73,6 +73,12 @@ class EmailQuerySerializer @Inject()(mailboxIdFactory: MailboxId.Factory) {
     case _ => Left(JsError("header filter needs to be an array of one or two strings"))
   }
   private implicit val bodyReads: Reads[Body] = Json.valueReads[Body]
+
+  private implicit val operatorReads: Reads[Operator] = {
+    case JsString("AND") => JsSuccess(And)
+    case _ => JsError(s"Expecting a JsString to represent a known operator")
+  }
+
   private implicit val filterConditionReads: Reads[FilterCondition] = Json.reads[FilterCondition]
   private implicit val limitUnparsedReads: Reads[LimitUnparsed] = Json.valueReads[LimitUnparsed]
   private implicit val CanCalculateChangesFormat: Format[CanCalculateChanges] = Json.valueFormat[CanCalculateChanges]
@@ -81,6 +87,13 @@ class EmailQuerySerializer @Inject()(mailboxIdFactory: MailboxId.Factory) {
   private implicit val positionUnparsedReads: Reads[PositionUnparsed] = Json.valueReads[PositionUnparsed]
   private implicit val messageIdWrites: Writes[MessageId] = id => JsString(id.serialize())
 
+  private implicit val filterOperatorReads: Reads[FilterOperator] = Json.reads[FilterOperator]
+
+  private implicit def filterQueryReads: Reads[FilterQuery] = {
+    case jsValue@JsObject(underlying) if underlying.contains("operator") => filterOperatorReads.reads(jsValue)
+    case jsValue => filterConditionReads.reads(jsValue)
+  }
+
   private implicit val sortPropertyReads: Reads[SortProperty] = {
     case JsString("receivedAt") => JsSuccess(ReceivedAtSortProperty)
     case JsString("allInThreadHaveKeyword") => JsSuccess(AllInThreadHaveKeywordSortProperty)
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/mail/EmailQuery.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/mail/EmailQuery.scala
index f7e4bab..7d678a8 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/mail/EmailQuery.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/mail/EmailQuery.scala
@@ -18,6 +18,7 @@
  ****************************************************************/
 
 package org.apache.james.jmap.mail
+
 import org.apache.james.jmap.mail.Email.Size
 import org.apache.james.jmap.mail.IsAscending.ASCENDING
 import org.apache.james.jmap.method.WithAccountId
@@ -32,6 +33,14 @@ case class UnsupportedSortException(unsupportedSort: String) extends Unsupported
 case class UnsupportedFilterException(unsupportedFilter: String) extends UnsupportedOperationException
 case class UnsupportedRequestParameterException(unsupportedParam: String) extends UnsupportedOperationException
 
+sealed trait FilterQuery
+
+sealed trait Operator
+case object And extends Operator
+
+case class FilterOperator(operator: Operator,
+                          conditions: Seq[FilterQuery]) extends FilterQuery
+
 case class Text(value: String) extends AnyVal
 case class From(value: String) extends AnyVal
 case class To(value: String) extends AnyVal
@@ -61,12 +70,12 @@ case class FilterCondition(inMailbox: Option[MailboxId],
                            bcc: Option[Bcc],
                            subject: Option[Subject],
                            header: Option[Header],
-                           body: Option[Body])
+                           body: Option[Body]) extends FilterQuery
 
 case class EmailQueryRequest(accountId: AccountId,
                              position: Option[PositionUnparsed],
                              limit: Option[LimitUnparsed],
-                             filter: Option[FilterCondition],
+                             filter: Option[FilterQuery],
                              comparator: Option[Set[Comparator]],
                              collapseThreads: Option[CollapseThreads],
                              anchor: Option[Anchor],
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/utils/search/MailboxFilter.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/utils/search/MailboxFilter.scala
index c0580ed..1dcc2f4 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/utils/search/MailboxFilter.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/utils/search/MailboxFilter.scala
@@ -21,13 +21,13 @@ package org.apache.james.jmap.utils.search
 import java.util.Date
 
 import cats.implicits._
-import org.apache.james.jmap.mail.{EmailQueryRequest, HeaderContains, HeaderExist, UnsupportedFilterException}
+import org.apache.james.jmap.mail.{And, EmailQueryRequest, FilterCondition, FilterOperator, FilterQuery, HeaderContains, HeaderExist, UnsupportedFilterException}
 import org.apache.james.jmap.model.CapabilityIdentifier
 import org.apache.james.jmap.model.CapabilityIdentifier.CapabilityIdentifier
 import org.apache.james.mailbox.MailboxSession
 import org.apache.james.mailbox.model.MultimailboxesSearchQuery.{AccessibleNamespace, Namespace, PersonalNamespace}
 import org.apache.james.mailbox.model.SearchQuery.DateResolution.Second
-import org.apache.james.mailbox.model.SearchQuery.{Criterion, AddressType, DateComparator, DateOperator, DateResolution, InternalDateCriterion}
+import org.apache.james.mailbox.model.SearchQuery.{AddressType, Criterion, DateComparator, DateOperator, DateResolution, InternalDateCriterion}
 import org.apache.james.mailbox.model.{MultimailboxesSearchQuery, SearchQuery}
 
 import scala.jdk.CollectionConverters._
@@ -37,16 +37,24 @@ sealed trait MailboxFilter {
 }
 
 case object InMailboxFilter extends MailboxFilter {
-  override def toQuery(builder: MultimailboxesSearchQuery.Builder, request: EmailQueryRequest): MultimailboxesSearchQuery.Builder = request.filter.flatMap(_.inMailbox) match {
-    case Some(mailboxId) => builder.inMailboxes(mailboxId)
-    case None => builder
-  }
+  override def toQuery(builder: MultimailboxesSearchQuery.Builder, request: EmailQueryRequest): MultimailboxesSearchQuery.Builder =
+    request.filter.flatMap {
+      case filterCondition: FilterCondition => Some(filterCondition)
+      case _ => None
+    }.flatMap(_.inMailbox) match {
+      case Some(mailboxId) => builder.inMailboxes(mailboxId)
+      case None => builder
+    }
 }
 
 case object NotInMailboxFilter extends MailboxFilter {
-  override def toQuery(builder: MultimailboxesSearchQuery.Builder, request: EmailQueryRequest): MultimailboxesSearchQuery.Builder = request.filter.flatMap(_.inMailboxOtherThan) match {
-    case Some(mailboxIds) => builder.notInMailboxes(mailboxIds.asJava)
-    case None => builder
+  override def toQuery(builder: MultimailboxesSearchQuery.Builder, request: EmailQueryRequest): MultimailboxesSearchQuery.Builder =
+    request.filter.flatMap {
+      case filterCondition: FilterCondition => Some(filterCondition)
+      case _ => None
+    }.flatMap(_.inMailboxOtherThan) match {
+      case Some(mailboxIds) => builder.notInMailboxes(mailboxIds.asJava)
+      case None => builder
   }
 }
 
@@ -66,185 +74,209 @@ object MailboxFilter {
   }
 
   sealed trait QueryFilter {
-    def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder]
+    def toQuery(filterQuery: FilterQuery): Either[UnsupportedFilterException, List[Criterion]]
+  }
+
+  sealed trait ConditionFilter extends QueryFilter {
+    def toQuery(filterQuery: FilterQuery): Either[UnsupportedFilterException, List[Criterion]] = filterQuery match {
+      case filterCondition: FilterCondition => toQuery(filterCondition)
+      case _ => Right(Nil)
+    }
+
+    def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]]
+  }
+
+  case object AndFilter extends QueryFilter {
+    override def toQuery(filterQuery: FilterQuery): Either[UnsupportedFilterException, List[Criterion]] = filterQuery match {
+      case filterOperator: FilterOperator if filterOperator.operator.equals(And) =>
+        filterOperator.conditions
+          .map(QueryFilter.toCriterion)
+          .toList
+          .sequence
+          .map(_.flatten)
+          .map(criteria => List(SearchQuery.and(criteria.asJava)))
+      case _ => Right(Nil)
+    }
   }
 
   object QueryFilter {
-    def buildQuery(request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] = {
+    def buildQuery(request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
+      request.filter.map(toCriterion)
+        .getOrElse(Right(Nil))
+        .map(criteria => new SearchQuery.Builder().andCriteria(criteria.asJava))
+
+    def toCriterion(filterQuery: FilterQuery): Either[UnsupportedFilterException, List[Criterion]] =
       List(ReceivedBefore, ReceivedAfter, HasAttachment, HasKeyWord, NotKeyWord, MinSize, MaxSize,
            AllInThreadHaveKeyword, NoneInThreadHaveKeyword, SomeInThreadHaveKeyword, Text, From,
-           To, Cc, Bcc, Subject, Header, Body)
-        .foldLeftM(new SearchQuery.Builder())((builder, filter) => filter.toQuery(builder, request))
-    }
+           To, Cc, Bcc, Subject, Header, Body, AndFilter)
+        .map(filter => filter.toQuery(filterQuery))
+        .sequence
+        .map(list => list.flatten)
   }
 
-  case object ReceivedBefore extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.before) match {
+  case object ReceivedBefore extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.before match {
         case Some(before) =>
           val strictlyBefore = SearchQuery.internalDateBefore(Date.from(before.asUTC.toInstant), Second)
           val sameDate = SearchQuery.internalDateOn(Date.from(before.asUTC.toInstant), Second)
-          Right(builder
-            .andCriteria(SearchQuery.or(strictlyBefore, sameDate)))
-        case None => Right(builder)
+          Right(List(SearchQuery.or(strictlyBefore, sameDate)))
+        case None => Right(List())
       }
   }
 
-  case object ReceivedAfter extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.after) match {
+  case object ReceivedAfter extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.after match {
         case Some(after) =>
           val strictlyAfter = new InternalDateCriterion(new DateOperator(DateComparator.AFTER, Date.from(after.asUTC.toInstant), DateResolution.Second))
-          Right(builder
-            .andCriteria(strictlyAfter))
-        case None => Right(builder)
+          Right(List(strictlyAfter))
+        case None => Right(List())
       }
   }
 
-  case object HasAttachment extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.hasAttachment) match {
-        case Some(hasAttachment) => Right(builder
-          .andCriteria(SearchQuery.hasAttachment(hasAttachment.value)))
-        case None => Right(builder)
+  case object HasAttachment extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.hasAttachment match {
+        case Some(hasAttachment) => Right(List(SearchQuery.hasAttachment(hasAttachment.value)))
+        case None => Right(List())
       }
   }
 
-  case object MinSize extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.minSize) match {
+  case object MinSize extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.minSize match {
         case Some(minSize) =>
-          Right(builder
-            .andCriteria(SearchQuery.or(
+          Right(List(SearchQuery.or(
               SearchQuery.sizeGreaterThan(minSize.value),
               SearchQuery.sizeEquals(minSize.value))))
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
 
-  case object MaxSize extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.maxSize) match {
+  case object MaxSize extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.maxSize match {
         case Some(maxSize) =>
-          Right(builder
-            .andCriteria(SearchQuery.sizeLessThan(maxSize.value)))
-        case None => Right(builder)
+          Right(List(SearchQuery.sizeLessThan(maxSize.value)))
+        case None => Right(List())
       }
   }
 
-  case object HasKeyWord extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.hasKeyword) match {
+  case object HasKeyWord extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.hasKeyword match {
         case Some(keyword) =>
           keyword.asSystemFlag match {
-            case Some(systemFlag) => Right(builder.andCriteria(SearchQuery.flagIsSet(systemFlag)))
-            case None => Right(builder.andCriteria(SearchQuery.flagIsSet(keyword.flagName)))
+            case Some(systemFlag) => Right(List(SearchQuery.flagIsSet(systemFlag)))
+            case None => Right(List(SearchQuery.flagIsSet(keyword.flagName)))
           }
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
-  case object NotKeyWord extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.notKeyword) match {
+  case object NotKeyWord extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.notKeyword match {
         case Some(keyword) =>
           keyword.asSystemFlag match {
-            case Some(systemFlag) => Right(builder.andCriteria(SearchQuery.flagIsUnSet(systemFlag)))
-            case None => Right(builder.andCriteria(SearchQuery.flagIsUnSet(keyword.flagName)))
+            case Some(systemFlag) => Right(List(SearchQuery.flagIsUnSet(systemFlag)))
+            case None => Right(List(SearchQuery.flagIsUnSet(keyword.flagName)))
           }
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
-  case object AllInThreadHaveKeyword extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.allInThreadHaveKeyword) match {
+  case object AllInThreadHaveKeyword extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.allInThreadHaveKeyword match {
         case Some(_) => Left(UnsupportedFilterException("allInThreadHaveKeyword"))
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
-  case object NoneInThreadHaveKeyword extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.noneInThreadHaveKeyword) match {
+  case object NoneInThreadHaveKeyword extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.noneInThreadHaveKeyword match {
         case Some(_) => Left(UnsupportedFilterException("noneInThreadHaveKeyword"))
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
-  case object SomeInThreadHaveKeyword extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.someInThreadHaveKeyword) match {
+  case object SomeInThreadHaveKeyword extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.someInThreadHaveKeyword match {
         case Some(_) => Left(UnsupportedFilterException("someInThreadHaveKeyword"))
-        case None => Right(builder)
+        case None => Right(List())
       }
   }
-  case object Text extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.text) match {
-        case Some(text) =>
-          val textFilterOrCondition: List[SearchQuery.Criterion] = List(SearchQuery.headerContains("From", text.value),
-            SearchQuery.headerContains("To", text.value),
-            SearchQuery.headerContains("Cc", text.value),
-            SearchQuery.headerContains("Bcc", text.value),
-            SearchQuery.headerContains("Subject", text.value),
-            SearchQuery.bodyContains(text.value))
 
-          Right(builder.andCriteria(SearchQuery.or(textFilterOrCondition.asJava))
-            .andCriteria(SearchQuery.not(SearchQuery.attachmentContains(text.value))))
-        case None => Right(builder)
+  case object Text extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.text match {
+        case Some(text) =>
+          Right(List(SearchQuery.or(
+            List(SearchQuery.headerContains("From", text.value),
+              SearchQuery.headerContains("To", text.value),
+              SearchQuery.headerContains("Cc", text.value),
+              SearchQuery.headerContains("Bcc", text.value),
+              SearchQuery.headerContains("Subject", text.value),
+              SearchQuery.bodyContains(text.value))
+            .asJava)))
+        case None => Right(Nil)
       }
   }
-  case object From extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.from) match {
-        case Some(from) => Right(builder.andCriteria(SearchQuery.address(AddressType.From, from.value)))
-        case None => Right(builder)
+
+  case object From extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.from match {
+        case Some(from) => Right(List(SearchQuery.address(AddressType.From, from.value)))
+        case None => Right(List())
       }
   }
-  case object To extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.to) match {
-        case Some(to) => Right(builder.andCriteria(SearchQuery.address(AddressType.To, to.value)))
-        case None => Right(builder)
+  case object To extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.to match {
+        case Some(to) => Right(List(SearchQuery.address(AddressType.To, to.value)))
+        case None => Right(List())
       }
   }
-  case object Cc extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.cc) match {
-        case Some(cc) => Right(builder.andCriteria(SearchQuery.address(AddressType.Cc, cc.value)))
-        case None => Right(builder)
+  case object Cc extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.cc match {
+        case Some(cc) => Right(List(SearchQuery.address(AddressType.Cc, cc.value)))
+        case None => Right(List())
       }
   }
-  case object Bcc extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.bcc) match {
-        case Some(bcc) => Right(builder.andCriteria(SearchQuery.address(AddressType.Bcc, bcc.value)))
-        case None => Right(builder)
+  case object Bcc extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.bcc match {
+        case Some(bcc) => Right(List(SearchQuery.address(AddressType.Bcc, bcc.value)))
+        case None => Right(List())
       }
   }
-  case object Subject extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.subject) match {
-        case Some(subject) => Right(builder.andCriteria(SearchQuery.headerContains("Subject", subject.value)))
-        case None => Right(builder)
+  case object Subject extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.subject match {
+        case Some(subject) => Right(List(SearchQuery.headerContains("Subject", subject.value)))
+        case None => Right(List())
       }
   }
-  case object Header extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.header) match {
-        case Some(HeaderExist(name)) => Right(builder.andCriteria(SearchQuery.headerExists(name)))
-        case Some(HeaderContains(name, value)) => Right(builder.andCriteria(SearchQuery.headerContains(name, value)))
-        case None => Right(builder)
+  case object Header extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.header match {
+        case Some(HeaderExist(name)) => Right(List(SearchQuery.headerExists(name)))
+        case Some(HeaderContains(name, value)) => Right(List(SearchQuery.headerContains(name, value)))
+        case None => Right(List())
       }
   }
-  case object Body extends QueryFilter {
-    override def toQuery(builder: SearchQuery.Builder, request: EmailQueryRequest): Either[UnsupportedFilterException, SearchQuery.Builder] =
-      request.filter.flatMap(_.body) match {
-        case Some(text) =>
-           val bodyFilterOr: List[Criterion] = List(
+
+  case object Body extends ConditionFilter {
+    override def toQuery(filterCondition: FilterCondition): Either[UnsupportedFilterException, List[Criterion]] =
+      filterCondition.body match {
+        case Some(text) => Right(List(SearchQuery.or(
+          List(
             SearchQuery.attachmentContains(text.value),
             SearchQuery.bodyContains(text.value),
             SearchQuery.attachmentFileName(text.value))
-
-          Right(builder.andCriteria(SearchQuery.or(bodyFilterOr.asJava)))
-        case None => Right(builder)
+          .asJava)))
+        case None => Right(Nil)
       }
   }
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org