moved to the use of permissions instead of roles for the AdminConsole; however, this will currently disable the effects of role ADMIN

java/com.sap.sse.gwt.adminconsole/META-INF/MANIFEST.MF

@@ -9,6 +9,7 @@ Require-Bundle: com.google.gwt.osgi;bundle-version="2.7.0",
  com.sap.sse.gwt,
  com.sap.sse.security.ui,
  com.sap.sse.security,
- com.sap.sse.common
+ com.sap.sse.common,
+ com.sap.sse.security.common
 Export-Package: com.sap.sse.gwt.adminconsole
 Bundle-ActivationPolicy: lazy

java/com.sap.sse.gwt.adminconsole/src/com/sap/sse/gwt/adminconsole/AdminConsoleFeatures.java

@@ -11,17 +11,17 @@ import com.sap.sse.common.impl.NamedImpl;
  */
 public class AdminConsoleFeatures extends NamedImpl {
     private static final long serialVersionUID = 7441608351911944793L;
-    private String[] enabledRoles;
+    private String requiredPermission;
     
-    public AdminConsoleFeatures(String name, String... enabledRoles) {
+    public AdminConsoleFeatures(String name, String requiredPermission) {
         super(name);
-        this.enabledRoles = enabledRoles;
+        this.requiredPermission = requiredPermission;
     }
 
     /**
      * If the user has at least one of these roles, he/she is permitted to use this feature.
      */
-    public String[] getEnabledRoles() {
-        return enabledRoles;
+    public String getRequiredPermission() {
+        return requiredPermission;
     }
 }

java/com.sap.sse.gwt.adminconsole/src/com/sap/sse/gwt/adminconsole/AdminConsolePanel.java

@@ -273,23 +273,11 @@ public class AdminConsolePanel extends DockLayoutPanel {
         for (Map.Entry<Triple<VerticalOrHorizontalTabLayoutPanel, Widget, String>, AdminConsoleFeatures> e : roleSpecificTabs
                 .entrySet()) {
             final Widget panelToAdd = e.getKey().getB();
-            if (user != null && isUserInRole(e.getValue().getEnabledRoles())) {
+            if (user != null && user.hasPermission(e.getValue().getRequiredPermission())) {
                 e.getKey().getA().add(panelToAdd, e.getKey().getC(), /* asHtml */false);
             } else {
                 e.getKey().getA().remove(panelToAdd);
             }
         }
     }
-
-    private boolean isUserInRole(String... roles) {
-        boolean result = false;
-        UserDTO user = getUserService().getCurrentUser();
-        for (String enabledRole : roles) {
-            if (user.hasRole(enabledRole)) {
-                result = true;
-                break;
-            }
-        }
-        return result;
-    }
 }

java/com.sap.sse.security.common/src/com/sap/sse/security/shared/WildcardPermission.java

@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package com.sap.sse.security.shared;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A <code>WildcardPermission</code> is a very flexible permission construct supporting multiple levels of
+ * permission matching. However, most people will probably follow some standard conventions as explained below.
+ * <p/>
+ * <h3>Simple Usage</h3>
+ * <p/>
+ * In the simplest form, <code>WildcardPermission</code> can be used as a simple permission string. You could grant a
+ * user an &quot;editNewsletter&quot; permission and then check to see if the user has the editNewsletter
+ * permission by calling
+ * <p/>
+ * <code>subject.isPermitted(&quot;editNewsletter&quot;)</code>
+ * <p/>
+ * This is (mostly) equivalent to
+ * <p/>
+ * <code>subject.isPermitted( new WildcardPermission(&quot;editNewsletter&quot;) )</code>
+ * <p/>
+ * but more on that later.
+ * <p/>
+ * The simple permission string may work for simple applications, but it requires you to have permissions like
+ * <code>&quot;viewNewsletter&quot;</code>, <code>&quot;deleteNewsletter&quot;</code>,
+ * <code>&quot;createNewsletter&quot;</code>, etc. You can also grant a user <code>&quot;*&quot;</code> permissions
+ * using the wildcard character (giving this class its name), which means they have <em>all</em> permissions. But
+ * using this approach there's no way to just say a user has &quot;all newsletter permissions&quot;.
+ * <p/>
+ * For this reason, <code>WildcardPermission</code> supports multiple <em>levels</em> of permissioning.
+ * <p/>
+ * <h3>Multiple Levels</h3>
+ * <p/>
+ * WildcardPermission</code> also supports the concept of multiple <em>levels</em>.  For example, you could
+ * restructure the previous simple example by granting a user the permission <code>&quot;newsletter:edit&quot;</code>.
+ * The colon in this example is a special character used by the <code>WildcardPermission</code> that delimits the
+ * next token in the permission.
+ * <p/>
+ * In this example, the first token is the <em>domain</em> that is being operated on
+ * and the second token is the <em>action</em> being performed. Each level can contain multiple values.  So you
+ * could simply grant a user the permission <code>&quot;newsletter:view,edit,create&quot;</code> which gives them
+ * access to perform <code>view</code>, <code>edit</code>, and <code>create</code> actions in the <code>newsletter</code>
+ * <em>domain</em>. Then you could check to see if the user has the <code>&quot;newsletter:create&quot;</code>
+ * permission by calling
+ * <p/>
+ * <code>subject.isPermitted(&quot;newsletter:create&quot;)</code>
+ * <p/>
+ * (which would return true).
+ * <p/>
+ * In addition to granting multiple permissions via a single string, you can grant all permission for a particular
+ * level. So if you wanted to grant a user all actions in the <code>newsletter</code> domain, you could simply give
+ * them <code>&quot;newsletter:*&quot;</code>. Now, any permission check for <code>&quot;newsletter:XXX&quot;</code>
+ * will return <code>true</code>. It is also possible to use the wildcard token at the domain level (or both): so you
+ * could grant a user the <code>&quot;view&quot;</code> action across all domains <code>&quot;*:view&quot;</code>.
+ * <p/>
+ * <h3>Instance-level Access Control</h3>
+ * <p/>
+ * Another common usage of the <code>WildcardPermission</code> is to model instance-level Access Control Lists.
+ * In this scenario you use three tokens - the first is the <em>domain</em>, the second is the <em>action</em>, and
+ * the third is the <em>instance</em> you are acting on.
+ * <p/>
+ * So for example you could grant a user <code>&quot;newsletter:edit:12,13,18&quot;</code>.  In this example, assume
+ * that the third token is the system's ID of the newsletter. That would allow the user to edit newsletters
+ * <code>12</code>, <code>13</code>, and <code>18</code>. This is an extremely powerful way to express permissions,
+ * since you can now say things like <code>&quot;newsletter:*:13&quot;</code> (grant a user all actions for newsletter
+ * <code>13</code>), <code>&quot;newsletter:view,create,edit:*&quot;</code> (allow the user to
+ * <code>view</code>, <code>create</code>, or <code>edit</code> <em>any</em> newsletter), or
+ * <code>&quot;newsletter:*:*</code> (allow the user to perform <em>any</em> action on <em>any</em> newsletter).
+ * <p/>
+ * To perform checks against these instance-level permissions, the application should include the instance ID in the
+ * permission check like so:
+ * <p/>
+ * <code>subject.isPermitted( &quot;newsletter:edit:13&quot; )</code>
+ * <p/>
+ * There is no limit to the number of tokens that can be used, so it is up to your imagination in terms of ways that
+ * this could be used in your application.  However, the Shiro team likes to standardize some common usages shown
+ * above to help people get started and provide consistency in the Shiro community.<p>
+ * 
+ * This class has been slightly adjusted from the original Shiro version such that it no longer depends on any Shiro
+ * classes but still offers the same services that the Shiro <code>WildcardPermission</code> does. This way, the
+ * permission can also be used by a GWT client and an Android implementation.
+ */
+public class WildcardPermission implements Serializable {
+
+    //TODO - JavaDoc methods
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = -7136806951296823464L;
+    /*--------------------------------------------
+    |             C O N S T A N T S             |
+    ============================================*/
+    protected static final String WILDCARD_TOKEN = "*";
+    protected static final String PART_DIVIDER_TOKEN = ":";
+    protected static final String SUBPART_DIVIDER_TOKEN = ",";
+    protected static final boolean DEFAULT_CASE_SENSITIVE = false;
+
+    /*--------------------------------------------
+    |    I N S T A N C E   V A R I A B L E S    |
+    ============================================*/
+    private List<Set<String>> parts;
+
+    /*--------------------------------------------
+    |         C O N S T R U C T O R S           |
+    ============================================*/
+    /**
+     * Default no-arg constructor for subclasses only - end-user developers instantiating Permission instances must
+     * provide a wildcard string at a minimum, since Permission instances are immutable once instantiated.
+     * <p/>
+     * Note that the WildcardPermission class is very robust and typically subclasses are not necessary unless you
+     * wish to create type-safe Permission objects that would be used in your application, such as perhaps a
+     * {@code UserPermission}, {@code SystemPermission}, {@code PrinterPermission}, etc.  If you want such type-safe
+     * permission usage, consider subclassing the {@link DomainPermission DomainPermission} class for your needs.
+     */
+    protected WildcardPermission() {
+    }
+
+    public WildcardPermission(String wildcardString) {
+        this(wildcardString, DEFAULT_CASE_SENSITIVE);
+    }
+
+    public WildcardPermission(String wildcardString, boolean caseSensitive) {
+        setParts(wildcardString, caseSensitive);
+    }
+
+    protected void setParts(String wildcardString) {
+        setParts(wildcardString, DEFAULT_CASE_SENSITIVE);
+    }
+
+    protected void setParts(String wildcardString, boolean caseSensitive) {
+        if (wildcardString == null || wildcardString.trim().length() == 0) {
+            throw new IllegalArgumentException("Wildcard string cannot be null or empty. Make sure permission strings are properly formatted.");
+        }
+
+        wildcardString = wildcardString.trim();
+
+        List<String> parts = Arrays.asList(wildcardString.split(PART_DIVIDER_TOKEN));
+
+        this.parts = new ArrayList<Set<String>>();
+        for (String part : parts) {
+            Set<String> subparts = new HashSet<>(Arrays.asList(part.split(SUBPART_DIVIDER_TOKEN)));
+            if (!caseSensitive) {
+                subparts = lowercase(subparts);
+            }
+            if (subparts.isEmpty()) {
+                throw new IllegalArgumentException("Wildcard string cannot contain parts with only dividers. Make sure permission strings are properly formatted.");
+            }
+            this.parts.add(subparts);
+        }
+
+        if (this.parts.isEmpty()) {
+            throw new IllegalArgumentException("Wildcard string cannot contain only dividers. Make sure permission strings are properly formatted.");
+        }
+    }
+
+    private Set<String> lowercase(Set<String> subparts) {
+        Set<String> lowerCasedSubparts = new LinkedHashSet<String>(subparts.size());
+        for (String subpart : subparts) {
+            lowerCasedSubparts.add(subpart.toLowerCase());
+        }
+        return lowerCasedSubparts;
+    }
+
+    /*--------------------------------------------
+    |  A C C E S S O R S / M O D I F I E R S    |
+    ============================================*/
+    protected List<Set<String>> getParts() {
+        return this.parts;
+    }
+
+    /*--------------------------------------------
+    |               M E T H O D S               |
+    ============================================*/
+
+    public boolean implies(WildcardPermission wp) {
+        // By default only supports comparisons with other WildcardPermissions
+        List<Set<String>> otherParts = wp.getParts();
+
+        int i = 0;
+        for (Set<String> otherPart : otherParts) {
+            // If this permission has less parts than the other permission, everything after the number of parts contained
+            // in this permission is automatically implied, so return true
+            if (getParts().size() - 1 < i) {
+                return true;
+            } else {
+                Set<String> part = getParts().get(i);
+                if (!part.contains(WILDCARD_TOKEN) && !part.containsAll(otherPart)) {
+                    return false;
+                }
+                i++;
+            }
+        }
+
+        // If this permission has more parts than the other parts, only imply it if all of the other parts are wildcards
+        for (; i < getParts().size(); i++) {
+            Set<String> part = getParts().get(i);
+            if (!part.contains(WILDCARD_TOKEN)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public String toString() {
+        StringBuilder buffer = new StringBuilder();
+        for (Set<String> part : parts) {
+            if (buffer.length() > 0) {
+                buffer.append(":");
+            }
+            buffer.append(part);
+        }
+        return buffer.toString();
+    }
+
+    public boolean equals(Object o) {
+        if (o instanceof WildcardPermission) {
+            WildcardPermission wp = (WildcardPermission) o;
+            return parts.equals(wp.parts);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return parts.hashCode();
+    }
+
+}

java/com.sap.sse.security.ui/src/main/java/com/sap/sse/security/ui/client/component/UserDetailsView.java

@@ -53,7 +53,7 @@ public class UserDetailsView extends FlowPanel {
     private final VerticalPanel accountPanels;
     private UserDTO user;
 
-    public UserDetailsView(final UserService userService, UserDTO user, final StringMessages stringMessages) {
+    public UserDetailsView(final UserService userService, UserDTO user, final StringMessages stringMessages, final UserListDataProvider userListDataProvider) {
         final UserManagementServiceAsync userManagementService = userService.getUserManagementService();
         this.stringMessages = stringMessages;
         this.user = user;
@@ -85,7 +85,7 @@ public class UserDetailsView extends FlowPanel {
                                 if (!result.isSuccessful()) {
                                     Window.alert(stringMessages.errorUpdatingRoles(selectedUser.getName(), result.getMessage()));
                                 } else {
-                                    selectedUser.setRoles(newRoleList);
+                                    userListDataProvider.updateDisplays();
                                     if (userService.getCurrentUser().getName().equals(selectedUser.getName())) {
                                         // if the current user's roles changed, update the user object in the user service and notify others
                                         userService.updateUser(/* notify other instances */ true);
@@ -95,7 +95,8 @@ public class UserDetailsView extends FlowPanel {
                         }));
             }
         });
-        permissionsEditor = new StringListEditorComposite(user==null?Collections.<String>emptySet():user.getPermissions(), stringMessages, com.sap.sse.gwt.client.IconResources.INSTANCE.removeIcon(), defaultPermissionNames,
+        permissionsEditor = new StringListEditorComposite(user==null?Collections.<String>emptySet():user.getStringPermissions(), stringMessages,
+                com.sap.sse.gwt.client.IconResources.INSTANCE.removeIcon(), defaultPermissionNames,
                 stringMessages.enterPermissionName());
         permissionsEditor.addValueChangeHandler(new ValueChangeHandler<Iterable<String>>() {
             @Override
@@ -114,7 +115,7 @@ public class UserDetailsView extends FlowPanel {
                                 if (!result.isSuccessful()) {
                                     Window.alert(stringMessages.errorUpdatingPermissions(selectedUser.getName(), result.getMessage()));
                                 } else {
-                                    selectedUser.setPermissions(newPermissionList);
+                                    userListDataProvider.updateDisplays();
                                     if (userService.getCurrentUser().getName().equals(selectedUser.getName())) {
                                         // if the current user's permissions changed, update the user object in the user service and notify others
                                         userService.updateUser(/* notify other instances */ true);
@@ -240,7 +241,7 @@ public class UserDetailsView extends FlowPanel {
                 accountPanels.add(accountPanelDecorator);
             }
             rolesEditor.setValue(user.getRoles(), /* fireEvents */ false);
-            permissionsEditor.setValue(user.getPermissions(), /* fireEvents */ false);
+            permissionsEditor.setValue(user.getStringPermissions(), /* fireEvents */ false);
         }
     }
 

java/com.sap.sse.security.ui/src/main/java/com/sap/sse/security/ui/client/component/UserListDataProvider.java

@@ -76,6 +76,5 @@ public class UserListDataProvider extends AbstractDataProvider<UserDTO> {
         for (HasData<UserDTO> hd : getDataDisplays()) {
             onRangeChanged(hd);
         }
-//        //TODO [D056866] SelectionChangeEvent.fire(singleSelectionModel);
     }
 }

java/com.sap.sse.security.ui/src/main/java/com/sap/sse/security/ui/client/component/UserManagementPanel.java

@@ -80,7 +80,9 @@ public class UserManagementPanel extends DockPanel {
         deleteButton.setEnabled(singleSelectionModel.getSelectedObject() != null);
         final UserList userList = new UserList();
         userList.setSelectionModel(singleSelectionModel);
-        final UserDetailsView userDetailsView = new UserDetailsView(userService, singleSelectionModel.getSelectedObject(), stringMessages);
+        TextBox filterBox = new TextBox();
+        userListDataProvider = new UserListDataProvider(userManagementService, filterBox);
+        final UserDetailsView userDetailsView = new UserDetailsView(userService, singleSelectionModel.getSelectedObject(), stringMessages, userListDataProvider);
         add(userDetailsView, DockPanel.CENTER);
         userDetailsView.addUserChangeEventHandler(new UserChangeEventHandler() {
             @Override
@@ -96,8 +98,6 @@ public class UserManagementPanel extends DockPanel {
             }
         });
         userList.setPageSize(20);
-        TextBox filterBox = new TextBox();
-        userListDataProvider = new UserListDataProvider(userManagementService, filterBox);
         userListDataProvider.addDataDisplay(userList);
         SimplePager pager = new SimplePager(TextLocation.CENTER, false, /* fast forward step size */ 50, true);
         pager.setDisplay(userList);

java/com.sap.sse.security.ui/src/main/java/com/sap/sse/security/ui/server/UserManagementServiceImpl.java

@@ -272,7 +272,7 @@ public class UserManagementServiceImpl extends RemoteServiceServlet implements U
         }
     }
 
-    private UserDTO createUserDTOFromUser(User user){
+    private UserDTO createUserDTOFromUser(User user) {
         UserDTO userDTO;
         Map<AccountType, Account> accounts = user.getAllAccounts();
         List<AccountDTO> accountDTOs = new ArrayList<>();
@@ -288,9 +288,7 @@ public class UserManagementServiceImpl extends RemoteServiceServlet implements U
                 break;
             }
         }
-        userDTO = new UserDTO(user.getName(), user.getEmail(), user.isEmailValidated(), accountDTOs);
-        userDTO.addRoles(user.getRoles());
-        userDTO.addPermissions(user.getPermissions());
+        userDTO = new UserDTO(user.getName(), user.getEmail(), user.isEmailValidated(), accountDTOs, user.getRoles(), user.getPermissions());
         return userDTO;
     }
 

java/com.sap.sse.security.ui/src/main/java/com/sap/sse/security/ui/shared/UserDTO.java

@@ -1,27 +1,35 @@
 package com.sap.sse.security.ui.shared;
 
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import com.google.gwt.user.client.rpc.IsSerializable;
 import com.sap.sse.common.Util;
+import com.sap.sse.security.shared.WildcardPermission;
 
 public class UserDTO implements IsSerializable {
     private String name;
     private String email;
     private List<AccountDTO> accounts;
-    private Set<String> roles = new HashSet<>();
-    private Set<String> permissions = new HashSet<>();
+    private Set<String> roles;
+    private Set<WildcardPermission> permissions;
     private boolean emailValidated;
 
     UserDTO() {} // for serialization only
 
-    public UserDTO(String name, String email, boolean emailValidated, List<AccountDTO> accounts) {
+    public UserDTO(String name, String email, boolean emailValidated, List<AccountDTO> accounts, Iterable<String> roles, Iterable<String> stringPermissions) {
         this.name = name;
         this.email = email;
         this.emailValidated = emailValidated;
         this.accounts = accounts;
+        this.roles = new HashSet<>();
+        Util.addAll(roles, this.roles);
+        this.permissions = new HashSet<>();
+        for (String stringPermission : stringPermissions) {
+            this.permissions.add(new WildcardPermission(stringPermission));
+        }
     }
 
     public String getName() {
@@ -36,32 +44,31 @@ public class UserDTO implements IsSerializable {
         return roles.contains(role);
     }
     
-    public void addRoles(Iterable<String> roles) {
-        Util.addAll(roles, this.roles);
-    }
-    
-    public void setRoles(Iterable<String> newRoleList) {
-        this.roles.clear();
-        Util.addAll(newRoleList, this.roles);
-    }
-    
-    public Iterable<String> getPermissions() {
+    public Iterable<WildcardPermission> getPermissions() {
         return permissions;
     }
     
-    public boolean hasPermission(String permission) {
-        return permissions.contains(permission);
-    }
-
-    public void addPermissions(Iterable<String> permissions) {
-        Util.addAll(permissions, this.permissions);
-    }
-
-    public void setPermissions(Iterable<String> newPermissionList) {
-        this.permissions.clear();
-        Util.addAll(newPermissionList, this.permissions);
+    public Iterable<String> getStringPermissions() {
+        List<String> result = new ArrayList<>();
+        for (WildcardPermission wp : getPermissions()) {
+            result.add(wp.toString());
+        }
+        return result;
     }
     
+    public boolean hasPermission(String permission) {
+        return hasPermission(new WildcardPermission(permission));
+    }
+    
+    public boolean hasPermission(WildcardPermission permission) {
+        for (WildcardPermission p : permissions) {
+            if (p.implies(permission)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public List<AccountDTO> getAccounts() {
         return accounts;
     }