Merge branch 'develop'

Author: Gerald Unterrainer

Diff for: pom.xml

@@ -17,15 +17,15 @@
 
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>http-server</artifactId>
-	<version>0.2.9</version>
+	<version>0.2.10</version>
 	<name>HttpServer</name>
 	<packaging>jar</packaging>
 
 	<dependencies>
 		<dependency>
 			<groupId>info.unterrainer.commons</groupId>
 			<artifactId>jre-utils</artifactId>
-			<version>0.1.9</version>
+			<version>0.1.10</version>
 		</dependency>
 		<dependency>
 			<groupId>info.unterrainer.commons</groupId>

Diff for: src/main/java/info/unterrainer/commons/httpserver/GenericHandlerGroup.java

@@ -7,9 +7,8 @@
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 
-import info.unterrainer.commons.httpserver.daos.BasicDao;
+import info.unterrainer.commons.httpserver.daos.CoreDao;
 import info.unterrainer.commons.httpserver.daos.DaoTransaction;
-import info.unterrainer.commons.httpserver.daos.DaoTransactionManager;
 import info.unterrainer.commons.httpserver.enums.Attribute;
 import info.unterrainer.commons.httpserver.enums.Endpoint;
 import info.unterrainer.commons.httpserver.enums.QueryField;
@@ -33,10 +32,9 @@
 @RequiredArgsConstructor(access = AccessLevel.PACKAGE)
 public class GenericHandlerGroup<P extends BasicJpa, J extends BasicJson, E> implements HandlerGroup {
 
-	private final BasicDao<P, E> dao;
+	private final CoreDao<P, E> dao;
 	private final Class<P> jpaType;
 	private final Class<J> jsonType;
-	private final DaoTransactionManager<E> daoTransactionManager;
 	private final JsonMapper jsonMapper;
 	private final MapperFacade orikaMapper;
 	private final String path;
@@ -47,7 +45,7 @@ public class GenericHandlerGroup<P extends BasicJpa, J extends BasicJson, E> imp
 	private final ExecutorService executorService;
 	private final HandlerUtils hu = new HandlerUtils();
 	private final String tenantIdRowName;
-	private final BasicDao<? extends BasicJpa, E> tenantDao;
+	private final CoreDao<? extends BasicJpa, E> tenantDao;
 	private final Class<? extends BasicJpa> tenantJpaType;
 	private final String fieldRowName;
 	private final String tenantRowName;
@@ -97,7 +95,7 @@ private Role[] rolesFor(final List<Endpoint> endpointList) {
 	}
 
 	private void getEntry(final Context ctx) {
-		DaoTransaction<E> transaction = daoTransactionManager.beginTransaction();
+		DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
 
 		P jpa = hu.getJpaById(ctx, transaction.getManager(), dao);
 		J json = orikaMapper.map(jpa, jsonType);
@@ -130,7 +128,7 @@ private void getList(final Context ctx) {
 						e.getMessage());
 			}
 
-		DaoTransaction<E> transaction = daoTransactionManager.beginTransaction();
+		DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
 
 		ListJson<P> bList = dao.getList(transaction.getManager(), offset, size, interceptorResult.getSelectClause(),
 				interceptorResult.getJoinClause(), interceptorResult.getWhereClause(), interceptorResult.getParams(),
@@ -152,7 +150,7 @@ private void create(final Context ctx) throws IOException {
 		try {
 			J json = jsonMapper.fromStringTo(jsonType, b);
 			P mappedJpa = orikaMapper.map(json, jpaType);
-			DaoTransaction<E> transaction = daoTransactionManager.beginTransaction();
+			DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
 
 			mappedJpa = extensions.runPreInsert(ctx, transaction.getManager(), json, mappedJpa, executorService);
 			P createdJpa = dao.create(transaction.getManager(), mappedJpa);
@@ -170,38 +168,39 @@ private void create(final Context ctx) throws IOException {
 	}
 
 	private void fullUpdate(final Context ctx) throws IOException {
-		P jpa = hu.getJpaById(ctx, dao);
+		DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
+		P jpa = hu.getJpaById(ctx, transaction.getManager(), dao);
 		try {
 			J json = jsonMapper.fromStringTo(jsonType, ctx.body());
 			P mappedJpa = orikaMapper.map(json, jpaType);
 			mappedJpa.setId(jpa.getId());
 			mappedJpa.setCreatedOn(jpa.getCreatedOn());
 			mappedJpa.setEditedOn(jpa.getEditedOn());
-			DaoTransaction<E> transaction = daoTransactionManager.beginTransaction();
 
 			mappedJpa = extensions.runPreModify(ctx, transaction.getManager(), jpa.getId(), json, jpa, mappedJpa,
 					executorService);
-			P persistedJpa = dao.update(mappedJpa);
+			P persistedJpa = dao.update(transaction.getManager(), mappedJpa);
 
 			J r = orikaMapper.map(persistedJpa, jsonType);
 			r = extensions.runPostModify(ctx, transaction.getManager(), jpa.getId(), json, jpa, mappedJpa, persistedJpa,
 					r, executorService);
 
-			transaction.end();
 			ctx.attribute(Attribute.RESPONSE_OBJECT, r);
 
 		} catch (JsonProcessingException | JsonMappingException e) {
 			throw new BadRequestException();
+		} finally {
+			transaction.end();
 		}
 	}
 
 	private void delete(final Context ctx) {
 		ctx.attribute(Attribute.RESPONSE_OBJECT, null);
 		Long id = hu.checkAndGetId(ctx);
-		DaoTransaction<E> transaction = daoTransactionManager.beginTransaction();
+		DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
 
 		id = extensions.runPreDelete(ctx, transaction.getManager(), id, executorService);
-		dao.delete(id);
+		dao.delete(transaction.getManager(), id);
 		ctx.status(204);
 		extensions.runPostDelete(ctx, transaction.getManager(), id, executorService);
 

Diff for: src/main/java/info/unterrainer/commons/httpserver/GenericHandlerGroupBuilder.java

@@ -6,8 +6,7 @@
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 
-import info.unterrainer.commons.httpserver.daos.BasicDao;
-import info.unterrainer.commons.httpserver.daos.DaoTransactionManager;
+import info.unterrainer.commons.httpserver.daos.CoreDao;
 import info.unterrainer.commons.httpserver.daos.ParamMap;
 import info.unterrainer.commons.httpserver.enums.Endpoint;
 import info.unterrainer.commons.httpserver.interceptors.InterceptorData;
@@ -28,10 +27,9 @@
 public class GenericHandlerGroupBuilder<P extends BasicJpa, J extends BasicJson, E> {
 
 	private final HttpServer server;
-	private BasicDao<P, E> dao;
 	private final Class<P> jpaType;
 	private final Class<J> jsonType;
-	private final DaoTransactionManager<E> daoTransactionManager;
+	private final CoreDao<P, E> dao;
 	private JsonMapper jsonMapper;
 	private MapperFactory orikaFactory;
 	private String path;
@@ -42,7 +40,7 @@ public class GenericHandlerGroupBuilder<P extends BasicJpa, J extends BasicJson,
 	private String tenantIdRowName;
 	private String tenantRowName;
 	private String tenantFieldRowName;
-	private BasicDao<? extends BasicJpa, E> tenantDao;
+	private CoreDao<? extends BasicJpa, E> tenantDao;
 	private Class<? extends BasicJpa> tenantJpaType;
 
 	HandlerExtensions<P, J, E> extensions = new HandlerExtensions<>();
@@ -56,8 +54,8 @@ public HttpServer add() {
 		if (executorService == null)
 			executorService = server.executorService;
 		GenericHandlerGroup<P, J, E> handlerGroupInstance = new GenericHandlerGroup<>(dao, jpaType, jsonType,
-				daoTransactionManager, jsonMapper, orikaFactory.getMapperFacade(), path, endpoints, getListInterceptors,
-				extensions, accessRoles, executorService, tenantIdRowName, tenantDao, tenantJpaType, tenantFieldRowName,
+				jsonMapper, orikaFactory.getMapperFacade(), path, endpoints, getListInterceptors, extensions,
+				accessRoles, executorService, tenantIdRowName, tenantDao, tenantJpaType, tenantFieldRowName,
 				tenantRowName);
 		server.addHandlerGroup(handlerGroupInstance);
 		return server;
@@ -78,7 +76,7 @@ public GenericHandlerGroupBuilder<P, J, E> isMultiTenantEnabledByIdRow(final Str
 	}
 
 	public <TP extends BasicJpa> GenericHandlerGroupBuilder<P, J, E> isMultiTenantEnabledByTable(
-			final BasicDao<TP, E> tenantDao, final Class<TP> tenantJpaType, final String fieldRowName,
+			final CoreDao<TP, E> tenantDao, final Class<TP> tenantJpaType, final String fieldRowName,
 			final String tenantRowName) {
 		this.tenantDao = tenantDao;
 		this.tenantJpaType = tenantJpaType;
@@ -87,11 +85,6 @@ public <TP extends BasicJpa> GenericHandlerGroupBuilder<P, J, E> isMultiTenantEn
 		return this;
 	}
 
-	public GenericHandlerGroupBuilder<P, J, E> dao(final BasicDao<P, E> dao) {
-		this.dao = dao;
-		return this;
-	}
-
 	public GenericHandlerGroupBuilder<P, J, E> jsonMapper(final JsonMapper jsonMapper) {
 		this.jsonMapper = jsonMapper;
 		return this;

Diff for: src/main/java/info/unterrainer/commons/httpserver/HandlerUtils.java

@@ -4,7 +4,8 @@
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 
-import info.unterrainer.commons.httpserver.daos.BasicDao;
+import info.unterrainer.commons.httpserver.daos.CoreDao;
+import info.unterrainer.commons.httpserver.daos.DaoTransaction;
 import info.unterrainer.commons.httpserver.enums.QueryField;
 import info.unterrainer.commons.httpserver.exceptions.BadRequestException;
 import info.unterrainer.commons.httpserver.exceptions.NotFoundException;
@@ -19,20 +20,25 @@ public Long checkAndGetId(final Context ctx) {
 		return convertToLong(s);
 	}
 
-	public <P extends BasicJpa, E> P getJpaById(final Context ctx, final E entityManager, final BasicDao<P, E> dao) {
+	public <P extends BasicJpa, E> P getJpaById(final Context ctx, final E manager, final CoreDao<P, E> dao) {
 		Long id = checkAndGetId(ctx);
-		P jpa = dao.getById(entityManager, id);
+		P jpa = dao.getById(manager, id);
 		if (jpa == null)
 			throw new NotFoundException();
 		return jpa;
 	}
 
-	public <P extends BasicJpa, E> P getJpaById(final Context ctx, final BasicDao<P, E> dao) {
+	public <P extends BasicJpa, E> P getJpaById(final Context ctx, final CoreDao<P, E> dao) {
 		Long id = checkAndGetId(ctx);
-		P jpa = dao.getById(id);
-		if (jpa == null)
-			throw new NotFoundException();
-		return jpa;
+		DaoTransaction<E> transaction = dao.getTransactionManager().beginTransaction();
+		try {
+			P jpa = dao.getById(transaction.getManager(), id);
+			if (jpa == null)
+				throw new NotFoundException();
+			return jpa;
+		} finally {
+			transaction.end();
+		}
 	}
 
 	public <J> void setPaginationParamsFor(final ListJson<J> jList, final long offset, final long pageSize,

Diff for: src/main/java/info/unterrainer/commons/httpserver/HttpServer.java

@@ -16,7 +16,7 @@
 import org.eclipse.jetty.server.ServerConnector;
 
 import info.unterrainer.commons.httpserver.accessmanager.HttpAccessManager;
-import info.unterrainer.commons.httpserver.daos.DaoTransactionManager;
+import info.unterrainer.commons.httpserver.daos.CoreDaoProvider;
 import info.unterrainer.commons.httpserver.enums.Attribute;
 import info.unterrainer.commons.httpserver.enums.ResponseType;
 import info.unterrainer.commons.httpserver.exceptions.HttpException;
@@ -98,8 +98,8 @@ public void addHandlerGroup(final HandlerGroup group) {
 	}
 
 	public <P extends BasicJpa, J extends BasicJson, E> GenericHandlerGroupBuilder<P, J, E> handlerGroupFor(
-			final Class<P> jpaType, final Class<J> jsonType, final DaoTransactionManager<E> daoTransactionManager) {
-		return new GenericHandlerGroupBuilder<>(this, jpaType, jsonType, daoTransactionManager);
+			final Class<P> jpaType, final Class<J> jsonType, final CoreDaoProvider<P, E> coreDaoProvider) {
+		return new GenericHandlerGroupBuilder<>(this, jpaType, jsonType, coreDaoProvider.getCoreDao());
 	}
 
 	private void create() {

Diff for: src/main/java/info/unterrainer/commons/httpserver/Information.java

@@ -0,0 +1,102 @@
+package info.unterrainer.commons.httpserver.daos;
+
+import javax.persistence.EntityManagerFactory;
+
+import info.unterrainer.commons.rdbutils.entities.BasicAsyncJpa;
+
+public class AsyncJpqlDao<P extends BasicAsyncJpa> extends BasicJpqlDao<P> {
+
+	/**
+	 * Generates a DAO that lets you build and execute queries.
+	 *
+	 * @param emf  the {@link EntityManagerFactory} to use
+	 * @param type the return-type of the query (the underlying JPA)
+	 */
+	public AsyncJpqlDao(final EntityManagerFactory emf, final Class<P> type) {
+		super(emf, type);
+	}
+
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the underlying generic
+	 * type.
+	 *
+	 * @return a query-builder
+	 */
+	public AsyncListQueryBuilder<P, P> select() {
+		return new AsyncListQueryBuilder<>(emf, this, type);
+	}
+
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the given type (use this
+	 * for a COUNT(*) query, for example).
+	 *
+	 * @param <T>        the type the result will be
+	 * @param resultType the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> AsyncListQueryBuilder<P, T> select(final Class<T> resultType) {
+		return new AsyncListQueryBuilder<>(emf, this, resultType);
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * given type (use this for a COUNT(*) query, for example).
+	 *
+	 * @param <T>          the type the result will be
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @param resultType   the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> AsyncListQueryBuilder<P, T> select(final String selectClause, final Class<T> resultType) {
+		AsyncListQueryBuilder<P, T> b = new AsyncListQueryBuilder<>(emf, this, resultType);
+		b.setSelect(selectClause);
+		return b;
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * underlying generic type.
+	 *
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @return a query-builder
+	 */
+	public AsyncListQueryBuilder<P, P> select(final String selectClause) {
+		AsyncListQueryBuilder<P, P> b = new AsyncListQueryBuilder<>(emf, this, type);
+		b.setSelect(selectClause);
+		return b;
+	}
+
+	/**
+	 * Get an element by ID.
+	 *
+	 * @param id the ID to fetch.
+	 * @return the element with the given ID or null, if there was no such thing
+	 */
+	public SingleQueryBuilder<P, P> select(final Long id) {
+		return new SingleQueryBuilder<>(this, id);
+	}
+
+	/**
+	 * Insert the given entity.
+	 *
+	 * @param entity to insert.
+	 * @return the entity after inserting
+	 */
+	public InsertQueryBuilder<P> insert(final P entity) {
+		return new InsertQueryBuilder<>(this, entity);
+	}
+
+	/**
+	 * Update the given entity.
+	 *
+	 * @param entity to update.
+	 * @return the entity after updating
+	 */
+	public UpdateQueryBuilder<P> update(final P entity) {
+		return new UpdateQueryBuilder<>(this, entity);
+	}
+}