v1.0.4 pom

pom.xml

@@ -5,7 +5,7 @@
 	
 	<groupId>com.inteligr8.alfresco</groupId>
 	<artifactId>annotations-platform-module</artifactId>
-	<version>1.0.2</version>
+	<version>1.0.4</version>
 	<packaging>jar</packaging>
 	
 	<name>Annotations ACS Platform Module</name>
@@ -75,6 +75,18 @@
 			<version>1.0.1</version>
 			<type>amp</type>
 		</dependency>
+		<dependency>
+			<groupId>javax.transaction</groupId>
+			<artifactId>javax.transaction-api</artifactId>
+			<version>1.3</version>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>jakarta.transaction</groupId>
+			<artifactId>jakarta.transaction-api</artifactId>
+			<version>2.0.1</version>
+			<scope>provided</scope>
+		</dependency>
 		
 		<!-- AMP resources are included in the WAR, not the extension directory; this makes aspectjweaver available to javaagent -->
 		<dependency>

src/main/java/com/inteligr8/alfresco/annotations/TransactionalWrapper.java

@@ -1,113 +0,0 @@
-package com.inteligr8.alfresco.annotations;
-
-import java.lang.reflect.Method;
-
-import org.springframework.transaction.annotation.Isolation;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-
-public class TransactionalWrapper {
-	
-	private Transactional stxl = null;
-	private javax.transaction.Transactional jtxl = null;
-	
-	public TransactionalWrapper(Transactional txl) {
-		this.stxl = txl;
-	}
-	
-	public TransactionalWrapper(javax.transaction.Transactional txl) {
-		this.jtxl = txl;
-	}
-	
-	public static TransactionalWrapper wrap(Method method) {
-		Transactional stxl = method.getAnnotation(Transactional.class);
-		javax.transaction.Transactional jtxl = method.getAnnotation(javax.transaction.Transactional.class);
-		if (stxl == null && jtxl == null) {
-			return null;
-		} else if (stxl != null) {
-			return new TransactionalWrapper(stxl);
-		} else if (jtxl != null) {
-			return new TransactionalWrapper(jtxl);
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	public boolean isReadOnly() {
-		if (this.stxl != null) {
-			return this.stxl.readOnly();
-		} else if (this.jtxl != null) {
-			return false;
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	public Propagation getPropagation() {
-		if (this.stxl != null) {
-			return this.stxl.propagation();
-		} else if (this.jtxl != null) {
-			switch (this.jtxl.value()) {
-				case MANDATORY:
-					return Propagation.MANDATORY;
-				case REQUIRED:
-					return Propagation.REQUIRED;
-				case REQUIRES_NEW:
-					return Propagation.REQUIRES_NEW;
-				case SUPPORTS:
-					return Propagation.SUPPORTS;
-				case NOT_SUPPORTED:
-					return Propagation.NOT_SUPPORTED;
-				case NEVER:
-					return Propagation.NEVER;
-				default:
-					throw new IllegalStateException("This should never happen");
-			}
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	public Isolation getIsolation() {
-		if (this.stxl != null) {
-			return this.stxl.isolation();
-		} else if (this.jtxl != null) {
-			return Isolation.DEFAULT;
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	public int getTimeoutInSeconds() {
-		if (this.stxl != null) {
-			return this.stxl.timeout();
-		} else if (this.jtxl != null) {
-			return 0;
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	@SuppressWarnings("unchecked")
-	public Class<? extends Throwable>[] getRollbackFor() {
-		if (this.stxl != null) {
-			return this.stxl.rollbackFor();
-		} else if (this.jtxl != null) {
-			return this.jtxl.rollbackOn();
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-	
-	@SuppressWarnings("unchecked")
-	public Class<? extends Throwable>[] getNoRollbackFor() {
-		if (this.stxl != null) {
-			return this.stxl.noRollbackFor();
-		} else if (this.jtxl != null) {
-			return this.jtxl.dontRollbackOn();
-		} else {
-			throw new IllegalStateException("This should never happen");
-		}
-	}
-
-}

src/main/java/com/inteligr8/alfresco/annotations/aspect/RetryingTransactionAspect.java

@@ -1,5 +1,6 @@
 package com.inteligr8.alfresco.annotations.aspect;
 
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 
 import org.alfresco.repo.transaction.AlfrescoTransactionSupport;
@@ -17,9 +18,13 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.IllegalTransactionStateException;
+import org.springframework.transaction.annotation.Transactional;
 
 import com.inteligr8.alfresco.annotations.TransactionalRetryable;
-import com.inteligr8.alfresco.annotations.TransactionalWrapper;
+import com.inteligr8.alfresco.annotations.util.JakartaTransactionalAnnotationAdapter;
+import com.inteligr8.alfresco.annotations.util.JtaTransactionalAnnotationAdapter;
+import com.inteligr8.alfresco.annotations.util.SpringTransactionalAnnotationAdapter;
+import com.inteligr8.alfresco.annotations.util.TransactionalAnnotationAdapter;
 
 /**
  * This aspect implements the @Transactional and @TransactionalRetryable
@@ -54,16 +59,20 @@ public class RetryingTransactionAspect {
 	public void isJtaTransactionalAnnotated() {
 	}
 	
+	@Pointcut("@annotation(jakarta.transaction.Transactional) && execution(* *(..))")
+	public void isJakartaTransactionalAnnotated() {
+	}
+	
 	@Pointcut("@annotation(com.inteligr8.alfresco.annotations.TransactionalRetryable) && execution(* *(..))")
 	public void isTransactionalRetryableAnnotated() {
 	}
 	
-	@Around("isTransactionalAnnotated() || isJtaTransactionalAnnotated() || isTransactionalRetryableAnnotated()")
+	@Around("isTransactionalAnnotated() || isJtaTransactionalAnnotated() || isJakartaTransactionalAnnotated() || isTransactionalRetryableAnnotated()")
 	public Object retryingTransactional(ProceedingJoinPoint joinPoint) throws Throwable {
 		this.logger.trace("retryingTransactional({})", joinPoint);
 		
 		Method method = this.getMethod(joinPoint);
-		TransactionalWrapper txl = TransactionalWrapper.wrap(method);
+		TransactionalAnnotationAdapter txl = this.wrapTransactionalAnnotation(method);
 		TransactionalRetryable txtry = method.getAnnotation(TransactionalRetryable.class);
 		
 		if (this.doCreateNewTxContext(txl) || this.isReadStateChange(txl)) {
@@ -77,6 +86,33 @@ public class RetryingTransactionAspect {
 		}
 	}
 	
+	private TransactionalAnnotationAdapter wrapTransactionalAnnotation(Method method) {
+		Annotation txl = method.getAnnotation(Transactional.class);
+		if (txl != null)
+			return new SpringTransactionalAnnotationAdapter((Transactional) txl);
+		
+		txl = this.getOptionalAnnotation(method, "javax.transaction.Transactional");
+		if (txl != null)
+			return new JtaTransactionalAnnotationAdapter((javax.transaction.Transactional) txl);
+		
+		txl = this.getOptionalAnnotation(method, "jakarta.transaction.Transactional");
+		if (txl != null)
+			return new JakartaTransactionalAnnotationAdapter((jakarta.transaction.Transactional) txl);
+		
+		return null;
+	}
+	
+	private <A extends Annotation> A getOptionalAnnotation(Method method, String fullyQualifiedAnnotationName) {
+		try {
+			@SuppressWarnings("unchecked")
+			Class<A> annotationClass = (Class<A>) Class.forName(fullyQualifiedAnnotationName);
+			return method.getAnnotation(annotationClass);
+		} catch (ClassNotFoundException cnfe) {
+			this.logger.trace("The {} annotation is not available in the classpath; assuming not set", fullyQualifiedAnnotationName);
+			return null;
+		}
+	}
+	
 	private Method getMethod(ProceedingJoinPoint joinPoint) {
 		if (!(joinPoint.getSignature() instanceof MethodSignature))
 			throw new IllegalStateException("The @Transactional or @TransactionalRetryable annotations must be on methods");
@@ -85,7 +121,7 @@ public class RetryingTransactionAspect {
 		return methodSig.getMethod();
 	}
 	
-	private boolean isReadStateChange(TransactionalWrapper txl) {
+	private boolean isReadStateChange(TransactionalAnnotationAdapter txl) {
 		if (txl == null)
 			return false;
 		
@@ -114,7 +150,7 @@ public class RetryingTransactionAspect {
 		return txtry != null;
 	}
 	
-	private boolean doCreateNewTxContext(TransactionalWrapper txl) {
+	private boolean doCreateNewTxContext(TransactionalAnnotationAdapter txl) {
 		if (txl == null) {
 			return false;
 		} else switch (txl.getPropagation()) {
@@ -136,8 +172,14 @@ public class RetryingTransactionAspect {
 						if (txl.isReadOnly())
 							throw new IllegalTransactionStateException("A read/write transaction exists where a read-only one is mandatory");
 				}
+			case NOT_SUPPORTED:
+				switch (AlfrescoTransactionSupport.getTransactionReadState()) {
+					case TXN_NONE:
+						return false;
+					default:
+						throw new IllegalTransactionStateException("A transaction exists and pausing it is not supported");
+				}
 			case SUPPORTS:
-			//case NOT_SUPPORTED:  not supported; we would have to create another thread to simulate
 				return false;
 			case REQUIRED:
 				switch (AlfrescoTransactionSupport.getTransactionReadState()) {
@@ -153,7 +195,7 @@ public class RetryingTransactionAspect {
 		}
 	}
 	
-	private Object execute(final ProceedingJoinPoint joinPoint, TransactionalWrapper txl, TransactionalRetryable txtry) throws Throwable {
+	private Object execute(final ProceedingJoinPoint joinPoint, TransactionalAnnotationAdapter txl, TransactionalRetryable txtry) throws Throwable {
 		RetryingTransactionCallback<Object> rtcallback = new RetryingTransactionCallback<Object>() {
 			@Override
 			public Object execute() throws Throwable {

src/main/java/com/inteligr8/alfresco/annotations/service/impl/MqAsyncService.java

@@ -9,6 +9,15 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.Temporal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -479,7 +488,28 @@ public class MqAsyncService extends AbstractLifecycleBean implements AsyncServic
     	Class<?> paramType = param.getType();
 		this.logger.trace("Unmarshaling parameter of type: {}", paramType);
 
-		if (Version.class.isAssignableFrom(paramType)) {
+    	if (arg instanceof String || arg instanceof Number || arg instanceof Boolean) {
+			this.logger.trace("Unmarshaling primitive: {}", arg);
+			return arg;
+    	} else if (Temporal.class.isAssignableFrom(paramType)) {
+    		if (OffsetDateTime.class.isAssignableFrom(paramType)) {
+    			return OffsetDateTime.from(DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(arg.toString()));
+    		} else if (ZonedDateTime.class.isAssignableFrom(paramType)) {
+    			return ZonedDateTime.from(DateTimeFormatter.ISO_ZONED_DATE_TIME.parse(arg.toString()));
+    		} else if (LocalDate.class.isAssignableFrom(paramType)) {
+    			return LocalDate.from(DateTimeFormatter.ISO_LOCAL_DATE.parse(arg.toString()));
+    		} else if (LocalDateTime.class.isAssignableFrom(paramType)) {
+    			return LocalDateTime.from(DateTimeFormatter.ISO_LOCAL_DATE_TIME.parse(arg.toString()));
+    		} else if (Instant.class.isAssignableFrom(paramType)) {
+    			return Instant.from(DateTimeFormatter.ISO_INSTANT.parse(arg.toString()));
+    		} else if (LocalTime.class.isAssignableFrom(paramType)) {
+    			return LocalTime.from(DateTimeFormatter.ISO_LOCAL_TIME.parse(arg.toString()));
+    		} else if (OffsetTime.class.isAssignableFrom(paramType)) {
+    			return OffsetTime.from(DateTimeFormatter.ISO_OFFSET_TIME.parse(arg.toString()));
+    		} else {
+    			throw new UnsupportedOperationException();
+    		}
+    	} else if (Version.class.isAssignableFrom(paramType)) {
 			this.logger.trace("Unmarshaling as JSON object: {}", arg);
 			Map<String, Object> argMap = (Map<String, Object>) this.om.convertValue(arg, Map.class);
 			
@@ -515,13 +545,22 @@ public class MqAsyncService extends AbstractLifecycleBean implements AsyncServic
 			return cons.invoke(null, arg.toString());
 		} else {
 			this.logger.trace("Unmarshaling as POJO: {}", arg);
+			try {
 				Constructor<?> cons = paramType.getConstructor(String.class);
 				return cons.newInstance(arg.toString());
+			} catch (NoSuchMethodException nsme) {
+				Method method = paramType.getDeclaredMethod("valueOf", String.class);
+				return method.invoke(null, arg.toString());
+			}
 		}
     }
     
     private Object marshal(Object arg) {
-		if (arg instanceof Version) {
+    	if (arg instanceof String || arg instanceof Number || arg instanceof Boolean) {
+    		return arg;
+    	} else if (arg instanceof Temporal) {
+    		return arg.toString();
+    	} else if (arg instanceof Version) {
 			Version version = (Version) arg;
 			Map<String, Object> map = new HashMap<>();
 			map.put("nodeRef", version.getFrozenStateNodeRef());
@@ -555,7 +594,8 @@ public class MqAsyncService extends AbstractLifecycleBean implements AsyncServic
 			this.logger.trace("Marshaling Java Map as JSON object: {}", map);
 			return this.om.convertValue(map, String.class);
 		} else {
-			return arg;
+			this.logger.trace("Marshaling Java object as JSON object: {}", arg);
+			return this.om.convertValue(arg, String.class);
 		}
     }
     

src/main/java/com/inteligr8/alfresco/annotations/util/JakartaTransactionalAnnotationAdapter.java

@@ -0,0 +1,63 @@
+package com.inteligr8.alfresco.annotations.util;
+
+import jakarta.transaction.Transactional;
+
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+
+public class JakartaTransactionalAnnotationAdapter implements TransactionalAnnotationAdapter {
+	
+	private final Transactional txl;
+	
+	public JakartaTransactionalAnnotationAdapter(Transactional txl) {
+		this.txl = txl;
+	}
+
+	@Override
+	public boolean isReadOnly() {
+		return false;
+	}
+
+	@Override
+	public Propagation getPropagation() {
+		switch (this.txl.value()) {
+			case MANDATORY:
+				return Propagation.MANDATORY;
+			case REQUIRED:
+				return Propagation.REQUIRED;
+			case REQUIRES_NEW:
+				return Propagation.REQUIRES_NEW;
+			case SUPPORTS:
+				return Propagation.SUPPORTS;
+			case NOT_SUPPORTED:
+				return Propagation.NOT_SUPPORTED;
+			case NEVER:
+				return Propagation.NEVER;
+			default:
+				throw new IllegalStateException("This should never happen");
+		}
+	}
+
+	@Override
+	public Isolation getIsolation() {
+		return Isolation.DEFAULT;
+	}
+
+	@Override
+	public int getTimeoutInSeconds() {
+		return 0;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Class<? extends Throwable>[] getRollbackFor() {
+		return this.txl.rollbackOn();
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Class<? extends Throwable>[] getNoRollbackFor() {
+		return this.txl.dontRollbackOn();
+	}
+
+}

src/main/java/com/inteligr8/alfresco/annotations/util/JtaTransactionalAnnotationAdapter.java

@@ -0,0 +1,63 @@
+package com.inteligr8.alfresco.annotations.util;
+
+import javax.transaction.Transactional;
+
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+
+public class JtaTransactionalAnnotationAdapter implements TransactionalAnnotationAdapter {
+	
+	private final Transactional txl;
+	
+	public JtaTransactionalAnnotationAdapter(Transactional txl) {
+		this.txl = txl;
+	}
+
+	@Override
+	public boolean isReadOnly() {
+		return false;
+	}
+
+	@Override
+	public Propagation getPropagation() {
+		switch (this.txl.value()) {
+			case MANDATORY:
+				return Propagation.MANDATORY;
+			case REQUIRED:
+				return Propagation.REQUIRED;
+			case REQUIRES_NEW:
+				return Propagation.REQUIRES_NEW;
+			case SUPPORTS:
+				return Propagation.SUPPORTS;
+			case NOT_SUPPORTED:
+				return Propagation.NOT_SUPPORTED;
+			case NEVER:
+				return Propagation.NEVER;
+			default:
+				throw new IllegalStateException("This should never happen");
+		}
+	}
+
+	@Override
+	public Isolation getIsolation() {
+		return Isolation.DEFAULT;
+	}
+
+	@Override
+	public int getTimeoutInSeconds() {
+		return 0;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Class<? extends Throwable>[] getRollbackFor() {
+		return this.txl.rollbackOn();
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Class<? extends Throwable>[] getNoRollbackFor() {
+		return this.txl.dontRollbackOn();
+	}
+
+}

src/main/java/com/inteligr8/alfresco/annotations/util/MapUtils.java

@@ -0,0 +1,32 @@
+package com.inteligr8.alfresco.annotations.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.alfresco.util.Pair;
+
+public class MapUtils {
+	
+	public static <K, V> Map<K, V> build(Pair<K, V>... pairs) {
+		Map<K, V> map = new HashMap<>();
+		for (Pair<K, V> pair : pairs) {
+			map.put(pair.getFirst(), pair.getSecond());
+		}
+		
+		return map;
+	}
+	
+	public static Map<String, String> build(String... keyValuePairs) {
+		if (keyValuePairs.length % 2 == 1)
+			throw new IllegalArgumentException();
+		
+		Map<String, String> map = new HashMap<>();
+		for (int pair = 0; pair < keyValuePairs.length / 2; pair++) {
+			int base = pair * 2;
+			map.put(keyValuePairs[base], keyValuePairs[base + 1]);
+		}
+		
+		return map;
+	}
+
+}

src/main/java/com/inteligr8/alfresco/annotations/util/SpringTransactionalAnnotationAdapter.java

@@ -0,0 +1,45 @@
+package com.inteligr8.alfresco.annotations.util;
+
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+public class SpringTransactionalAnnotationAdapter implements TransactionalAnnotationAdapter {
+	
+	private final Transactional txl;
+	
+	public SpringTransactionalAnnotationAdapter(Transactional txl) {
+		this.txl = txl;
+	}
+
+	@Override
+	public boolean isReadOnly() {
+		return this.txl.readOnly();
+	}
+
+	@Override
+	public Propagation getPropagation() {
+		return this.txl.propagation();
+	}
+
+	@Override
+	public Isolation getIsolation() {
+		return this.txl.isolation();
+	}
+
+	@Override
+	public int getTimeoutInSeconds() {
+		return this.txl.timeout();
+	}
+
+	@Override
+	public Class<? extends Throwable>[] getRollbackFor() {
+		return this.txl.rollbackFor();
+	}
+
+	@Override
+	public Class<? extends Throwable>[] getNoRollbackFor() {
+		return this.txl.noRollbackFor();
+	}
+
+}

src/main/java/com/inteligr8/alfresco/annotations/util/TransactionalAnnotationAdapter.java

@@ -0,0 +1,20 @@
+package com.inteligr8.alfresco.annotations.util;
+
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+
+public interface TransactionalAnnotationAdapter {
+	
+	boolean isReadOnly();
+	
+	Propagation getPropagation();
+	
+	Isolation getIsolation();
+	
+	int getTimeoutInSeconds();
+	
+	Class<? extends Throwable>[] getRollbackFor();
+	
+	Class<? extends Throwable>[] getNoRollbackFor();
+
+}