Migration to query dsl 4

pom.xml

@@ -26,7 +26,7 @@
 		<h2.version>1.3.173</h2.version>
 		<liquibase.version>3.3.1</liquibase.version>
 		<liquibase.slf4j.version>1.7.7</liquibase.slf4j.version>
-		<querydsl.version>3.6.0</querydsl.version>
+		<querydsl.version>4.1.4</querydsl.version>
 		<logback.version>1.0.13</logback.version>
 		<selenium.version>2.53.0</selenium.version>
 		<build.server.version>1.2.0</build.server.version>
@@ -248,15 +248,10 @@
 			<version>1.2.1</version>
 		</dependency>
 		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
+			<groupId>com.querydsl</groupId>
 			<artifactId>querydsl-jpa</artifactId>
 			<version>${querydsl.version}</version>
 		</dependency>
-		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
-			<artifactId>querydsl-apt</artifactId>
-			<version>${querydsl.version}</version>
-		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
 			<artifactId>commons-csv</artifactId>
@@ -487,19 +482,26 @@
 			</plugin>
 			<plugin>
 				<groupId>com.mysema.maven</groupId>
-				<artifactId>maven-apt-plugin</artifactId>
-				<version>1.0.4</version>
+				<artifactId>apt-maven-plugin</artifactId>
+				<version>1.1.3</version>
 				<executions>
 					<execution>
 						<goals>
 							<goal>process</goal>
 						</goals>
 						<configuration>
 							<outputDirectory>target/metamodel</outputDirectory>
-							<processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
+							<processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
 						</configuration>
 					</execution>
 				</executions>
+				<dependencies>
+					<dependency>
+						<groupId>com.querydsl</groupId>
+						<artifactId>querydsl-apt</artifactId>
+						<version>${querydsl.version}</version>
+					</dependency>
+				</dependencies>
 			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/Assignments.java

@@ -19,18 +19,18 @@ public Assignments(EntityManager em) {
     }
 
     public Assignment find(CourseEdition course, Long assignmentId) {
-        return ensureNotNull(query().from(QAssignment.assignment)
+        return ensureNotNull(query().selectFrom(QAssignment.assignment)
             .where(QAssignment.assignment.courseEdition.eq(course)
             .and(QAssignment.assignment.assignmentId.eq(assignmentId)))
-            .singleResult(QAssignment.assignment),
+            .fetchOne(),
             "Could not find assignment " + assignmentId + " for " + course.getCode());
     }
 
     public boolean exists(CourseEdition course, Long assignmentId) {
-        return query().from(QAssignment.assignment)
+        return query().selectFrom(QAssignment.assignment)
             .where(QAssignment.assignment.courseEdition.eq(course)
             .and(QAssignment.assignment.assignmentId.eq(assignmentId)))
-            .exists();
+            .fetchCount() > 0;
     }
 
 }

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/BuildResults.java

@@ -14,6 +14,8 @@
 import java.util.Collection;
 import java.util.Map;
 
