Added some convenience methods for creating AdSubmissionHandlers.

Author: rmcdouga

spring/fluentforms-spring-boot-autoconfigure/src/main/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmission.java

@@ -9,8 +9,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.regex.Pattern;
 
 import org.glassfish.jersey.client.ChunkedInput;
 import org.glassfish.jersey.client.ClientProperties;
@@ -267,6 +269,12 @@ private static byte[] transferFromAem(Response result, Logger logger) {
 	 * Implement this interface in order to provide code that will handle an Adaptive Form submission
 	 * 
 	 */
+	/**
+	 * 
+	 */
+	/**
+	 * 
+	 */
 	public interface AfSubmissionHandler {
 		/**
 		 * Object that contains the data submitted by the Adaptive Form
@@ -347,6 +355,125 @@ public record Redirect(URI redirectUrl) implements SubmitResponse {};
 		 * 		a SubmitResponse object that will be turned into an HTTP response to the submission.
 		 */
 		SubmitResponse processSubmission(Submission submission);
+		
+		/**
+		 * Creates an AfSubmissionHandler that handles form submissions from a specific form
+		 * 
+		 * @param formName
+		 * 		name of the form (so the form name under FormsAndDocuments)
+		 * @param handlerLogic
+		 * 		function that will be called when a form submission for occurs from that form
+		 * @return
+		 * 		an AfSubmissionHandler object
+		 */
+		public static AfSubmissionHandler canHandleFormNameEquals(String formName, Function<Submission, SubmitResponse> handlerLogic) {
+			Objects.requireNonNull(formName, "Form Name for submission handler cannot be null.");
+			return new AfSubmissionHandler() {
+
+				@Override
+				public boolean canHandle(String formNameIn) {
+					return formName.equals(formNameIn);
+				}
+
+				@Override
+				public SubmitResponse processSubmission(Submission submission) {
+					return handlerLogic.apply(submission);
+				}
+			};
+		}
+		
+		/**
+		 * Creates an AfSubmissionHandler that handles form submissions from one or more specific forms
+		 * 
+		 * @param handlerLogic
+		 * 		function that will be called when a form submission for occurs from that form
+		 * @param formNames
+		 * 		one or more form names (can be zero, but then this handler will never be called)
+		 * @return
+		 * 		an AfSubmissionHandler object
+		 */
+		public static AfSubmissionHandler canHandleFormNameAnyOf(Function<Submission, SubmitResponse> handlerLogic, String... formNames) {
+			if (formNames.length < 1) {
+				logger.atWarn().log("No form names were supplied, so this handler will never be called.");
+			}
+			return new AfSubmissionHandler() {
+
+				@Override
+				public boolean canHandle(String formNameIn) {
+					for (String formName : formNames) {
+						if (Objects.equals(formName, formNameIn)) {
+							return true;
+						}
+					}
+					return false;
+				}
+
+				@Override
+				public SubmitResponse processSubmission(Submission submission) {
+					return handlerLogic.apply(submission);
+				}
+			};
+		}
+		
+		/**
+		 * Creates an AfSubmissionHandler that handles form submissions from one or more specific forms
+		 * 
+		 * @param formNames
+		 * 		list of one or more form names (can be empty, but then this handler will never be called)
+		 * @param handlerLogic
+		 * 		function that will be called when a form submission for occurs from that form
+		 * @return
+		 * 		an AfSubmissionHandler object
+		 */
+		public static AfSubmissionHandler canHandleFormNameAnyOf(List<String> formNames, Function<Submission, SubmitResponse> handlerLogic) {
+			if (formNames.size() < 1) {
+				logger.atWarn().log("No form names were supplied, so this handler will never be called.");
+			}
+			return new AfSubmissionHandler() {
+
+				@Override
+				public boolean canHandle(String formNameIn) {
+					for (String formName : formNames) {
+						if (Objects.equals(formName, formNameIn)) {
+							return true;
+						}
+					}
+					return false;
+				}
+
+				@Override
+				public SubmitResponse processSubmission(Submission submission) {
+					return handlerLogic.apply(submission);
+				}
+			};
+		}
+		
+ 		/**
+		 * Creates an AfSubmissionHandler that handles form submissions from one or more specific forms
+		 * 
+ 		 * @param formNameRegEx
+		 * 		a regex that will be applied to the name of the form, if it matches, then the handler will apply
+ 		 * @param handlerLogic
+		 * 		function that will be called when a form submission for occurs from that form
+ 		 * @return
+		 * 		an AfSubmissionHandler object
+ 		 */
+ 		public static AfSubmissionHandler canHandleFormNameMatchesRegex(String formNameRegEx, Function<Submission, SubmitResponse> handlerLogic) {
+			final var pattern = Pattern.compile(Objects.requireNonNull(formNameRegEx, "Form Name RegEx for submission handler cannot be null."));
+
+			return new AfSubmissionHandler() {
+
+				@Override
+				public boolean canHandle(String formNameIn) {
+					return pattern.matcher(formNameIn).matches();
+				}
+
+				@Override
+				public SubmitResponse processSubmission(Submission submission) {
+					return handlerLogic.apply(submission);
+				}
+			};
+		}
 	}
 
 	/**

spring/fluentforms-spring-boot-autoconfigure/src/test/java/com/_4point/aem/fluentforms/spring/AemProxyAfSubmissionTest.java

@@ -2,22 +2,26 @@
 
 import static com._4point.aem.fluentforms.spring.AemProxyAfSubmissionTest.TestApplication.JerseyConfig;
 import static com._4point.testing.matchers.jaxrs.ResponseMatchers.*;
+import static com._4point.testing.matchers.javalang.ExceptionMatchers.*;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.*;
 import static org.junit.jupiter.api.Assertions.*;
 
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 import java.util.function.Function;
 
 import org.glassfish.jersey.client.ClientProperties;
 import org.glassfish.jersey.media.multipart.FormDataMultiPart;
 import org.glassfish.jersey.media.multipart.MultiPartFeature;
 import org.glassfish.jersey.server.ResourceConfig;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.EnumSource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -329,12 +333,90 @@ private TestScenario(String expectedContentType, Function<String, SubmitResponse
 
 		@ParameterizedTest
 		@EnumSource
-		void testText(TestScenario scenario) {
+		void testResponseCreationMethod(TestScenario scenario) {
 			var result = scenario.methodUnderTest.apply(SAMPLE_TEXT);
 			assertAll(
 					()->assertArrayEquals(SAMPLE_TEXT_BYTES, result.responseBytes()),
 					()->assertEquals(scenario.expectedContentType, result.mediaType())
 					);
 		}
 	}
+	
+	public static class AfSubmissionHandlerTests {
+		// In this class we test the static convenience methods that generate AfSubmissionHandlers.  Since the 
+		// processSubmission logic is one line (and trivial) we don't test it, however we do test the canHandle()
+		// method generated by the convenience method.
+		
+		@ParameterizedTest
+		@CsvSource({
+				"formName, true",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameEquals(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameEquals("formName", t->null);
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+		
+		@DisplayName("Passing in null should produce a null pointer exception")
+		@Test
+		void testcanHandleFormNameEquals_Null() {
+			NullPointerException ex = assertThrows(NullPointerException.class, ()->AfSubmissionHandler.canHandleFormNameEquals(null, t->null));
+			assertThat(ex, exceptionMsgContainsAll("Form Name for submission handler cannot be null"));
+		}
+		
+		@ParameterizedTest
+		@CsvSource({
+				"formName1, true",
+				"formName2, true",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameAnyOf(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(t->null, "formName1", "formName2");
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+
+		@ParameterizedTest
+		@CsvSource({
+				"formName1, false",
+				"formName2, false",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameAnyOf_NoNames(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(t->null);
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+		
+		@ParameterizedTest
+		@CsvSource({
+				"formName1, true",
+				"formName2, true",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameAnyOf_List(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(List.of("formName1", "formName2"), t->null);
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+
+		@ParameterizedTest
+		@CsvSource({
+				"formName1, false",
+				"formName2, false",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameAnyOf__List_NoNames(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameAnyOf(List.of(), t->null);
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+		
+		@ParameterizedTest
+		@CsvSource({
+				"formName1, true",
+				"formName2, true",
+				"notFormName, false"
+				})
+		void testcanHandleFormNameMatchesRegEx(String formNameIn, boolean expectedResult) {
+			var underTest = AfSubmissionHandler.canHandleFormNameMatchesRegex("formName.*", t->null);
+			assertEquals(expectedResult, underTest.canHandle(formNameIn));
+		}
+	}
 }