The sorting should always be in descending order for numbers when first clicking on a new search term, i. e. another Keyword type (area or regular). SQl (and not HQL) must be used in the database tier because of the implementation of Employee#keywords.

src/main/java/se/su/dsv/scipro/springdata/repos/SupervisorRepo.java

@@ -1,5 +1,6 @@
 package se.su.dsv.scipro.springdata.repos;
 
+import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.querydsl.QueryDslPredicateExecutor;
@@ -15,13 +16,49 @@ import java.util.List;
  */
 @Transactional ( readOnly = true )
 public interface SupervisorRepo extends JpaRepository<Employee, Long>, QueryDslPredicateExecutor<Employee> {
+             // select employeeFull from Employee employeeFull where employeeFull.id in (
+	@Query ("select employee.id " +
+            "from Employee employee " +
+                "join employee.keywords.keywords keywords " +
+                "where keywords.type.name = :keywordTypeName " +
+			    "group by employee.id " +
+                "order by size(employee.keywords.keywords) desc ")
+	public List<Long> findSupervisorsOrderedByNumKeywordsDescending(
+            @Param("keywordTypeName")
+            String keywordTypeName);
 
-	@Query ( "select employee from Employee employee left outer join employee.keywords.keywords keywords " +
+    // hämtar employees med keywords där typen är type name... men en employee kan ha keywords av flera olika type names
-					 "where (size(employee.keywords.keywords) = 0 or (keywords.type.name = :keywordTypeName and keywords.deleted = false)) " +
-					 "order by size(employee.keywords.keywords) desc, employee.user.lastName" )
-	public List<Employee> findSupervisorDescDirection(
-			@Param ( "keywordTypeName" )
-			String keywordTypeName);
 
+    @Query ("select employee.id " +
+            "from Employee employee " +
+            "join employee.keywords.keywords keywords " +
+            "where keywords.type.name = :keywordTypeName " +
+            "group by employee.id " +
+            //"order by size(employee.keywords.keywords) asc ")
+            "order by size(employee.keywords.keywords) asc ")
+                      // sum(keywords.type.name = :keywordTypeName)
+    /*@Query ("select employeeFull from Employee employeeFull where employeeFull.id in (" +
+            "select employee.id from Employee employee inner join employee.keywords.keywords keywords " +
+            "where keywords.type.name = :keywordTypeName " + //and keywords.deleted = false and employee.deleted = false)) " +
+            "group by employee.id " +
+            "order by size(employeeFull.keywords.keywords) asc)")*/
+//"CASE ':ascending' WHEN 'true' THEN (size(employeeFull.keywords.keywords) asc " +
+//"ELSE size(employeeFull.keywords.keywords) desc END" +
+//"ELSE employeeFull.keywords.keywords.size desc " +
+//"END"
+    public List<Long> findSupervisorsOrderedByNumKeywordsAscending(
+            @Param("keywordTypeName")
+            String keywordTypeName);
+
+   /* public List<Employee> findSupervisorsOrderedByNumKeywords(String keywordTypeName, Boolean asc) {
+        switch (asc) {
+            case Direction.ASC:
+                return findSupervisorsOrderedByNumKeywordsAscending(keywordTypeName);
+            case Direction.DESC:
+            default:
+                return findSupervisorsOrderedByNumKeywordsAscending(keywordTypeName);
+        }
+        return findSupervisorsOrderedByNumKeywordsAscending(keywordTypeName);
+    }*/
 }
 

src/main/java/se/su/dsv/scipro/springdata/serviceimpls/SupervisorServiceImpl.java

@@ -2,6 +2,7 @@ package se.su.dsv.scipro.springdata.serviceimpls;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import se.su.dsv.scipro.data.dataobjects.Employee;
@@ -37,17 +38,55 @@ public class SupervisorServiceImpl extends AbstractQueryService<Employee, Long>
 
     @Override
     public List<Employee> findAllEmployees(org.springframework.data.domain.Sort orders) {
-        return supervisorRepo.findAll(orders);
+        return supervisorRepo.findAll(orders);            // 218 st
+    }
+
+   /* @Override
+    public List<Employee> findSupervisorsOrderedByNumKeywords(String keywordTypeName, Sort.Direction sortDirection) {
+        return supervisorRepo.findSupervisorsOrderedByNumKeywords(keywordTypeName, sortDirection);
+    }*/
+
+    @Override
+    public List<Employee> findSupervisorsOrderedByNumKeywordsDescending(String keywordTypeName) {
+        List<Long> employeeIDs = new ArrayList<Long>();
+        employeeIDs.addAll(supervisorRepo.findSupervisorsOrderedByNumKeywordsDescending(keywordTypeName));
+        return loadEmployeeList(employeeIDs);
     }
 
     @Override