+
+import static com.querydsl.core.group.GroupBy.groupBy;
 import static nl.tudelft.ewi.devhub.server.database.entities.QBuildResult.buildResult;
 
 public class BuildResults extends Controller<BuildResult> {
@@ -33,10 +35,10 @@ public BuildResult find(RepositoryEntity repository, String commitId) {
 		Preconditions.checkNotNull(repository);
 		Preconditions.checkNotNull(commitId);
 
-		BuildResult result = query().from(buildResult)
+		BuildResult result = query().selectFrom(buildResult)
 				.where(buildResult.commit.repository.id.eq(repository.getId()))
 				.where(buildResult.commit.commitId.equalsIgnoreCase(commitId))
-				.singleResult(buildResult);
+				.fetchOne();
 
 		if (result == null) {
 			throw new EntityNotFoundException();
@@ -53,10 +55,10 @@ public Map<String, BuildResult> findBuildResults(RepositoryEntity repository, Co
 			return ImmutableMap.of();
 		}
 
-		return query().from(buildResult)
+		return query().selectFrom(buildResult)
 				.where(buildResult.commit.repository.eq(repository)
 						.and(buildResult.commit.commitId.in(commitIds)))
-				.map(buildResult.commit.commitId, buildResult);
+				.transform(groupBy(buildResult.commit.commitId).as(buildResult));
 	}
 
 	@Transactional

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/BuildServers.java

@@ -21,16 +21,16 @@ public BuildServers(EntityManager entityManager) {
 
 	@Transactional
 	public List<BuildServer> listAll() {
-		return ImmutableList.copyOf(query().from(QBuildServer.buildServer)
+		return ImmutableList.copyOf(query().selectFrom(QBuildServer.buildServer)
 				.orderBy(QBuildServer.buildServer.name.toLowerCase().asc())
-				.list(QBuildServer.buildServer));
+				.fetch());
 	}
 
 	@Transactional
 	public BuildServer findById(long id) {
-		BuildServer buildServer = query().from(QBuildServer.buildServer)
+		BuildServer buildServer = query().selectFrom(QBuildServer.buildServer)
 				.where(QBuildServer.buildServer.id.eq(id))
-				.singleResult(QBuildServer.buildServer);
+				.fetchOne();
 
 		if (buildServer == null) {
 			throw new EntityNotFoundException();
@@ -43,10 +43,10 @@ public BuildServer findByCredentials(String name, String secret) {
 		Preconditions.checkNotNull(name);
 		Preconditions.checkNotNull(secret);
 
-		BuildServer buildServer = query().from(QBuildServer.buildServer)
+		BuildServer buildServer = query().selectFrom(QBuildServer.buildServer)
 				.where(QBuildServer.buildServer.name.equalsIgnoreCase(name))
 				.where(QBuildServer.buildServer.secret.eq(secret))
-				.singleResult(QBuildServer.buildServer);
+				.fetchOne();
 
 		if (buildServer == null) {
 			throw new EntityNotFoundException();

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/CommitComments.java

@@ -13,6 +13,8 @@
 import java.util.Map;
 import java.util.stream.Stream;
 
+
+import static com.querydsl.core.group.GroupBy.groupBy;
 import static nl.tudelft.ewi.devhub.server.database.entities.comments.QCommitComment.commitComment;
 
 /**
@@ -33,11 +35,11 @@ public CommitComments(final EntityManager entityManager) {
      */
     @Transactional
     public List<CommitComment> getCommentsFor(RepositoryEntity repositoryEntity, String... commitIds) {
-        return query().from(commitComment)
+        return query().selectFrom(commitComment)
                 .where(commitComment.source.sourceFilePath.isNull()
                         .and(commitComment.commit.repository.eq(repositoryEntity)
                                 .and(commitComment.commit.commitId.in(commitIds))))
-            .list(commitComment);
+            .fetch();
     }
 
     /**
@@ -48,11 +50,11 @@ public List<CommitComment> getCommentsFor(RepositoryEntity repositoryEntity, Str
      */
     @Transactional
     public List<CommitComment> getCommentsFor(RepositoryEntity repositoryEntity, List<String> commitIds) {
-        return query().from(commitComment)
+        return query().selectFrom(commitComment)
                 .where(commitComment.source.sourceFilePath.isNull()
                         .and(commitComment.commit.repository.eq(repositoryEntity)
                                 .and(commitComment.commit.commitId.in(commitIds))))
-                .list(commitComment);
+                .fetch();
     }
 
     /**
@@ -63,11 +65,11 @@ public List<CommitComment> getCommentsFor(RepositoryEntity repositoryEntity, Lis
      */
     @Transactional
     public List<CommitComment> getInlineCommentsFor(RepositoryEntity repositoryEntity, Collection<String> commitIds) {
-        return query().from(commitComment)
+        return query().selectFrom(commitComment)
             .where(commitComment.source.sourceFilePath.isNotNull()
                     .and(commitComment.commit.repository.eq(repositoryEntity)
                             .and(commitComment.commit.commitId.in(commitIds))))
-            .list(commitComment);
+            .fetch();
     }
 
     /**
@@ -77,11 +79,11 @@ public List<CommitComment> getInlineCommentsFor(RepositoryEntity repositoryEntit
      */
     @Transactional
     public Map<String, Long> commentsFor(RepositoryEntity repositoryEntity, Collection<String> commitIds) {
-        return query().from(commitComment)
+        return query().selectFrom(commitComment)
             .where(commitComment.commit.repository.eq(repositoryEntity)
-                    .and(commitComment.commit.commitId.in(commitIds)))
-            .groupBy(commitComment.commit.commitId)
-            .map(commitComment.commit.commitId, commitComment.commentId.count());
+                    .and(commitComment.commit.commitId.in(commitIds))
+            ).groupBy(commitComment.commit.commitId)
+            .transform(groupBy(commitComment.commit.commitId).as( commitComment.commentId.count()));
     }
 
     /**
@@ -92,11 +94,11 @@ public Map<String, Long> commentsFor(RepositoryEntity repositoryEntity, Collecti
      */
     @Transactional
     public Stream<CommitComment> getMostRecentCommitComments(List<? extends RepositoryEntity> repositoryEntities, long limit) {
-        return toStream(query().from(commitComment)
+        return toStream(query().selectFrom(commitComment)
             .where(commitComment.commit.repository.in(repositoryEntities))
             .orderBy(commitComment.timestamp.desc())
             .limit(limit)
-            .iterate(commitComment));
+            .iterate());
     }
 
 }

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/Commits.java

@@ -96,10 +96,10 @@ protected CommitModel retrieveCommit(RepositoryEntity repositoryEntity, String c
 	 */
 	@Transactional
 	public boolean exists(RepositoryEntity repository, String commitId) {
-		return query().from(commit)
+		return query().selectFrom(commit)
 			.where(commit.repository.eq(repository))
 			.where(commit.commitId.eq(commitId))
-			.exists();
+			.fetchCount() > 0;
 	}
 
 	/**
@@ -110,10 +110,10 @@ public boolean exists(RepositoryEntity repository, String commitId) {
      */
 	@Transactional
 	public Stream<Commit> getMostRecentCommits(List<? extends RepositoryEntity> repositoryEntities, long limit) {
-		return toStream(query().from(commit)
+		return toStream(query().selectFrom(commit)
 			.where(commit.repository.in(repositoryEntities))
 			.orderBy(commit.pushTime.desc())
 			.limit(limit)
-			.iterate(commit));
+			.iterate());
 	}
 }

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/Controller.java

@@ -1,11 +1,11 @@
 package nl.tudelft.ewi.devhub.server.database.controllers;
 
 import com.mysema.commons.lang.CloseableIterator;
+import com.querydsl.jpa.impl.JPAQueryFactory;
 import lombok.extern.slf4j.Slf4j;
 
 import com.google.common.base.Preconditions;
 import com.google.inject.persist.Transactional;
-import com.mysema.query.jpa.impl.JPAQuery;
 
 import org.hibernate.Hibernate;
 import org.hibernate.engine.spi.SessionImplementor;
@@ -57,8 +57,8 @@ public T delete(T entity) {
 		return entity;
 	}
 
-	public JPAQuery query() {
-		return new JPAQuery(entityManager);
+	public JPAQueryFactory query() {
+		return new JPAQueryFactory(entityManager);
 	}
 
 	protected T ensureNotNull(T entry, String error) {

src/main/java/nl/tudelft/ewi/devhub/server/database/controllers/CourseEditions.java

@@ -1,16 +1,16 @@
 package nl.tudelft.ewi.devhub.server.database.controllers;
 
+import com.querydsl.core.types.OrderSpecifier;
+import com.querydsl.jpa.JPAExpressions;
+import com.querydsl.jpa.JPQLQuery;
+import com.querydsl.jpa.impl.JPAQuery;
 import nl.tudelft.ewi.devhub.server.database.entities.Course;
 import nl.tudelft.ewi.devhub.server.database.entities.CourseEdition;
 import nl.tudelft.ewi.devhub.server.database.entities.User;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.inject.persist.Transactional;
-import com.mysema.query.jpa.JPASubQuery;
-import com.mysema.query.jpa.impl.JPAQuery;
-import com.mysema.query.types.OrderSpecifier;
-import com.mysema.query.types.query.ListSubQuery;
 
 import javax.inject.Inject;
 import javax.persistence.EntityManager;
@@ -30,27 +30,28 @@ public CourseEditions(EntityManager entityManager) {
 
 	@Transactional
 	public CourseEdition find(long id) {
-		return ensureNotNull(query().from(courseEdition)
+		return ensureNotNull(query().selectFrom(courseEdition)
 			.where(courseEdition.id.eq(id))
-			.singleResult(courseEdition), "Could not find course with id: " + id);
+			.fetchOne(), "Could not find course with id: " + id);
 	}
 
 	@Transactional
 	public CourseEdition find(String courseCode, String period) {
 		Preconditions.checkNotNull(courseCode);
 		Preconditions.checkNotNull(period);
 
-		return ensureNotNull(query().from(courseEdition)
+		return ensureNotNull(query().selectFrom(courseEdition)
 			.where(courseEdition.code.equalsIgnoreCase(period)
 				.and(courseEdition.course.code.equalsIgnoreCase(courseCode)))
-			.singleResult(courseEdition), "Could not find course with code: " + courseCode);
+			.fetchOne(), "Could not find course with code: " + courseCode);
 	}
 
     @Transactional
     public List<CourseEdition> listParticipatingCourses(User user) {
 		return query().from(group)
 				.where(group.members.contains(user))
-				.list(group.courseEdition);
+				.select(group.courseEdition)
+				.fetch();
     }
 
 	/**
@@ -68,14 +69,14 @@ public Collection<CourseEdition> listAssistingCourses(User user) {
     @Transactional
     public List<CourseEdition> listAdministratingCourses(User user) {
         if(user.isAdmin()) {
-            return query().from(courseEdition).list(courseEdition);
+            return query().selectFrom(courseEdition).fetch();
         }
-        return ImmutableList.<CourseEdition> of();
+        return ImmutableList.of();
     }
 
-	private JPAQuery activeCoursesBaseQuery() {
+	private JPAQuery<CourseEdition> activeCoursesBaseQuery() {
 		Date now = new Date();
-		return query().from(courseEdition)
+		return query().selectFrom(courseEdition)
 			.where(courseEdition.timeSpan.start.before(now)
 				.and(courseEdition.timeSpan.end.isNull()
 					.or(courseEdition.timeSpan.end.after(now))));
@@ -85,28 +86,28 @@ private JPAQuery activeCoursesBaseQuery() {
 	public List<CourseEdition> listActiveCourses() {
 		return activeCoursesBaseQuery()
 			.orderBy(courseOrdering())
-			.list(courseEdition);
+			.fetch();
 	}
 
 	@Transactional
 	public CourseEdition getActiveCourseEdition(Course course) {
 		return ensureNotNull(activeCoursesBaseQuery()
 			.where(courseEdition.course.eq(course))
-			.singleResult(courseEdition), "Could not find active course edition for " + course);
+			.fetchOne(), "Could not find active course edition for " + course);
 	}
 
 	@Transactional
 	public List<CourseEdition> listNotYetParticipatedCourses(User user) {
 		Preconditions.checkNotNull(user);
 
-		ListSubQuery<CourseEdition> participatingCourses = new JPASubQuery().from(group)
-			.where(group.members.contains(user))
-			.list(group.courseEdition);
+		JPQLQuery<CourseEdition> participatingCourses = JPAExpressions.selectFrom(group)
+				.where(group.members.contains(user))
+				.select(group.courseEdition);
 
 		return activeCoursesBaseQuery()
 			.where(courseEdition.notIn(participatingCourses))
 			.orderBy(courseOrdering())
-			.list(courseEdition);
+			.fetch();
 	}
 
 	private static OrderSpecifier<?>[] courseOrdering() {