JAMES-2182 Sharing for IMAP

mailbox/api/src/main/java/org/apache/james/mailbox/MailboxSession.java

@@ -19,8 +19,6 @@
 
 package org.apache.james.mailbox;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
@@ -29,7 +27,6 @@
 import java.util.Optional;
 
 import org.apache.james.core.Username;
-import org.apache.james.mailbox.model.MailboxConstants;
 
 import com.google.common.base.MoreObjects;
 
@@ -100,9 +97,6 @@ public enum SessionType {
         User
     }
 
-    private final Collection<String> sharedSpaces;
-    private final String otherUsersSpace;
-    private final String personalSpace;
     private final SessionId sessionId;
     private final Username userName;
     private final Optional<Username> loggedInUser;
@@ -113,21 +107,9 @@ public enum SessionType {
 
     public MailboxSession(SessionId sessionId, Username userName, Optional<Username> loggedInUser,
                                 List<Locale> localePreferences, char pathSeparator, SessionType type) {
-        this(sessionId, userName, loggedInUser, localePreferences, new ArrayList<>(), null, pathSeparator, type);
-    }
-
-    public MailboxSession(SessionId sessionId, Username userName, Optional<Username> loggedInUser,
-                          List<Locale> localePreferences, List<String> sharedSpaces, String otherUsersSpace, char pathSeparator, SessionType type) {
         this.sessionId = sessionId;
         this.userName = userName;
-        this.otherUsersSpace = otherUsersSpace;
-        this.sharedSpaces = sharedSpaces;
         this.type = type;
-        if (otherUsersSpace == null && (sharedSpaces == null || sharedSpaces.isEmpty())) {
-            this.personalSpace = "";
-        } else {
-            this.personalSpace = MailboxConstants.USER_NAMESPACE;
-        }
 
         this.localePreferences = localePreferences;
         this.attributes = new HashMap<>();
@@ -173,43 +155,6 @@ public List<Locale> getLocalePreferences() {
         return localePreferences;
     }
 
-    /**
-     * Gets the <a href='http://www.isi.edu/in-notes/rfc2342.txt' rel='tag'>RFC
-     * 2342</a> personal namespace for the current session.<br>
-     * Note that though servers may offer multiple personal namespaces, support
-     * is not offered through this API. This decision may be revised if
-     * reasonable use cases emerge.
-     * 
-     * @return Personal Namespace, not null
-     */
-    public String getPersonalSpace() {
-        return personalSpace;
-    }
-
-    /**
-     * Gets the <a href='http://www.isi.edu/in-notes/rfc2342.txt' rel='tag'>RFC
-     * 2342</a> other users namespace for the current session.<br>
-     * Note that though servers may offer multiple other users namespaces,
-     * support is not offered through this API. This decision may be revised if
-     * reasonable use cases emerge.
-     * 
-     * @return Other Users Namespace or null when there is non available
-     */
-    public String getOtherUsersSpace() {
-        return otherUsersSpace;
-    }
-
-    /**
-     * Iterates the <a href='http://www.isi.edu/in-notes/rfc2342.txt'
-     * rel='tag'>RFC 2342</a> Shared Namespaces available for the current
-     * session.
-     * 
-     * @return not null though possibly empty
-     */
-    public Collection<String> getSharedSpaces() {
-        return sharedSpaces;
-    }
-
     /**
      * Return the stored attributes for this {@link MailboxSession}.
      */

mailbox/api/src/main/java/org/apache/james/mailbox/model/MailboxPath.java

@@ -154,7 +154,9 @@ public String getName() {
     }
 
     public boolean belongsTo(MailboxSession mailboxSession) {
-        return user.equals(mailboxSession.getUser());
+        return Optional.ofNullable(user)
+            .map(mailboxSession.getUser()::equals)
+            .orElse(false);
     }
 
     public MailboxPath child(String childName, char delimiter) {
@@ -255,7 +257,7 @@ boolean hasEmptyNameInHierarchy(char pathDelimiter) {
     }
 
     public String asString() {
-        return namespace + ":" + user.asString() + ":" + name;
+        return namespace + ":" + Optional.ofNullable(user).map(Username::asString).orElse("") + ":" + name;
     }
 
     public String asEscapedString() {

mailbox/api/src/main/java/org/apache/james/mailbox/model/search/PrefixedRegex.java

@@ -41,8 +41,18 @@ public PrefixedRegex(String prefix, String regex, char pathDelimiter) {
 
     @Override
     public boolean isExpressionMatch(String name) {
-        return name.startsWith(prefix)
-            && regexMatching(name.substring(prefix.length()));
+        if (name.startsWith(prefix)) {
+            String nameSubstring = sanitizeSubstring(name.substring(prefix.length()));
+            return regexMatching(nameSubstring);
+        }
+        return false;
+    }
+
+    private String sanitizeSubstring(String name) {
+        if (!name.isEmpty() && name.charAt(0) == pathDelimiter) {
+            return name.substring(1);
+        }
+        return name;
     }
 
     private boolean regexMatching(String name) {
@@ -133,4 +143,12 @@ public final boolean equals(Object o) {
     public final int hashCode() {
         return Objects.hash(prefix, regex, pathDelimiter);
     }
+
+    @Override
+    public String toString() {
+        return "PrefixedRegex{" +
+            "prefix='" + prefix + '\'' +
+            ", regex='" + regex + '\'' +
+            '}';
+    }
 }

mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java

@@ -271,6 +271,96 @@ void hasInboxShouldBeTrueWhenINBOXIsCreated() throws Exception {
             assertThat(mailboxId.get()).isEqualTo(retrievedMailbox.getId());
         }
 
+        @Test
+        void shareeShouldBeAbleToCreateMailbox() throws Exception {
+            assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.ACL));
+            session = mailboxManager.createSystemSession(USER_1);
+            MailboxPath mailboxPath = MailboxPath.inbox(session);
+            mailboxManager.createMailbox(mailboxPath, session);
+            mailboxManager.applyRightsCommand(mailboxPath,
+                MailboxACL.command()
+                    .key(MailboxACL.EntryKey.createUserEntryKey(USER_2))
+                    .rights(MailboxACL.Rfc4314Rights.of(ImmutableList.of(MailboxACL.Right.Lookup,
+                        MailboxACL.Right.Read, MailboxACL.Right.CreateMailbox)))
+                    .asAddition(), session);
+
+            MailboxSession session2 = mailboxManager.createSystemSession(USER_2);
+            MailboxPath childPath = MailboxPath.inbox(session).child("child", session2.getPathDelimiter());
+            mailboxManager.createMailbox(childPath, session2);
+
+            assertThat(mailboxManager.getMailbox(childPath, session)
+                .getMailboxEntity().getACL().getEntries().get(MailboxACL.EntryKey.createUserEntryKey(USER_2)))
+                .isEqualTo(MailboxACL.Rfc4314Rights.fromSerializedRfc4314Rights("lrk"));
+        }
+
+        @Test
+        void shareeShouldBeAbleToCreateMailboxChildren() throws Exception {
+            assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.ACL));
+            session = mailboxManager.createSystemSession(USER_1);
+            MailboxPath mailboxPath = MailboxPath.inbox(session);
+            mailboxManager.createMailbox(mailboxPath, session);
+            mailboxManager.applyRightsCommand(mailboxPath,
+                MailboxACL.command()
+                    .key(MailboxACL.EntryKey.createUserEntryKey(USER_2))
+                    .rights(MailboxACL.Rfc4314Rights.of(ImmutableList.of(MailboxACL.Right.Lookup,
+                        MailboxACL.Right.Read, MailboxACL.Right.CreateMailbox)))
+                    .asAddition(), session);
+
+            MailboxSession session2 = mailboxManager.createSystemSession(USER_2);
+            MailboxPath childPath = MailboxPath.inbox(session)
+                .child("child", session2.getPathDelimiter())
+                .child("anotherkid", session2.getPathDelimiter());
+            mailboxManager.createMailbox(childPath, session2);
+
+            assertThat(mailboxManager.getMailbox(childPath, session)
+                .getMailboxEntity().getACL().getEntries().get(MailboxACL.EntryKey.createUserEntryKey(USER_2)))
+                .isEqualTo(MailboxACL.Rfc4314Rights.fromSerializedRfc4314Rights("lrk"));
+        }
+
+        @Test
+        void shareeShouldBeAbleToCreateMailboxChildrenIntermediatePaths() throws Exception {
+            assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.ACL));
+            session = mailboxManager.createSystemSession(USER_1);
+            MailboxPath mailboxPath = MailboxPath.inbox(session);
+            mailboxManager.createMailbox(mailboxPath, session);
+            mailboxManager.applyRightsCommand(mailboxPath,
+                MailboxACL.command()
+                    .key(MailboxACL.EntryKey.createUserEntryKey(USER_2))
+                    .rights(MailboxACL.Rfc4314Rights.of(ImmutableList.of(MailboxACL.Right.Lookup,
+                        MailboxACL.Right.Read, MailboxACL.Right.CreateMailbox)))
+                    .asAddition(), session);
+
+            MailboxSession session2 = mailboxManager.createSystemSession(USER_2);
+            MailboxPath intermediatePath = MailboxPath.inbox(session)
+                .child("child", session2.getPathDelimiter());
+            MailboxPath childPath = intermediatePath.child("anotherkid", session2.getPathDelimiter());
+            mailboxManager.createMailbox(childPath, session2);
+
+            assertThat(mailboxManager.getMailbox(intermediatePath, session)
+                .getMailboxEntity().getACL().getEntries().get(MailboxACL.EntryKey.createUserEntryKey(USER_2)))
+                .isEqualTo(MailboxACL.Rfc4314Rights.fromSerializedRfc4314Rights("lrk"));
+        }
+
+        @Test
+        void shareeShouldBeAbleToDeleteMailbox() throws Exception {
+            assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.ACL));
+            session = mailboxManager.createSystemSession(USER_1);
+            MailboxPath mailboxPath = MailboxPath.forUser(USER_1, "child");
+            mailboxManager.createMailbox(mailboxPath, session);
+            mailboxManager.applyRightsCommand(mailboxPath,
+                MailboxACL.command()
+                    .key(MailboxACL.EntryKey.createUserEntryKey(USER_2))
+                    .rights(MailboxACL.Rfc4314Rights.of(ImmutableList.of(MailboxACL.Right.Lookup,
+                        MailboxACL.Right.Read, MailboxACL.Right.DeleteMailbox)))
+                    .asAddition(), session);
+
+            MailboxSession session2 = mailboxManager.createSystemSession(USER_2);
+            mailboxManager.deleteMailbox(mailboxPath, session2);
+
+            assertThatThrownBy(() -> mailboxManager.getMailbox(mailboxPath, session))
+                .isInstanceOf(MailboxNotFoundException.class);
+        }
+
         @Test
         void creatingMixedCaseINBOXShouldCreateItAsINBOX() throws Exception {
             session = mailboxManager.createSystemSession(USER_1);
@@ -1199,6 +1289,32 @@ void searchShouldCombinePrivateAndDelegatedMailboxes() throws Exception {
                 .extracting(MailboxMetaData::getPath)
                 .containsOnly(inbox1, inbox2);
         }
+
+        @Test
+        void searchShouldAllowListingAnotherUserMailbox() throws Exception {
+            assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.ACL));
+            MailboxSession session1 = mailboxManager.createSystemSession(USER_1);
+            MailboxSession session2 = mailboxManager.createSystemSession(USER_2);
+            MailboxPath inbox1 = MailboxPath.inbox(session1);
+            MailboxPath inbox2 = MailboxPath.inbox(session2);
+            mailboxManager.createMailbox(inbox1, session1);
+            mailboxManager.createMailbox(inbox2, session2);
+            mailboxManager.setRights(inbox1,
+                MailboxACL.EMPTY.apply(MailboxACL.command()
+                    .forUser(USER_2)
+                    .rights(MailboxACL.Right.Read, MailboxACL.Right.Lookup)
+                    .asAddition()),
+                session1);
+
+            MailboxQuery mailboxQuery = MailboxQuery.builder()
+                .userAndNamespaceFrom(inbox1)
+                .matchesAllMailboxNames()
+                .build();
+
+            assertThat(mailboxManager.search(mailboxQuery, session2).toStream())
+                .extracting(MailboxMetaData::getPath)
+                .containsExactly(inbox1);
+        }
 
         @Test
         void searchShouldAllowUserFiltering() throws Exception {
@@ -2093,7 +2209,7 @@ void user2ShouldNotBeAbleToDeleteUser1Mailbox() throws Exception {
             mailboxManager.createMailbox(inbox, sessionUser1);
 
             assertThatThrownBy(() -> mailboxManager.deleteMailbox(inbox, sessionUser2))
-                .isInstanceOf(MailboxNotFoundException.class);
+                .isInstanceOf(InsufficientRightsException.class);
         }
 
 
@@ -3018,6 +3134,26 @@ void setRightsShouldThrowOnDeletedMailbox() throws Exception {
 
         @Test
         void setRightsByIdShouldThrowWhenNotOwner() throws Exception {
+            MailboxPath mailboxPath = MailboxPath.forUser(USER_2, "mailbox");
+            MailboxId id = mailboxManager.createMailbox(mailboxPath, session2).get();
+            mailboxManager.setRights(id,  MailboxACL.EMPTY.apply(MailboxACL.command()
+                .key(MailboxACL.EntryKey.createUserEntryKey(USER_1))
+                .rights(new MailboxACL.Rfc4314Rights(MailboxACL.Right.Lookup, MailboxACL.Right.Administer, MailboxACL.Right.Read))
+                .asAddition()), session2);
+
+            mailboxManager.setRights(id, MailboxACL.EMPTY.apply(
+                MailboxACL.command()
+                    .key(MailboxACL.EntryKey.createUserEntryKey(USER_1))
+                    .rights(MailboxACL.FULL_RIGHTS)
+                    .asAddition()), session);
+
+            assertThat(mailboxManager.getMailbox(mailboxPath, session2)
+                .getMailboxEntity().getACL().getEntries().get(MailboxACL.EntryKey.createUserEntryKey(USER_1)))
+                .isEqualTo(MailboxACL.Rfc4314Rights.fromSerializedRfc4314Rights("aeiklprstwx"));
+        }
+
+        @Test
+        void setRightsByIdShouldThrowWhenNotAdministrator() throws Exception {
             MailboxId id = mailboxManager.createMailbox(MailboxPath.forUser(USER_2, "mailbox"), session2).get();
             mailboxManager.setRights(id,  MailboxACL.EMPTY.apply(MailboxACL.command()
                 .key(MailboxACL.EntryKey.createUserEntryKey(USER_1))

mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedRegexTest.java

@@ -224,12 +224,12 @@ void isExpressionMatchShouldMatchFolderWhenMatching() {
     }
 
     @Test
-    void isExpressionMatchShouldReturnFalseWhenNameBeginsWithDelimiter() {
+    void isExpressionMatchShouldReturnTrueWhenNameBeginsWithDelimiter() {
         PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
 
         boolean actual = testee.isExpressionMatch(".mailbox");
 
-        assertThat(actual).isFalse();
+        assertThat(actual).isTrue();
     }
 
     @Test