JAMES-2257 add builder for oldKeywords

Project: http://git-wip-us.apache.org/repos/asf/james-project/repo
Commit: http://git-wip-us.apache.org/repos/asf/james-project/commit/0e6082eb
Tree: http://git-wip-us.apache.org/repos/asf/james-project/tree/0e6082eb
Diff: http://git-wip-us.apache.org/repos/asf/james-project/diff/0e6082eb

Branch: refs/heads/master
Commit: 0e6082eb3f5a7f5cf7b2fc0f45b9e91ba63ce564
Parents: e9ef473
Author: Luc DUZAN <ldu...@linagora.com>
Authored: Mon Dec 11 18:18:53 2017 +0100
Committer: benwa <btell...@linagora.com>
Committed: Fri Dec 15 14:00:36 2017 +0700

----------------------------------------------------------------------
 .../james/jmap/model/CreationMessage.java       | 21 +++---
 .../org/apache/james/jmap/model/OldKeyword.java | 77 ++++++++++++++++++--
 .../james/jmap/model/UpdateMessagePatch.java    | 21 ++----
 .../apache/james/jmap/model/OldKeywordTest.java | 68 +++++++++--------
 4 files changed, 126 insertions(+), 61 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/james-project/blob/0e6082eb/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/CreationMessage.java
----------------------------------------------------------------------
diff --git 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/CreationMessage.java
 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/CreationMessage.java
