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;
+    }
+}

Reply via email to