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
< ?2 AND u.dateCreated > ?3 ORDER BY u.dateCreated DESC</query>
</named-query>
<named-query
name="User.getByEnabled&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 < ?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&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();
+ }
+}