index 625f42d..39840e5 100644
--- 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/CreationMessage.java
+++ 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/CreationMessage.java
@@ -59,11 +59,7 @@ public class CreationMessage {
     public static class Builder {
         private ImmutableList<String> mailboxIds;
         private String inReplyToMessageId;
-        private Optional<Boolean> isUnread = Optional.empty();
-        private Optional<Boolean> isFlagged = Optional.empty();
-        private Optional<Boolean> isAnswered = Optional.empty();
-        private Optional<Boolean> isDraft = Optional.empty();
-        private Optional<Boolean> isForwarded = Optional.empty();
+        private final OldKeyword.Builder oldKeywordBuilder;
         private final ImmutableMap.Builder<String, String> headers;
         private Optional<DraftEmailer> from = Optional.empty();
         private final ImmutableList.Builder<DraftEmailer> to;
@@ -86,6 +82,7 @@ public class CreationMessage {
             attachments = ImmutableList.builder();
             attachedMessages = ImmutableMap.builder();
             headers = ImmutableMap.builder();
+            oldKeywordBuilder = OldKeyword.builder();
         }
 
         public Builder mailboxId(String... mailboxIds) {
@@ -104,27 +101,27 @@ public class CreationMessage {
         }
 
         public Builder isUnread(Optional<Boolean> isUnread) {
-            this.isUnread = isUnread;
+            oldKeywordBuilder.isUnread(isUnread);
             return this;
         }
 
         public Builder isFlagged(Optional<Boolean> isFlagged) {
-            this.isFlagged = isFlagged;
+            oldKeywordBuilder.isFlagged(isFlagged);
             return this;
         }
 
         public Builder isAnswered(Optional<Boolean> isAnswered) {
-            this.isAnswered = isAnswered;
+            oldKeywordBuilder.isAnswered(isAnswered);
             return this;
         }
 
         public Builder isDraft(Optional<Boolean> isDraft) {
-            this.isDraft = isDraft;
+            oldKeywordBuilder.isDraft(isDraft);
             return this;
         }
 
         public Builder isForwarded(Optional<Boolean> isForwarded) {
-            this.isForwarded = isForwarded;
+            oldKeywordBuilder.isForwarded(isForwarded);
             return this;
         }
 
@@ -221,8 +218,8 @@ public class CreationMessage {
             }
 
             Optional<Keywords> maybeKeywords = creationKeywords();
-            Optional<OldKeyword> oldKeywords = OldKeyword.computeOldKeywords(
-                isUnread, isFlagged, isAnswered, isDraft, isForwarded);
+            Optional<OldKeyword> oldKeywords = 
oldKeywordBuilder.computeOldKeyword();
+
             Preconditions.checkArgument(!(maybeKeywords.isPresent() && 
oldKeywords.isPresent()), "Does not support keyword and is* at the same time");
             return new CreationMessage(mailboxIds, 
Optional.ofNullable(inReplyToMessageId), headers.build(), from,
                     to.build(), cc.build(), bcc.build(), replyTo.build(), 
subject, date, Optional.ofNullable(textBody), Optional.ofNullable(htmlBody),

http://git-wip-us.apache.org/repos/asf/james-project/blob/0e6082eb/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/OldKeyword.java
----------------------------------------------------------------------
diff --git 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/OldKeyword.java
 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/OldKeyword.java
index b240b54..a3aed3a 100644
--- 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/OldKeyword.java
+++ 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/OldKeyword.java
@@ -28,12 +28,79 @@ import com.google.common.base.MoreObjects;
 import com.google.common.base.Objects;
 
 public class OldKeyword {
-    public static Optional<OldKeyword> computeOldKeywords(Optional<Boolean> 
isUnread, Optional<Boolean> isFlagged, Optional<Boolean> isAnswered,
-                                                          Optional<Boolean> 
isDraft, Optional<Boolean> isForwarded) {
-        if (isAnswered.isPresent() || isFlagged.isPresent() || 
isUnread.isPresent() || isForwarded.isPresent() || isDraft.isPresent()) {
-            return Optional.of(new OldKeyword(isUnread, isFlagged, isAnswered, 
isDraft, isForwarded));
+
+    public static class Builder {
+        private Optional<Boolean> isUnread;
+        private Optional<Boolean> isFlagged;
+        private Optional<Boolean> isAnswered;
+        private Optional<Boolean> isDraft;
+        private Optional<Boolean> isForwarded;
+
+        private Builder() {
+            isUnread = Optional.empty();
+            isFlagged = Optional.empty();
+            isAnswered = Optional.empty();
+            isDraft = Optional.empty();
+            isForwarded = Optional.empty();
+        }
+
+        public Builder isFlagged(Optional<Boolean> isFlagged) {
+            this.isFlagged = isFlagged;
+            return this;
+        }
+
+        public Builder isFlagged(boolean isFlagged) {
+            return isFlagged(Optional.of(isFlagged));
+        }
+
+        public Builder isUnread(Optional<Boolean> isUnread) {
+            this.isUnread = isUnread;
+            return this;
         }
-        return Optional.empty();
+
+        public Builder isUnread(boolean isUnread) {
+            return isUnread(Optional.of(isUnread));
+        }
+
+        public Builder isAnswered(Optional<Boolean> isAnswered) {
+            this.isAnswered = isAnswered;
+            return this;
+        }
+
+        public Builder isAnswered(boolean isAnswered) {
+            return isAnswered(Optional.of(isAnswered));
+        }
+
+        public Builder isDraft(Optional<Boolean> isDraft) {
+            this.isDraft = isDraft;
+            return this;
+        }
+
+        public Builder isDraft(boolean isDraft) {
+            return isDraft(Optional.of(isDraft));
+        }
+
+        public Builder isForwarded(Optional<Boolean> isForwarded) {
+            this.isForwarded = isForwarded;
+            return this;
+        }
+
+        public Builder isForwarded(boolean isForwarded) {
+            return isForwarded(Optional.of(isForwarded));
+        }
+
+        public Optional<OldKeyword> computeOldKeyword() {
+            if (isAnswered.isPresent() || isFlagged.isPresent() || 
isUnread.isPresent() || isForwarded.isPresent() || isDraft.isPresent()) {
+                return Optional.of(new OldKeyword(isUnread, isFlagged, 
isAnswered, isDraft, isForwarded));
+            }
+
+            return Optional.empty();
+        }
+
+    }
+
+    public static Builder builder() {
+        return new Builder();
     }
 
     private final Optional<Boolean> isUnread;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0e6082eb/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/UpdateMessagePatch.java
----------------------------------------------------------------------
diff --git 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/UpdateMessagePatch.java
 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/UpdateMessagePatch.java
index 19671a9..830181b 100644
--- 
a/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/UpdateMessagePatch.java
+++ 
b/server/protocols/jmap/src/main/java/org/apache/james/jmap/model/UpdateMessagePatch.java
@@ -47,11 +47,7 @@ public class UpdateMessagePatch {
     @JsonPOJOBuilder(withPrefix = "")
     public static class Builder {
         private Optional<List<String>> mailboxIds = Optional.empty();
-        private Optional<Boolean> isFlagged = Optional.empty();
-        private Optional<Boolean> isUnread = Optional.empty();
-        private Optional<Boolean> isAnswered = Optional.empty();
-        private Optional<Boolean> isForwarded = Optional.empty();
-        private Optional<Boolean> isDraft = Optional.empty();
+        private OldKeyword.Builder oldKeyworkBuilder = OldKeyword.builder();
         private Optional<Map<String, Boolean>> keywords = Optional.empty();
         private Set<ValidationResult> validationResult = Sets.newHashSet();
 
@@ -66,27 +62,27 @@ public class UpdateMessagePatch {
         }
 
         public Builder isFlagged(Boolean isFlagged) {
-            this.isFlagged = Optional.of(isFlagged);
+            oldKeyworkBuilder.isFlagged(isFlagged);
             return this;
         }
 
         public Builder isUnread(Boolean isUnread) {
-            this.isUnread = Optional.of(isUnread);
+            oldKeyworkBuilder.isUnread(isUnread);
             return this;
         }
 
         public Builder isAnswered(Boolean isAnswered) {
-            this.isAnswered = Optional.of(isAnswered);
+            oldKeyworkBuilder.isAnswered(isAnswered);
             return this;
         }
 
-        public Builder isDraft(Boolean isAnswered) {
-            this.isDraft = Optional.of(isAnswered);
+        public Builder isDraft(Boolean isDraft) {
+            oldKeyworkBuilder.isDraft(isDraft);
             return this;
         }
 
         public Builder isForwarded(Boolean isForwarded) {
-            this.isForwarded = Optional.of(isForwarded);
+            oldKeyworkBuilder.isForwarded(isForwarded);
             return this;
         }
 
@@ -104,8 +100,7 @@ public class UpdateMessagePatch {
             }
 
             Optional<Keywords> mayBeKeywords = creationKeywords();
-            Optional<OldKeyword> oldKeywords = OldKeyword.computeOldKeywords(
-                isUnread, isFlagged, isAnswered, isDraft, isForwarded);
+            Optional<OldKeyword> oldKeywords = 
oldKeyworkBuilder.computeOldKeyword();
             Preconditions.checkArgument(!(mayBeKeywords.isPresent() && 
oldKeywords.isPresent()), "Does not support keyword and is* at the same time");
 
             return new UpdateMessagePatch(mailboxIds, mayBeKeywords, 
oldKeywords, ImmutableList.copyOf(validationResult));

http://git-wip-us.apache.org/repos/asf/james-project/blob/0e6082eb/server/protocols/jmap/src/test/java/org/apache/james/jmap/model/OldKeywordTest.java
----------------------------------------------------------------------
diff --git 
a/server/protocols/jmap/src/test/java/org/apache/james/jmap/model/OldKeywordTest.java
 
b/server/protocols/jmap/src/test/java/org/apache/james/jmap/model/OldKeywordTest.java
index 3d28be6..e703098 100644
--- 
a/server/protocols/jmap/src/test/java/org/apache/james/jmap/model/OldKeywordTest.java
+++ 
b/server/protocols/jmap/src/test/java/org/apache/james/jmap/model/OldKeywordTest.java
@@ -38,60 +38,66 @@ public class OldKeywordTest {
 
     @Test
     public void computeOldKeywordsShouldReturnEmptyWhenAllEmpty() {
-        Optional<Boolean> isUnread = Optional.empty();
-        Optional<Boolean> isFlagged = Optional.empty();
-        Optional<Boolean> isAnswered = Optional.empty();
-        Optional<Boolean> isDraft = Optional.empty();
-        Optional<Boolean> isForwarded = Optional.empty();
-        Optional<OldKeyword> testee = OldKeyword.computeOldKeywords(isUnread, 
isFlagged, isAnswered, isDraft, isForwarded);
+        Optional<OldKeyword> testee = OldKeyword.builder()
+            .isUnread(Optional.empty())
+            .isFlagged(Optional.empty())
+            .isAnswered(Optional.empty())
+            .isDraft(Optional.empty())
+            .isForwarded(Optional.empty())
+            .computeOldKeyword();
 
         assertThat(testee).isEmpty();
     }
 
     @Test
     public void applyStateShouldSetFlaggedOnlyWhenIsFlagged() {
-        Optional<Boolean> isUnread = Optional.empty();
-        Optional<Boolean> isFlagged = Optional.of(true);
-        Optional<Boolean> isAnswered = Optional.empty();
-        Optional<Boolean> isDraft = Optional.empty();
-        Optional<Boolean> isForwarded = Optional.empty();
-        Optional<OldKeyword> testee = OldKeyword.computeOldKeywords(isUnread, 
isFlagged, isAnswered, isDraft, isForwarded);
+        Optional<OldKeyword> testee = OldKeyword.builder()
+            .isUnread(Optional.empty())
+            .isFlagged(Optional.of(true))
+            .isAnswered(Optional.empty())
+            .isDraft(Optional.empty())
+            .isForwarded(Optional.empty())
+            .computeOldKeyword();
 
         assertThat(testee.get().applyToState(new Flags())).isEqualTo(new 
Flags(Flag.FLAGGED));
     }
 
     @Test
     public void 
applyStateShouldRemoveFlaggedWhenEmptyIsFlaggedOnFlaggedMessage() {
-        Optional<Boolean> isUnread = Optional.empty();
-        Optional<Boolean> isFlagged = Optional.of(false);
-        Optional<Boolean> isAnswered = Optional.empty();
-        Optional<Boolean> isDraft = Optional.empty();
-        Optional<Boolean> isForwarded = Optional.empty();
-        Optional<OldKeyword> testee = OldKeyword.computeOldKeywords(isUnread, 
isFlagged, isAnswered, isDraft, isForwarded);
-        
+        Optional<OldKeyword> testee = OldKeyword.builder()
+            .isUnread(Optional.empty())
+            .isFlagged(Optional.of(false))
+            .isAnswered(Optional.empty())
+            .isDraft(Optional.empty())
+            .isForwarded(Optional.empty())
+            .computeOldKeyword();
+
         assertThat(testee.get().applyToState(new 
Flags(Flag.FLAGGED))).isEqualTo(new Flags());
     }
 
+
     @Test
     public void applyStateShouldReturnUnreadFlagWhenUnreadSetOnSeenMessage() {
-        Optional<Boolean> isUnread = Optional.of(true);
-        Optional<Boolean> isFlagged = Optional.empty();
-        Optional<Boolean> isAnswered = Optional.empty();
-        Optional<Boolean> isDraft = Optional.empty();
-        Optional<Boolean> isForwarded = Optional.empty();
-        Optional<OldKeyword> testee = OldKeyword.computeOldKeywords(isUnread, 
isFlagged, isAnswered, isDraft, isForwarded);
+        Optional<OldKeyword> testee = OldKeyword.builder()
+            .isUnread(Optional.of(true))
+            .isFlagged(Optional.empty())
+            .isAnswered(Optional.empty())
+            .isDraft(Optional.empty())
+            .isForwarded(Optional.empty())
+            .computeOldKeyword();
 
         assertThat(testee.get().applyToState(new 
Flags(Flag.SEEN))).isEqualTo(new Flags());
     }
 
     @Test
     public void applyStateShouldReturnSeenWhenPatchSetsSeenOnSeenMessage() {
-        Optional<Boolean> isUnread = Optional.of(false);
-        Optional<Boolean> isFlagged = Optional.empty();
-        Optional<Boolean> isAnswered = Optional.empty();
-        Optional<Boolean> isDraft = Optional.empty();
-        Optional<Boolean> isForwarded = Optional.empty();
-        Optional<OldKeyword> testee = OldKeyword.computeOldKeywords(isUnread, 
isFlagged, isAnswered, isDraft, isForwarded);
+        Optional<OldKeyword> testee = OldKeyword.builder()
+            .isUnread(Optional.of(false))
+            .isFlagged(Optional.empty())
+            .isAnswered(Optional.empty())
+            .isDraft(Optional.empty())
+            .isForwarded(Optional.empty())
+            .computeOldKeyword();
 
         assertThat(testee.get().applyToState(new 
Flags(Flag.SEEN))).isEqualTo(new Flags(Flag.SEEN));
     }


---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org
For additional commands, e-mail: server-dev-h...@james.apache.org

Reply via email to