This is an automated email from the ASF dual-hosted git repository.

snoopdave pushed a commit to branch roller-6.1.x
in repository https://gitbox.apache.org/repos/asf/roller.git


The following commit(s) were added to refs/heads/roller-6.1.x by this push:
     new 3aab7aca3 Match only user names in the user search for non-admins and 
escape LIKE wildcards (#222)
3aab7aca3 is described below

commit 3aab7aca345a75f62f40bd113daca1adc4b8bb8f
Author: David M. Johnson <[email protected]>
AuthorDate: Thu Oct 29 22:41:54 2026 -0400

    Match only user names in the user search for non-admins and escape LIKE 
wildcards (#222)
    
    * Match only user names in the user search for non-admins and escape LIKE 
wildcards
    * Use a user-name-only query for non-admins and note the change in 
CHANGES.md
    * Test the underscore escape with a name-based probe; add 
UserDataServletTest
    * Share the user lookup and keep non-admin picker requests to one page of 
enabled users
---
 CHANGES.md                                         |   5 +
 .../roller/weblogger/business/UserManager.java     |  17 ++-
 .../weblogger/business/jpa/JPAUserManagerImpl.java |  35 ++++--
 .../weblogger/ui/struts2/ajax/UserDataServlet.java |  13 +-
 .../org/apache/roller/weblogger/pojos/User.orm.xml |  10 +-
 .../apache/roller/weblogger/business/UserTest.java |  15 +++
 .../business/jpa/JPAUserManagerLikePrefixTest.java |  37 ++++++
 .../ui/struts2/ajax/UserDataServletTest.java       | 132 +++++++++++++++++++++
 8 files changed, 252 insertions(+), 12 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 7dcfa9c18..5c97aae97 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -70,6 +70,11 @@
   weblog pages must be relative or use `http`, `https`, `ftp` or `mailto`;
   other links, and links with `&` before the path, are shown without a
   target. The blogroll escapes bookmark names and descriptions.
+- **The user picker matches user names only, except for global admins.** When
+  a user who is not a global admin searches for users (for example to invite a
+  member), only user names are matched. Global admins can still search by
+  email address. For other users the picker lists enabled users only, at
+  most 50 at a time. `%` and `_` in the search text match only themselves.
 
 ### Bug fixes
 
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/business/UserManager.java 
b/app/src/main/java/org/apache/roller/weblogger/business/UserManager.java
index 3a5056def..266fa1cfa 100644
--- a/app/src/main/java/org/apache/roller/weblogger/business/UserManager.java
+++ b/app/src/main/java/org/apache/roller/weblogger/business/UserManager.java
@@ -153,15 +153,30 @@ public interface UserManager {
 
     /**
      * Lookup users whose usernames or email addresses start with a string.
+     * Because it matches email addresses, use it only for callers who may
+     * see them (global admins); others use
+     * {@link #getUsersWithUserNameStartingWith}.
      *
      * @param startsWith String to match userNames and emailAddresses against
      * @param offset     Offset into results (for paging)
      * @param length     Max to return (for paging)
-     * @param enabled    True for only enalbed, false for disabled, null for 
all
+     * @param enabled    True for only enabled, false for disabled, null for 
all
      * @return List of (up to length) users that match startsWith string
      */
     List<User> getUsersStartingWith(String startsWith,
             Boolean enabled, int offset, int length) throws WebloggerException;
+
+    /**
+     * Lookup users whose usernames start with a string.
+     *
+     * @param startsWith String to match userNames against
+     * @param enabled    True for only enabled, false for disabled, null for 
all
+     * @param offset     Offset into results (for paging)
+     * @param length     Max to return (for paging)
+     * @return List of (up to length) users that match startsWith string
+     */
+    List<User> getUsersWithUserNameStartingWith(String startsWith,
+            Boolean enabled, int offset, int length) throws WebloggerException;
     
     
     /**
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerImpl.java
 
b/app/src/main/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerImpl.java
index d83bac426..df957ce3a 100644
--- 
a/app/src/main/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerImpl.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerImpl.java
@@ -257,15 +257,28 @@ public class JPAUserManagerImpl implements UserManager {
     @Override
     public List<User> getUsersStartingWith(String startsWith, Boolean enabled,
             int offset, int length) throws WebloggerException {
+        return findUsersStartingWith(startsWith, true, enabled, offset, 
length);
+    }
+
+    @Override
+    public List<User> getUsersWithUserNameStartingWith(String startsWith, 
Boolean enabled,
+            int offset, int length) throws WebloggerException {
+        return findUsersStartingWith(startsWith, false, enabled, offset, 
length);
+    }
+
+    private List<User> findUsersStartingWith(String startsWith, boolean 
matchEmail,
+            Boolean enabled, int offset, int length) throws WebloggerException 
{
         TypedQuery<User> query;
+        String match = matchEmail ? "UserNameOrEmailAddressStartsWith" : 
"UserNameStartsWith";
 
         if (enabled != null) {
             if (startsWith != null) {
-                query = strategy.getNamedQuery(
-                        "User.getByEnabled&UserNameOrEmailAddressStartsWith", 
User.class);
+                query = strategy.getNamedQuery("User.getByEnabled&" + match, 
User.class);
                 query.setParameter(1, enabled);
-                query.setParameter(2, startsWith + '%');
-                query.setParameter(3, startsWith + '%');
+                query.setParameter(2, likePrefix(startsWith));
+                if (matchEmail) {
+                    query.setParameter(3, likePrefix(startsWith));
+                }
             } else {
                 query = strategy.getNamedQuery(
                         "User.getByEnabled", User.class);
@@ -273,9 +286,8 @@ public class JPAUserManagerImpl implements UserManager {
             }
         } else {
             if (startsWith != null) {
-                query = strategy.getNamedQuery(
-                        "User.getByUserNameOrEmailAddressStartsWith", 
User.class);
-                query.setParameter(1, startsWith +  '%');
+                query = strategy.getNamedQuery("User.getBy" + match, 
User.class);
+                query.setParameter(1, likePrefix(startsWith));
             } else {
                 query = strategy.getNamedQuery("User.getAll", User.class);
             }
@@ -289,6 +301,15 @@ public class JPAUserManagerImpl implements UserManager {
         return query.getResultList();
     }
 
+    /**
+     * LIKE pattern that matches values starting with the given text. The
+     * named queries use '!' as the escape character, so '%' and '_' in the
+     * text match only themselves.
+     */
+    static String likePrefix(String startsWith) {
+        return startsWith.replace("!", "!!").replace("%", "!%").replace("_", 
"!_") + '%';
+    }
+
     
     @Override
     public Map<String, Long> getUserNameLetterMap() throws WebloggerException {
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServlet.java
 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServlet.java
index b3739ce40..6f3f735c3 100644
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServlet.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServlet.java
@@ -102,12 +102,21 @@ public class UserDataServlet extends HttpServlet {
             length = Integer.parseInt(request.getParameter("length"));
         } catch (Exception ignored) {
         }
+        if (!admin) {
+            // others pick from enabled users only, one page at a time
+            enabledOnly = Boolean.TRUE;
+            if (length < 0 || length > MAX_LENGTH) {
+                length = MAX_LENGTH;
+            }
+        }
 
         Weblogger roller = WebloggerFactory.getWeblogger();
         try {
             UserManager umgr = roller.getUserManager();
-            List<User> users = umgr.getUsersStartingWith(startsWith,
-                    enabledOnly, offset, length);
+            // only admins, who see email addresses, may search by them
+            List<User> users = admin
+                    ? umgr.getUsersStartingWith(startsWith, enabledOnly, 
offset, length)
+                    : umgr.getUsersWithUserNameStartingWith(startsWith, 
enabledOnly, offset, length);
             for (User user : users) {
                 response.getWriter().print(user.getUserName());
                 if (admin) {
diff --git 
a/app/src/main/resources/org/apache/roller/weblogger/pojos/User.orm.xml 
b/app/src/main/resources/org/apache/roller/weblogger/pojos/User.orm.xml
index e64ae4a53..033f78a80 100644
--- a/app/src/main/resources/org/apache/roller/weblogger/pojos/User.orm.xml
+++ b/app/src/main/resources/org/apache/roller/weblogger/pojos/User.orm.xml
@@ -22,7 +22,7 @@
             <query>SELECT u FROM User u WHERE u.enabled = ?1 AND u.dateCreated 
&lt; ?2 AND u.dateCreated &gt; ?3 ORDER BY u.dateCreated DESC</query>
         </named-query>
         <named-query 
name="User.getByEnabled&amp;UserNameOrEmailAddressStartsWith">
-            <query>SELECT u FROM User u WHERE u.enabled = ?1 AND (u.userName 
LIKE ?2 OR u.emailAddress LIKE ?3)</query>
+            <query>SELECT u FROM User u WHERE u.enabled = ?1 AND (u.userName 
LIKE ?2 ESCAPE '!' OR u.emailAddress LIKE ?3 ESCAPE '!')</query>
         </named-query>
         <named-query name="User.getByEndDateOrderByStartDateDesc">
             <query>SELECT u FROM User u WHERE u.dateCreated &lt; ?1 ORDER BY 
u.dateCreated DESC</query>
@@ -37,7 +37,13 @@
             <query>SELECT u FROM User u WHERE u.openIdUrl = ?1</query>
         </named-query>
         <named-query name="User.getByUserNameOrEmailAddressStartsWith">
-            <query>SELECT u FROM User u WHERE u.userName LIKE ?1 OR 
u.emailAddress LIKE ?1</query>
+            <query>SELECT u FROM User u WHERE u.userName LIKE ?1 ESCAPE '!' OR 
u.emailAddress LIKE ?1 ESCAPE '!'</query>
+        </named-query>
+        <named-query name="User.getByUserNameStartsWith">
+            <query>SELECT u FROM User u WHERE u.userName LIKE ?1 ESCAPE 
'!'</query>
+        </named-query>
+        <named-query name="User.getByEnabled&amp;UserNameStartsWith">
+            <query>SELECT u FROM User u WHERE u.enabled = ?1 AND u.userName 
LIKE ?2 ESCAPE '!'</query>
         </named-query>
         <named-query name="User.getByUserNameOrderByUserName">
             <query>SELECT u FROM User u WHERE u.userName= ?1 ORDER BY 
u.userName</query>
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/business/UserTest.java 
b/app/src/test/java/org/apache/roller/weblogger/business/UserTest.java
index cabbc32af..8f0c94e62 100644
--- a/app/src/test/java/org/apache/roller/weblogger/business/UserTest.java
+++ b/app/src/test/java/org/apache/roller/weblogger/business/UserTest.java
@@ -149,6 +149,21 @@ public class UserTest  {
         user = users2.get(0);
         assertNotNull(user);
         assertEquals(testUser.getUserName(), user.getUserName());
+
+        // '%' and '_' in the search text match only themselves
+        // (an unescaped '_' would let the probe match the test user's name)
+        String name = testUser.getUserName();
+        String underscoreProbe = name.charAt(0) + "_" + name.substring(2, 5);
+        assertEquals(0, mgr.getUsersStartingWith("%", Boolean.TRUE, 0, 
10).size());
+        assertEquals(0, mgr.getUsersStartingWith(underscoreProbe, 
Boolean.TRUE, 0, 10).size());
+        assertEquals(0, mgr.getUsersStartingWith(underscoreProbe, null, 0, 
10).size());
+
+        // the user-name-only lookup does not match email addresses
+        assertEquals(1, mgr.getUsersWithUserNameStartingWith(
+                testUser.getUserName().substring(0, 3), Boolean.TRUE, 0, 
10).size());
+        assertEquals(0, mgr.getUsersWithUserNameStartingWith(
+                testUser.getEmailAddress().substring(0, 3), Boolean.TRUE, 0, 
10).size());
+        assertEquals(0, mgr.getUsersWithUserNameStartingWith(underscoreProbe, 
null, 0, 10).size());
         
         // make sure disable users are not returned
         user.setEnabled(Boolean.FALSE);
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerLikePrefixTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerLikePrefixTest.java
new file mode 100644
index 000000000..d9f63429c
--- /dev/null
+++ 
b/app/src/test/java/org/apache/roller/weblogger/business/jpa/JPAUserManagerLikePrefixTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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 org.apache.roller.weblogger.business.jpa;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * '%', '_' and the escape character '!' in search text match only themselves.
+ */
+class JPAUserManagerLikePrefixTest {
+
+    @Test
+    void escapesLikeCharacters() {
+        assertEquals("a!!b%", JPAUserManagerImpl.likePrefix("a!b"));
+        assertEquals("a!%b%", JPAUserManagerImpl.likePrefix("a%b"));
+        assertEquals("a!_b%", JPAUserManagerImpl.likePrefix("a_b"));
+        assertEquals("!!!%%", JPAUserManagerImpl.likePrefix("!%"));
+        assertEquals("%", JPAUserManagerImpl.likePrefix(""));
+    }
+}
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
new file mode 100644
index 000000000..7479fb6e0
--- /dev/null
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
@@ -0,0 +1,132 @@
+/*
+ * 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 org.apache.roller.weblogger.ui.struts2.ajax;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.List;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.roller.weblogger.business.UserManager;
+import org.apache.roller.weblogger.business.Weblogger;
+import org.apache.roller.weblogger.business.WebloggerFactory;
+import org.apache.roller.weblogger.pojos.User;
+import org.apache.roller.weblogger.ui.rendering.util.WeblogRequest;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockConstruction;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class UserDataServletTest {
+
+    @Test
+    public void testNonAdminSearchesUserNamesOnly() throws Exception {
+        User caller = mock(User.class);
+        when(caller.hasGlobalPermission("admin")).thenReturn(false);
+        UserManager users = userManager();
+
+        String body = search(caller, users);
+
+        verify(users).getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 0, 
50);
+        verify(users, never()).getUsersStartingWith(anyString(), any(), 
anyInt(), anyInt());
+        assertEquals("alice,Alice\n", body.replace("\r", ""));
+    }
+
+    @Test
+    public void testAdminSearchesUserNamesAndEmail() throws Exception {
+        User caller = mock(User.class);
+        when(caller.hasGlobalPermission("admin")).thenReturn(true);
+        UserManager users = userManager();
+
+        String body = search(caller, users);
+
+        verify(users).getUsersStartingWith("ali", Boolean.TRUE, 0, 50);
+        verify(users, never()).getUsersWithUserNameStartingWith(anyString(), 
any(), anyInt(), anyInt());
+        assertEquals("alice,[email protected]\n", body.replace("\r", ""));
+    }
+
+    @Test
+    public void testNonAdminGetsEnabledUsersOnePageAtATime() throws Exception {
+        User caller = mock(User.class);
+        when(caller.hasGlobalPermission("admin")).thenReturn(false);
+        UserManager users = userManager();
+
+        search(caller, users, "false", "100000");
+
+        verify(users).getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 0, 
50);
+    }
+
+    @Test
+    public void testAdminKeepsRequestedParameters() throws Exception {
+        User caller = mock(User.class);
+        when(caller.hasGlobalPermission("admin")).thenReturn(true);
+        UserManager users = userManager();
+
+        search(caller, users, "false", "100");
+
+        verify(users).getUsersStartingWith("ali", Boolean.FALSE, 0, 100);
+    }
+
+    private static UserManager userManager() throws Exception {
+        User alice = mock(User.class);
+        when(alice.getUserName()).thenReturn("alice");
+        when(alice.getScreenName()).thenReturn("Alice");
+        when(alice.getEmailAddress()).thenReturn("[email protected]");
+        UserManager users = mock(UserManager.class);
+        when(users.getUsersStartingWith("ali", Boolean.TRUE, 0, 
50)).thenReturn(List.of(alice));
+        when(users.getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 0, 
50)).thenReturn(List.of(alice));
+        return users;
+    }
+
+    private static String search(User caller, UserManager users) throws 
Exception {
+        return search(caller, users, "true", "50");
+    }
+
+    private static String search(User caller, UserManager users, String 
enabled, String length)
+            throws Exception {
+        Weblogger weblogger = mock(Weblogger.class);
+        when(weblogger.getUserManager()).thenReturn(users);
+
+        HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getParameter("startsWith")).thenReturn("ali");
+        when(request.getParameter("enabled")).thenReturn(enabled);
+        when(request.getParameter("length")).thenReturn(length);
+        HttpServletResponse response = mock(HttpServletResponse.class);
+        StringWriter body = new StringWriter();
+        when(response.getWriter()).thenReturn(new PrintWriter(body, true));
+
+        try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class);
+             MockedConstruction<WeblogRequest> weblogRequests = 
mockConstruction(WeblogRequest.class,
+                     (weblogRequest, context) -> 
when(weblogRequest.getUser()).thenReturn(caller))) {
+            factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+            new UserDataServlet().doGet(request, response);
+        }
+        return body.toString();
+    }
+}

Reply via email to