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 08528c4db Apply the Limited role to each entry in the entry editor
(#235)
08528c4db is described below
commit 08528c4db8c1b687027ff9e51bd98e81a5fddcc9
Author: David M. Johnson <[email protected]>
AuthorDate: Sat Nov 7 15:01:57 2026 -0500
Apply the Limited role to each entry in the entry editor (#235)
* Apply the Limited role to each entry in the entry editor
A Limited member can open, change and remove draft and pending entries
only, as in AtomPub and XML-RPC. Other entries answer with the access
denied page.
* Check entry write access when the editor action is prepared
The check now runs in myPrepare(), so it also covers the INPUT result after
field validation fails.
---
CHANGES.md | 3 +
.../weblogger/ui/struts2/editor/EntryEdit.java | 35 ++++
.../weblogger/ui/struts2/editor/EntryRemove.java | 22 ++-
.../struts2/editor/EntryWritePermissionTest.java | 214 +++++++++++++++++++++
4 files changed, 273 insertions(+), 1 deletion(-)
diff --git a/CHANGES.md b/CHANGES.md
index c63e2de41..17fe9ab67 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -46,6 +46,9 @@
PDF or plain text. The media file editor sets a file's original path only
when `mediafile.originalPathEdit.enabled=true`, as its form already shows.
AtomPub media uploads no longer set one.
+- **The entry editor applies the Limited role to each entry.** A Limited member
+ can open, change and remove draft and pending entries only, as in AtomPub and
+ XML-RPC. Other entries answer with the access denied page.
- **Planet is off by default.** `planet.aggregator.enabled` now defaults to
`false`. While it is off, the Planet admin pages, `/planetrss` and the
Planet background tasks (`RefreshRollerPlanetTask`, `SyncWebsitesTask`) do
diff --git
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryEdit.java
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryEdit.java
index 1d2f4e493..1c9ece2e8 100644
---
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryEdit.java
+++
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryEdit.java
@@ -80,6 +80,9 @@ public final class EntryEdit extends UIAction {
// the entry we are adding or editing
private WeblogEntry entry = null;
+ // set by myPrepare() when the user may not write the saved entry
+ private boolean writeDenied = false;
+
public EntryEdit() {
this.desiredMenu = "editor";
}
@@ -108,6 +111,13 @@ public final class EntryEdit extends UIAction {
WeblogEntryManager wmgr = WebloggerFactory.getWeblogger()
.getWeblogEntryManager();
setEntry(wmgr.getWeblogEntry(getActionWeblog(),
getBean().getId()));
+ // Checked here, not in the methods: when field validation
+ // fails, Struts returns INPUT without calling them, and the
+ // page shows the entry.
+ if (entry != null && !canWriteEntry()) {
+ writeDenied = true;
+ entry = null;
+ }
} catch (WebloggerException ex) {
log.error(
"Error looking up entry by id - " + getBean().getId(),
@@ -124,6 +134,9 @@ public final class EntryEdit extends UIAction {
@SkipValidation
@Override
public String execute() {
+ if (writeDenied) {
+ return DENIED;
+ }
if (getActionName().equals("entryEdit")) {
if (!requireEntry()) {
return ERROR;
@@ -152,6 +165,9 @@ public final class EntryEdit extends UIAction {
* @return String The result of the action.
*/
public String saveDraft() {
+ if (writeDenied) {
+ return DENIED;
+ }
if (!requireEntry()) {
return INPUT;
}
@@ -170,6 +186,9 @@ public final class EntryEdit extends UIAction {
* @return String The result of the action.
*/
public String publish() {
+ if (writeDenied) {
+ return DENIED;
+ }
if (!requireEntry()) {
return INPUT;
}
@@ -618,8 +637,24 @@ public final class EntryEdit extends UIAction {
return true;
}
+ /**
+ * The action lets LIMITED users in; a saved entry then decides what they
+ * may do with it.
+ */
+ private boolean canWriteEntry() {
+ try {
+ return entry.hasWritePermissions(getAuthenticatedUser());
+ } catch (WebloggerException ex) {
+ log.error("Error checking permissions on entry " +
getBean().getId(), ex);
+ return false;
+ }
+ }
+
@SkipValidation
public String firstSave() {
+ if (writeDenied) {
+ return DENIED;
+ }
if (!requireEntry()) {
return ERROR;
}
diff --git
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryRemove.java
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryRemove.java
index 25bb69edc..85471e030 100644
---
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryRemove.java
+++
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/EntryRemove.java
@@ -55,6 +55,7 @@ public class EntryRemove extends UIAction {
@Override
public void myPrepare() {
+ setRemoveEntry(null);
if (getRemoveId() != null) {
try {
WeblogEntryManager wmgr = WebloggerFactory.getWeblogger()
@@ -68,11 +69,18 @@ public class EntryRemove extends UIAction {
@Override
public String execute() {
+ if (!canRemoveEntry()) {
+ return DENIED;
+ }
return INPUT;
}
public String remove() {
+ if (!canRemoveEntry()) {
+ return DENIED;
+ }
+
if (getRemoveEntry() != null) {
try {
WeblogEntry entry = getRemoveEntry();
@@ -111,6 +119,18 @@ public class EntryRemove extends UIAction {
return INPUT;
}
+ private boolean canRemoveEntry() {
+ if (getRemoveEntry() == null) {
+ return true;
+ }
+ try {
+ return
getRemoveEntry().hasWritePermissions(getAuthenticatedUser());
+ } catch (WebloggerException ex) {
+ log.error("Error checking permissions on entry " + getRemoveId(),
ex);
+ return false;
+ }
+ }
+
public String getRemoveId() {
return removeId;
}
@@ -127,7 +147,7 @@ public class EntryRemove extends UIAction {
this.removeEntry = removeEntry;
}
- // allow LIMITED users to delete their own draft/pending blog entries
+ // lets LIMITED users in; canRemoveEntry() limits them to draft/pending
entries
@Override
public List<String> requiredWeblogPermissionActions() {
return Collections.singletonList(WeblogPermission.EDIT_DRAFT);
diff --git
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/editor/EntryWritePermissionTest.java
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/editor/EntryWritePermissionTest.java
new file mode 100644
index 000000000..a029dc771
--- /dev/null
+++
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/editor/EntryWritePermissionTest.java
@@ -0,0 +1,214 @@
+/*
+ * 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
+ *
+ * https://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.editor;
+
+import java.util.Collections;
+import java.util.Locale;
+
+import org.apache.roller.weblogger.business.UserManager;
+import org.apache.roller.weblogger.business.WeblogEntryManager;
+import org.apache.roller.weblogger.business.Weblogger;
+import org.apache.roller.weblogger.business.WebloggerFactory;
+import org.apache.roller.weblogger.business.search.IndexManager;
+import org.apache.roller.weblogger.pojos.User;
+import org.apache.roller.weblogger.pojos.Weblog;
+import org.apache.roller.weblogger.pojos.WeblogCategory;
+import org.apache.roller.weblogger.pojos.WeblogEntry;
+import org.apache.roller.weblogger.pojos.WeblogEntry.PubStatus;
+import org.apache.roller.weblogger.pojos.WeblogPermission;
+import org.apache.roller.weblogger.ui.struts2.util.UIAction;
+import org.apache.roller.weblogger.util.cache.CacheManager;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The entry actions admit a Limited member, so each one has to ask the entry
+ * whether that member may work on it.
+ */
+class EntryWritePermissionTest {
+
+ private MockedStatic<WebloggerFactory> factory;
+ private MockedStatic<CacheManager> cache;
+ private WeblogEntryManager entries;
+ private UserManager users;
+ private Weblog weblog;
+ private User user;
+
+ @BeforeEach
+ void setUp() throws Exception {
+ entries = mock(WeblogEntryManager.class);
+ users = mock(UserManager.class);
+ Weblogger weblogger = mock(Weblogger.class);
+ when(weblogger.getWeblogEntryManager()).thenReturn(entries);
+ when(weblogger.getUserManager()).thenReturn(users);
+ when(weblogger.getIndexManager()).thenReturn(mock(IndexManager.class));
+ factory = mockStatic(WebloggerFactory.class);
+ factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+ cache = mockStatic(CacheManager.class);
+
+ weblog = mock(Weblog.class);
+ user = mock(User.class);
+ when(user.getUserName()).thenReturn("member");
+ }
+
+ @AfterEach
+ void tearDown() {
+ cache.close();
+ factory.close();
+ }
+
+ @Test
+ void limitedMemberCannotRemoveALiveEntry() throws Exception {
+ memberHas(WeblogPermission.EDIT_DRAFT);
+ for (PubStatus status : new PubStatus[]{PubStatus.PUBLISHED,
PubStatus.SCHEDULED}) {
+ EntryRemove action = removeAction(entry(status));
+
+ assertEquals(UIAction.DENIED, action.execute());
+ assertEquals(UIAction.DENIED, action.remove());
+ }
+ verify(entries, never()).removeWeblogEntry(any());
+ }
+
+ @Test
+ void limitedMemberCanRemoveADraftOrPendingEntry() throws Exception {
+ memberHas(WeblogPermission.EDIT_DRAFT);
+ for (PubStatus status : new PubStatus[]{PubStatus.DRAFT,
PubStatus.PENDING}) {
+ assertEquals(UIAction.SUCCESS,
removeAction(entry(status)).remove());
+ }
+ verify(entries, times(2)).removeWeblogEntry(any());
+ }
+
+ @Test
+ void authorCanRemoveAPublishedEntry() throws Exception {
+ memberHas(WeblogPermission.POST);
+ WeblogEntry entry = entry(PubStatus.PUBLISHED);
+
+ assertEquals(UIAction.SUCCESS, removeAction(entry).remove());
+ verify(entries).removeWeblogEntry(entry);
+ }
+
+ @Test
+ void removeLooksTheEntryUpAgainWhateverWasPosted() throws Exception {
+ memberHas(WeblogPermission.EDIT_DRAFT);
+ EntryRemove action = action(new EntryRemove());
+ action.setRemoveEntry(entry(PubStatus.DRAFT));
+
+ action.myPrepare();
+
+ assertEquals(UIAction.ERROR, action.remove());
+ verify(entries, never()).removeWeblogEntry(any());
+ }
+
+ @Test
+ void limitedMemberCannotOpenOrSaveAPublishedEntry() throws Exception {
+ memberHas(WeblogPermission.EDIT_DRAFT);
+ WeblogEntry entry = entry(PubStatus.PUBLISHED);
+
+ assertEquals(UIAction.DENIED, editAction(entry).execute());
+ assertEquals(UIAction.DENIED, editAction(entry).firstSave());
+ assertEquals(UIAction.DENIED, editAction(entry).saveDraft());
+ assertEquals(UIAction.DENIED, editAction(entry).publish());
+
+ assertEquals(PubStatus.PUBLISHED, entry.getStatus());
+ verify(entries, never()).saveWeblogEntry(any());
+ }
+
+ @Test
+ void failedValidationShowsNoEntryToALimitedMember() throws Exception {
+ // Struts returns INPUT without calling saveDraft() or publish() when
+ // a field fails validation; the page then shows getEntry().
+ memberHas(WeblogPermission.EDIT_DRAFT);
+
+ assertNull(editAction(entry(PubStatus.PUBLISHED)).getEntry());
+ assertNull(editAction(entry(PubStatus.SCHEDULED)).getEntry());
+ }
+
+ @Test
+ void limitedMemberCanOpenADraft() throws Exception {
+ memberHas(WeblogPermission.EDIT_DRAFT);
+
+ assertEquals(UIAction.INPUT,
editAction(entry(PubStatus.DRAFT)).execute());
+ }
+
+ @Test
+ void authorCanOpenAPublishedEntry() throws Exception {
+ memberHas(WeblogPermission.POST);
+
+ assertEquals(UIAction.INPUT,
editAction(entry(PubStatus.PUBLISHED)).execute());
+ }
+
+ private void memberHas(String action) throws Exception {
+ WeblogPermission permission = new WeblogPermission(
+ weblog, user, Collections.singletonList(action));
+ when(users.getWeblogPermission(weblog, user)).thenReturn(permission);
+ }
+
+ private WeblogEntry entry(PubStatus status) throws Exception {
+ WeblogEntry entry = new WeblogEntry();
+ entry.setId("entry-1");
+ entry.setTitle("title");
+ entry.setWebsite(weblog);
+ entry.setStatus(status);
+ entry.setCategory(mock(WeblogCategory.class));
+ when(entries.getWeblogEntry(weblog, "entry-1")).thenReturn(entry);
+ return entry;
+ }
+
+ private EntryRemove removeAction(WeblogEntry entry) {
+ EntryRemove action = action(new EntryRemove());
+ action.setRemoveId(entry.getId());
+ action.myPrepare();
+ return action;
+ }
+
+ private EntryEdit editAction(WeblogEntry entry) {
+ EntryEdit action = action(new EntryEdit());
+ action.setActionName("entryEdit");
+ action.getBean().setId(entry.getId());
+ doReturn(Locale.ENGLISH).when(action).getLocale();
+ action.myPrepare();
+ return action;
+ }
+
+ private <T extends UIAction> T action(T instance) {
+ T action = spy(instance);
+ doAnswer(call ->
call.getArgument(0)).when(action).getText(anyString());
+ doAnswer(call ->
call.getArgument(0)).when(action).getText(anyString(), anyList());
+ doAnswer(call -> call.getArgument(0)).when(action)
+ .getText(anyString(), anyString(), anyString());
+ action.setActionWeblog(weblog);
+ action.setAuthenticatedUser(user);
+ return action;
+ }
+}