Merge pull request #81 from prime-framework/degroff/add_default_result

Support a default result mapping on a base action

Author: robotdan

src/main/java/org/primeframework/mvc/action/result/AbstractForwardResult.java

@@ -153,8 +153,8 @@ private String buildFullyQualifiedPath(ActionInvocation actionInvocation, U forw
   private String locateDefault(ActionInvocation actionInvocation, U forward) {
     String page = resourceLocator.locate(configuration.templateDirectory());
     if (page == null) {
-      throw new PrimeException("Missing result for action class [" + actionInvocation.configuration.actionClass + "] URI [" +
-          actionInvocation.uri() + "] and result code [" + getCode(forward) + "]");
+      throw new PrimeException("Missing result for action class [" + actionInvocation.configuration.actionClass.getName() + "] URI [" +
+                               actionInvocation.uri() + "] and result code [" + getCode(forward) + "]");
     }
     return page;
   }

src/main/java/org/primeframework/mvc/action/result/DefaultResultInvocationWorkflow.java

@@ -17,11 +17,14 @@
 
 import java.io.IOException;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.util.List;
 import java.util.Map;
 
 import com.google.inject.Inject;
+import org.primeframework.mvc.PrimeException;
 import org.primeframework.mvc.action.ActionInvocation;
 import org.primeframework.mvc.action.ActionInvocationStore;
 import org.primeframework.mvc.action.result.ForwardResult.ForwardImpl;
@@ -93,14 +96,42 @@ public void perform(WorkflowChain chain) throws IOException {
         annotation = actionInvocation.configuration.resultConfigurations.get(resultCode);
       }
 
+      // If the current action has not provided a resultCode mapping, in order, resolve a default result.
+      //  Using:
+      //  1. the bound defaultResultMappings
+      //  2. the action defined a '*' mapping which should be used as a default.
+      //  3. the fail-safe ForwardImpl.
+
       if (annotation == null) {
         var defaultMapping = defaultResultMappings.get(resultCode);
         if (defaultMapping != null) {
           annotation = defaultMapping.getAnnotation(resultCode);
         }
 
         if (annotation == null) {
-          annotation = new ForwardImpl("", resultCode);
+          if (actionInvocation.action != null) {
+            // Note that if an action exists, a configuration exists, so we should not need to check for null on configuration.
+            annotation = actionInvocation.configuration.resultConfigurations.get("*");
+            if (annotation != null) {
+              // Proxying the annotation will allow us to return the actual result code instead of '*' when the code() method is invoked.
+              // - The primary reason for this is debug. See AbstractForwardResult. But any result handler could decide to use this
+              //   resultCode in theory for debug or other purposes. This proxy allows us to override the code() method.
+              annotation = newProxyInstance(annotation, resultCode);
+              logger.debug("Missing result annotation for action class [{}] URI [{}] for result code [{}]. A default mapping of [@{}] was configured using the [*] result code. " +
+                           "This is not an error. This message is provided in case you do wish to define an explicit mapping.",
+                           actionInvocation.configuration.actionClass.getName(), actionInvocation.uri(), resultCode, annotation.annotationType().getSimpleName());
+            }
+          }
+
+          if (annotation == null) {
+            annotation = new ForwardImpl("", resultCode);
+            // Only debug log this if there was an action that could have declared the result mapping.
+            if (actionInvocation.action != null) {
+              logger.debug("Missing result annotation for action class [{}] URI [{}] for result code [{}]. The default mapping of [@{}] was used. " +
+                           "This is not an error. This message is provided in case you do wish to define an explicit mapping.",
+                           actionInvocation.configuration.actionClass.getName(), actionInvocation.uri(), resultCode, annotation.annotationType().getSimpleName());
+            }
+          }
         }
       }
 
@@ -113,6 +144,7 @@ public void perform(WorkflowChain chain) throws IOException {
       }
 
       long start = System.currentTimeMillis();
+      @SuppressWarnings("rawtypes")
       Result result = factory.build(annotation.annotationType());
       boolean handled = result.execute(annotation);
 
@@ -131,6 +163,7 @@ private void handleContinueOrRedirect(WorkflowChain chain) throws IOException {
     String uri = resourceLocator.locateIndex(configuration.templateDirectory());
     if (uri != null) {
       Annotation annotation = new RedirectImpl(uri, "success", true, false);
+      @SuppressWarnings("rawtypes")
       Result redirectResult = factory.build(annotation.annotationType());
       redirectResult.execute(annotation);
       return;
@@ -140,4 +173,39 @@ private void handleContinueOrRedirect(WorkflowChain chain) throws IOException {
     // In either case, this should be a 404 so we will let the Prime MVC workflow at the top level handle that
     chain.continueWorkflow();
   }
+
+  private Annotation newProxyInstance(Annotation annotation, String resultCode) {
+    try {
+      // Note that the annotation object here is already a proxy. Asking this object for getClass() will not return the correct class.
+      Class<?> annotationType = annotation.annotationType();
+      return (Annotation) Proxy.newProxyInstance(
+          annotationType.getClassLoader(),
+          new Class[]{annotationType},
+          new AnnotationInvocationHandler(annotation, resultCode));
+    } catch (Exception e) {
+      throw new PrimeException("Unable to proxy the default result code [*]. This is unexpected.", e);
+    }
+  }
+
+  public static class AnnotationInvocationHandler implements InvocationHandler {
+    private final Annotation annotation;
+
+    private final String resultCode;
+
+    public AnnotationInvocationHandler(Annotation annotation, String resultCode) {
+      this.annotation = annotation;
+      this.resultCode = resultCode;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      // The purpose of this proxy handler is to be able to modify the return value for "code" which is the result code.
+      if (method.getName().equals("code")) {
+        return resultCode;
+      }
+
+      // For all other methods, defer to the actual annotation
+      return method.invoke(annotation, args);
+    }
+  }
 }

src/test/java/org/example/action/DefaultForwardResultAction.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Inversoft Inc., All Rights Reserved
+ * Copyright (c) 2015-2025, Inversoft Inc., All Rights Reserved
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,8 +24,9 @@
 @Action
 @Forward
 public class DefaultForwardResultAction {
+  public String resultCode = "success";
 
   public String get() {
-    return "success";
+    return resultCode;
   }
 }

src/test/java/org/example/action/RequestedDefaultForwardResultAction.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025, Inversoft Inc., All Rights Reserved
+ *
+ * Licensed 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.example.action;
+
+import org.primeframework.mvc.action.annotation.Action;
+import org.primeframework.mvc.action.result.annotation.Forward;
+
+/**
+ * @author Daniel DeGroff
+ */
+@Action
+@Forward.List({
+    @Forward,
+    @Forward(code = "*", status = 201),
+})
+public class RequestedDefaultForwardResultAction {
+  public String resultCode = "success";
+
+  public String get() {
+    return resultCode;
+  }
+}

src/test/java/org/example/action/RequestedDefaultForwardResultNoTemplateAction.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025, Inversoft Inc., All Rights Reserved
+ *
+ * Licensed 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.example.action;
+
+import org.primeframework.mvc.action.annotation.Action;
+import org.primeframework.mvc.action.result.annotation.Forward;
+
+/**
+ * @author Daniel DeGroff
+ */
+@Action
+@Forward.List({
+    @Forward,
+    @Forward(code = "*", status = 201),
+})
+public class RequestedDefaultForwardResultNoTemplateAction {
+  public String resultCode = "success";
+
+  public String get() {
+    return resultCode;
+  }
+}

src/test/java/org/example/action/RequestedDefaultStatusResultAction.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025, Inversoft Inc., All Rights Reserved
+ *
+ * Licensed 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.example.action;
+
+import org.primeframework.mvc.action.annotation.Action;
+import org.primeframework.mvc.action.result.annotation.Status;
+
+/**
+ * @author Daniel DeGroff
+ */
+@Action
+@Status.List({
+    @Status,
+    @Status(code = "*", status = 201),
+})
+public class RequestedDefaultStatusResultAction {
+  public String resultCode = "success";
+
+  public String get() {
+    return resultCode;
+  }
+}

src/test/java/org/primeframework/mvc/GlobalTest.java

@@ -436,6 +436,71 @@ public void get_collectionConverter() throws Exception {
                                  .assertBodyContains("<input type=\"text\" id=\"strings\" name=\"strings\" value=\"foo,bar,baz\"/"));
   }
 
+  @Test
+  public void get_default_results() {
+    // Take default of 'success' See DefaultForwardResultAction
+    simulator.test("/default-forward-result")
+             .get()
+             .assertStatusCode(200)
+             .assertBody("""
+                             Default Forward""");
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // Unknown result code, still a 200 using ForwardImpl because this is the default in DefaultResultInvocationWorkflow
+    simulator.test("/default-forward-result")
+             .withURLParameter("resultCode", "foo")
+             .get()
+             .assertStatusCode(200)
+             .assertBody("""
+                             Default Forward""");
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // Take default of 'success' See RequestedDefaultForwardResultAction
+    simulator.test("/requested-default-status-result")
+             .get()
+             .assertStatusCode(200)
+             .assertBodyIsEmpty();
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // Unknown result code, this should use the default mapping of '*' which results in a 201
+    simulator.test("/requested-default-status-result")
+             .withURLParameter("resultCode", "foo")
+             .get()
+             .assertStatusCode(201)
+             .assertBodyIsEmpty();
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // Ensure the normal mapping works, expecting an .ftl per the forward result
+    simulator.test("/requested-default-forward-result")
+             .get()
+             .assertStatusCode(200)
+             .assertBody("""
+                             Hi!
+                             """);
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // Unknown result code of 'foo', this should use the default mapping of '*' which results in a 201
+    simulator.test("/requested-default-forward-result")
+             .withURLParameter("resultCode", "foo")
+             .get()
+             .assertStatusCode(201)
+             .assertBody("""
+                             Hi!
+                             """);
+    TestUnhandledExceptionHandler.assertNoUnhandledException();
+
+    // No template, so expect an exception. Ensure the exception has the correct result code.
+    simulator.test("/requested-default-forward-result-no-template")
+             .withURLParameter("resultCode", "foo")
+             .get()
+             // 500 because the template is missing
+             .assertStatusCode(500);
+
+    // Ensure the exception contains the invalid result code of 'foo' and not '*' which is found in the default mapping.
+    TestUnhandledExceptionHandler.assertLastUnhandledException(new PrimeException(
+        "Missing result for action class [org.example.action.RequestedDefaultForwardResultNoTemplateAction] URI [/requested-default-forward-result-no-template] and result code [foo]"));
+  }
+
   @Test
   public void get_developmentExceptions() {
     // Bad annotation @Action("{id}") it should be @Action("{uuid}")

src/test/web/templates/requested-default-forward-result.ftl

@@ -0,0 +1,2 @@
+[#ftl/]
+Hi!