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