-    public List<Employee> findSupervisorDescDirection(String keywordTypeName) {
+    public List<Employee> findSupervisorsOrderedByNumKeywordsAscending(String keywordTypeName) {
-        return supervisorRepo.findSupervisorDescDirection(keywordTypeName);
+        List<Long> employeeIDs = new ArrayList<Long>();
+        employeeIDs.addAll(supervisorRepo.findSupervisorsOrderedByNumKeywordsAscending(keywordTypeName));
+        return loadEmployeeList(employeeIDs);
+    }
+
+
+    private List<Employee> loadEmployeeList(List<Long> employeeIDs) {
+        List<Employee> employeeList = new ArrayList<Employee>();
+        for (Long employeeID : employeeIDs) {
+            Employee employee = (Employee) em.createQuery("from Employee employee where employee.id = " + employeeID).getResultList().get(0);
+            if(employee != null && !employeeList.contains(employee)) {
+                employeeList.add(employee);
+            }
+        }
+        return employeeList;
     }
 
     @Override
     public List<Employee> findSupervisorBySQL(String keywordTypeName, String direction) {
+        List<Employee> employeeList = new ArrayList<Employee>();
+        if(direction.equalsIgnoreCase("desc")) {
+            employeeList.addAll(getEmployeesThatHaveKeywords(keywordTypeName, direction));
+            employeeList.addAll(getEmployeesWithoutKeywords());
+        } else {
+            employeeList.addAll(getEmployeesWithoutKeywords());
+            employeeList.addAll(getEmployeesThatHaveKeywords(keywordTypeName, direction));
+        }
+        return employeeList;  // totalt 129 st för regular men 156 st för area och 218 för last name (vilken innehåller både keywords Area och Regular)
+    }
 
+    private List<Employee> getEmployeesThatHaveKeywords(String keywordTypeName, String direction) {
+        List<Employee> employeeList = new ArrayList<Employee>();
         String nativeSQL = "select " +
                                     "role.id " +
                             "from " +
@@ -66,23 +105,41 @@ public class SupervisorServiceImpl extends AbstractQueryService<Employee, Long>
                                     "role_id " +
                             "order by " +
                                     "count(keywords_id) " + direction + ", user.lastName asc ";
+        return runQueryAddToList(employeeList, nativeSQL);
+    }
 
+
+    private List<Employee> getEmployeesWithoutKeywords() {
+        List<Employee> employeeList = new ArrayList<Employee>();
+        String nativeSQL = "select  " +
+                                    "role.id " +
+                            "from  " +
+                                    "role role, " +
+                                    "user user " +
+                            "where " +
+                                    "role.rolename = 'Employee' and " +
+                                    "user.id = role.user_id and not exists " +
+                                    "(select " +
+                                            "1 " +
+                                     "from " +
+                                            "Employee_Keyword ek " +
+                                     "where " +
+                                            "ek.role_id = role.id)  " +
+                                      "order by  " +
+                                            "user.lastName asc ";
+        return runQueryAddToList(employeeList, nativeSQL);
+    }
+
+    private List<Employee> runQueryAddToList(List<Employee> employeeList, final String nativeSQL) {
         List<BigInteger> dBlist= new ArrayList<BigInteger>();
         //noinspection unchecked
         dBlist.addAll(em.createNativeQuery(nativeSQL).getResultList());
-
-        List<Long> employeeIDs  = new ArrayList<Long>();
         for (BigInteger number : dBlist) {
-            employeeIDs.add(number.longValue());
+            Employee employee = (Employee) em.createQuery("from Employee employee where employee.id = " + number.longValue()).getResultList().get(0);
-        }
-
-        List<Employee> employeeList = new ArrayList<Employee>();
-        for(Long employeeID : employeeIDs) {
-            Employee employee = (Employee) em.createQuery("from Employee employee where employee.id = " + employeeID).getResultList().get(0);
             if(employee != null && !employeeList.contains(employee)) {
                 employeeList.add(employee);
             }
         }
-        return employeeList;
+        return employeeList;        // 36 st   + 93 st
     }
 }

src/main/java/se/su/dsv/scipro/springdata/services/SupervisorService.java

@@ -1,11 +1,13 @@
 package se.su.dsv.scipro.springdata.services;
 
 
+import org.springframework.data.domain.Sort;
 import se.su.dsv.scipro.data.dataobjects.Employee;
 import javax.persistence.EntityManager;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
+import org.springframework.data.domain.Sort.Direction;
 
 /**
  * fred-fri
@@ -14,7 +16,11 @@ import java.util.List;
 public interface SupervisorService extends CrudService<Employee,Long>, QueryService<Employee, Long> {
     public List<Employee> findAllEmployees(org.springframework.data.domain.Sort orders);
 
-    public List<Employee> findSupervisorDescDirection(String keywordTypeName);
+    public List<Employee> findSupervisorsOrderedByNumKeywordsDescending(String keywordTypeName);
+
+    public List<Employee> findSupervisorsOrderedByNumKeywordsAscending(String keywordTypeName);
+
+//    public List<Employee> findSupervisorsOrderedByNumKeywords(String keywordTypeName, Sort.Direction sortDirection);
 
     public List<Employee> findSupervisorBySQL(String keywordTypeName, String sortOrder);
 }

src/test/java/se/su/dsv/scipro/springdata/TestSupervisor.java

@@ -140,7 +140,7 @@ public class TestSupervisor {
         createAndAddKeyword(larsson, keywordTypeArea, "Area2");
         createAndAddKeyword(larsson, keywordTypeArea, "Area3");
 
-        for(Employee employee : supervisorService.findSupervisorDescDirection(keywordTypeArea.getName())) {
+        for(Employee employee : supervisorService.findSupervisorsOrderedByNumKeywordsDescending(keywordTypeArea.getName())) {
             if(!employeeList.contains(employee)) {
                 employeeList.add(employee);
             }
@@ -186,4 +186,56 @@ public class TestSupervisor {
         assertTrue(employeeList.get(0).equals(herder));
         assertTrue(employeeList.get(1).equals(tholerus));*/
     }
+
+    @Test
+    @Transactional
+    @Rollback
+    public void testFindSupervisorsOrderedByNumKeywordsDescending() {
+        Employee tholerus = getEmployee("Torgny", "Tholerus", "torgny@dsv.su.se");
+        Employee vahlman = getEmployee("Tom", "Vahlman", "tom@dsv.su.se");
+        Employee gomes = getEmployee("Anton", "Gomes", "anton@dsv.su.se");
+
+        createAndAddKeyword(vahlman,  keywordTypeArea, "Information systems");
+        createAndAddKeyword(tholerus, keywordTypeArea, "IT for health");
+        createAndAddKeyword(tholerus, keywordTypeArea, "IT for learning");
+        createAndAddKeyword(gomes,    keywordTypeWord, "Online gaming communities");
+
+        List<Employee> employeeList = supervisorService.findSupervisorsOrderedByNumKeywordsDescending(KeywordTypeDao.TYPE.RESEARCH_AREA.toDbName());
+
+        assertFalse(employeeList.isEmpty());
+        assertTrue(employeeList.size() == 2);
+        assertFalse(employeeList.contains(gomes));
+        assertTrue(employeeList.get(0).equals(tholerus));
+
+        createAndAddKeyword(vahlman,  keywordTypeArea, "IT for health");
+        createAndAddKeyword(vahlman,  keywordTypeArea, "Aprikoskärnor");
+        employeeList = supervisorService.findSupervisorsOrderedByNumKeywordsDescending(KeywordTypeDao.TYPE.RESEARCH_AREA.toDbName());
+        assertTrue(employeeList.get(0).equals(vahlman));
+    }
+
+    @Test
+    @Transactional
+    @Rollback
+    public void testFindSupervisorsOrderedByNumKeywordsAscending() {
+        Employee tholerus = getEmployee("Torgny", "Tholerus", "torgny@dsv.su.se");
+        Employee vahlman = getEmployee("Tom", "Vahlman", "tom@dsv.su.se");
+        Employee gomes = getEmployee("Anton", "Gomes", "anton@dsv.su.se");
+
+        createAndAddKeyword(vahlman,  keywordTypeArea, "Information systems");
+        createAndAddKeyword(tholerus, keywordTypeArea, "IT for health");
+        createAndAddKeyword(tholerus, keywordTypeArea, "IT for learning");
+        createAndAddKeyword(gomes,    keywordTypeWord, "Online gaming communities");
+
+        List<Employee> employeeList = supervisorService.findSupervisorsOrderedByNumKeywordsAscending(KeywordTypeDao.TYPE.RESEARCH_AREA.toDbName());
+
+        assertFalse(employeeList.isEmpty());
+        assertTrue(employeeList.size() == 2);
+        assertFalse(employeeList.contains(gomes));
+        assertTrue(employeeList.get(1).equals(tholerus));
+
+        createAndAddKeyword(vahlman,  keywordTypeArea, "IT for health");
+        createAndAddKeyword(vahlman,  keywordTypeArea, "Aprikoskärnor");
+        employeeList = supervisorService.findSupervisorsOrderedByNumKeywordsAscending(KeywordTypeDao.TYPE.RESEARCH_AREA.toDbName());
+        assertTrue(employeeList.get(0).equals(tholerus));
+    }
 }