Using a native SQL query to sort the Employees based on keywords in the statistics page.

src/main/java/se/su/dsv/scipro/admin/panels/match/AdminSupervisorKeywordPanel.java

@@ -1,12 +1,8 @@
 package se.su.dsv.scipro.admin.panels.match;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 
-import com.mysema.query.types.OrderSpecifier;
-import com.mysema.query.types.expr.BooleanExpression;
 import org.apache.wicket.ajax.AjaxRequestTarget;
 import org.apache.wicket.ajax.markup.html.AjaxLink;
 import org.apache.wicket.ajax.markup.html.form.AjaxButton;
@@ -24,7 +20,6 @@ import org.apache.wicket.spring.injection.annot.SpringBean;
 import org.odlabs.wiquery.ui.dialog.Dialog;
 
 import se.su.dsv.scipro.data.dataobjects.Employee;
-import se.su.dsv.scipro.data.dataobjects.QEmployee;
 import se.su.dsv.scipro.match.dao.interfaces.KeywordTypeDao;
 import se.su.dsv.scipro.match.dao.interfaces.SupervisorDao;
 import se.su.dsv.scipro.match.dataobject.Keyword;
@@ -116,29 +111,26 @@ if(!supervisorName.toString().isEmpty()) {
                         employeeList.addAll(supervisorService.findAllEmployees(sorter));
                     }
                 }
-
-
-                QEmployee employee = QEmployee.employee;
-                OrderSpecifier<?> orderBySize = employee.keywords.keywords.size().asc();
                 KeywordType keywordType = keywordTypeDao.findByType(KeywordTypeDao.TYPE.REGULAR);
-
                 if(orderBy.toString().equals("keywords.all.size") || orderBy.toString().equals("areas.all.size")) {
-                    if(sortDirection.toString().equals("ASC")) {
-                        orderBySize = employee.keywords.keywords.size().asc();
-                    } else {
-                        orderBySize = employee.keywords.keywords.size().desc();
-                    }
-
                     if(orderBy.toString().equals("keywords.all.size")) {
                         keywordType = keywordTypeDao.findByType(KeywordTypeDao.TYPE.REGULAR);
                     } else if (orderBy.toString().equals("areas.all.size")) {
                         keywordType = keywordTypeDao.findByType(KeywordTypeDao.TYPE.RESEARCH_AREA);
                     }
 
-                    // DETTA funkar inte den kollar om det finns något element i listan av den aktuella typen!!!!!!
+                    if(sortDirection.toString().equals("ASC")) {
-                    BooleanExpression keywordsHasCorrectType = employee.isNotNull().and(employee.keywords.keywords.any().type.eq(keywordType));
+                        for(Employee employee : supervisorService.findSupervisorBySQL(keywordType.getName(), "asc")) {
-                    for(Employee employee__ : supervisorService.findSupervisorQuery(keywordsHasCorrectType, orderBySize)) {
+                            if(!employeeList.contains(employee)) {
-                        employeeList.add(employee__);
+                                employeeList.add(employee);
+                            }
+                        }
+                    } else {
+                        for(Employee employee : supervisorService.findSupervisorBySQL(keywordType.getName(), "desc")) {
+                            if(!employeeList.contains(employee)) {
+                                employeeList.add(employee);
+                            }
+                        }
                     }
                 }
                 if(supervisorName.toString().isEmpty()) {

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

@@ -1,18 +1,25 @@
 package se.su.dsv.scipro.springdata.repos;
 
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.querydsl.QueryDslPredicateExecutor;
+import org.springframework.data.repository.query.Param;
 import org.springframework.transaction.annotation.Transactional;
 import se.su.dsv.scipro.data.dataobjects.Employee;
 
+import java.util.List;
+
 /**
- * @author: fred-fri
+ * fred-fri
  * date: 2012 03 23
  */
 @Transactional(readOnly = true)
 public interface SupervisorRepo extends JpaRepository<Employee, Long>, QueryDslPredicateExecutor<Employee> {
 
-    //nothing here yet
+    @Query("select employee from Employee employee join employee.keywords.keywords keywords " +
+            "where keywords.type.name = :keywordTypeName and keywords.deleted = false " +
+            "order by employee.keywords.keywords.size desc, employee.user.lastName desc  ")
+    public List<Employee> findSupervisorDescDirection(@Param("keywordTypeName") String keywordTypeName);
 
 }
 

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

@@ -17,6 +17,7 @@ import javax.annotation.Resource;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 
+import java.math.BigInteger;
 import java.util.*;
 
 @Service ( "supervisorService" )
@@ -28,9 +29,14 @@ public class SupervisorServiceImpl extends AbstractQueryService<Employee, Long>
     private SupervisorRepo supervisorRepo;
 
 
+
     @PersistenceContext
     private EntityManager em;
 
+    public void setEm(EntityManager em) {    // for the purpose of tests
+        if(em == null)
+            this.em = em;
+    }
 
     @Autowired
     public SupervisorServiceImpl(@Qualifier("supervisorRepo") SupervisorRepo supervisorRepo) {
@@ -44,7 +50,47 @@ public class SupervisorServiceImpl extends AbstractQueryService<Employee, Long>
     }
 
     @Override
-    public Iterable<Employee> findSupervisorQuery(BooleanExpression booleanExpression, OrderSpecifier<?> orderSpecifier) {
+    public List<Employee> findSupervisorDescDirection(String keywordTypeName) {
-        return queryDslPredicateExecutor.findAll(booleanExpression, orderSpecifier);
+        return supervisorRepo.findSupervisorDescDirection(keywordTypeName);
+    }
+
+    @Override
+    public List<Employee> findSupervisorBySQL(String keywordTypeName, String sortOrder) {
+
+        String nativeSQL = "select " +
+                                    "role.id " +
+                            "from " +
+                                    "Employee_Keyword ek, " +
+                                    "role role, " +
+                                    "user user, " +
+                                    "Keyword k, " +
+                                    "KeywordType kt " +
+                            "where " +
+                                    "role.id = ek.role_id  and " +
+                                    "user.id = role.user_id and " +
+                                    "k.id = ek.keywords_id and " +
+                                    "k.type_id = kt.id and " +
+                                    "kt.name= '" + keywordTypeName + "' " +
+                            "group by " +
+                                    "role_id " +
+                            "order by " +
+                                    "count(keywords_id) " + sortOrder + ", user.lastName asc ";
+
+        List<BigInteger> dBlist= new ArrayList<BigInteger>();
+        dBlist.addAll(em.createNativeQuery(nativeSQL).getResultList());
+
+        List<Long> employeeIDs  = new ArrayList<Long>();
+        for (BigInteger number : dBlist) {
+            employeeIDs.add(number.longValue());
+        }
+
+        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;
     }
 }

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

@@ -1,19 +1,22 @@
 package se.su.dsv.scipro.springdata.services;
-import com.mysema.query.types.OrderSpecifier;
-import com.mysema.query.types.expr.BooleanExpression;
-import se.su.dsv.scipro.data.dataobjects.Employee;
 
+
+import se.su.dsv.scipro.data.dataobjects.Employee;
+import javax.persistence.EntityManager;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
 
 /**
- * @author: fred-fri
+ * fred-fri
  * date: 2012 03 26
  */
 public interface SupervisorService extends CrudService<Employee,Long>, QueryService<Employee, Long> {
-    public //List<Employee>
+    public List<Employee> findAllEmployees(org.springframework.data.domain.Sort orders);
-    List<Employee> findAllEmployees(org.springframework.data.domain.Sort orders);
 
-    public Iterable<Employee> findSupervisorQuery(BooleanExpression booleanExpression, OrderSpecifier<?> orderSpecifier);
+    public List<Employee> findSupervisorDescDirection(String keywordTypeName);
+
+    public List<Employee> findSupervisorBySQL(String keywordTypeName, String sortOrder);
+
+    public void setEm(EntityManager em);
 }

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

@@ -135,41 +135,6 @@ public class TestSupervisor {
     }
 
 
-    /**
-     *   Test for implementing a supervisorService with Spring Data
-     */
-    @Test
-    @Transactional
-    @Rollback
-    public void findEmployeeByName() {
-        List<Employee> employeeList = new ArrayList<Employee>();
-        Date dateCreated = new Date();
-        Employee hallberg = getEmployee("David", "Hallberg", "dhallb@dsv.su.se", dateCreated);
-        Employee tholerus = getEmployee("Torgny", "Tholerus", "torgny@dsv.su.se", dateCreated);
-        Employee vahlman = getEmployee("Tom", "Vahlman", "tom@dsv.su.se", dateCreated);
-        Employee friis = getEmployee("Fredrik", "Friis", "fre-fri@dsv.su.se", dateCreated);
-        Employee larsson = getEmployee("Ken", "Larsson", "kenlars@dsv.su.se", dateCreated);
-
-        QEmployee employee = QEmployee.employee;
-        BooleanExpression lastName = employee.user.lastName.eq("Vahlman")
-                .or(employee.user.lastName.eq("Larsson")
-                        .or(employee.user.lastName.eq("Friis"))
-                        .or(employee.user.lastName.eq("Tholerus"))
-                        .or(employee.user.lastName.eq("Hallberg")));
-        BooleanExpression booleanExpression = employee.user.dateCreated.eq(dateCreated).and(lastName);
-        OrderSpecifier<?> orderByName = employee.user.lastName.asc();
-
-        for(Employee employee__ : supervisorService.findSupervisorQuery(booleanExpression, orderByName)) {
-            employeeList.add(employee__);
-        }
-        assertFalse(employeeList.isEmpty());
-        assertTrue(employeeList.size() == 5);
-        assertTrue(employeeList.get(0).equals(friis));
-        assertTrue(employeeList.get(1).equals(hallberg));
-        assertTrue(employeeList.get(2).equals(larsson));
-        assertTrue(employeeList.get(3).equals(tholerus));
-        assertTrue(employeeList.get(4).equals(vahlman));
-    }
 
     /**
      *   Test for implementing a supervisorService with Spring Data
@@ -224,61 +189,4 @@ public class TestSupervisor {
         assertTrue(employeeList.get(1).equals(herder));
     }
 
-
-    /**
-     *   Test for implementing a supervisorService with Spring Data
-     */
-    @Test
-    @Transactional
-    @Rollback
-    public void findNewSupervisorKeywords() {
-        List<Employee> employeeList = new ArrayList<Employee>();
-        Employee larsson = getEmployee("Ken", "Larsson", "kenlars@dsv.su.se", null);
-        Employee hallberg = getEmployee("David", "Hallberg", "dhallb@dsv.su.se", null);
-        Employee tholerus = getEmployee("Torgny", "Tholerus", "torgny@dsv.su.se", null);
-        Employee herder = getEmployee("Niklas", "Herder", "herder@dsv.su.se", null);
-        Employee moattar = getEmployee("Golrokh", "Moattar", "goli@dsv.su.se", null);
-        Employee friis = getEmployee("Fredrik", "Friis", "fre-fri@dsv.su.se", null);
-
-        Keyword keyword = createKeyword(keywordTypeWord, "JUnit", false);
-        herder.getKeywords().getAll().add(keyword);
-        keyword = createKeyword(keywordTypeWord, "Maven", false);
-        herder.getKeywords().getAll().add(keyword);
-        herder =  supervisorService.save(herder);
-
-        keyword = createKeyword(keywordTypeWord, "JUnit", false);
-        tholerus.getKeywords().getAll().add(keyword);
-        keyword = createKeyword(keywordTypeWord, "Maven", false);
-        tholerus.getKeywords().getAll().add(keyword);
-        keyword = createKeyword(keywordTypeWord, "Java", false);
-        tholerus.getKeywords().getAll().add(keyword);
-        tholerus =  supervisorService.save(tholerus);
-
-        keyword = createKeyword(keywordTypeArea, "Area1", false);
-        larsson.getKeywords().getAll().add(keyword);
-        keyword = createKeyword(keywordTypeArea, "Area2", false);
-        larsson.getKeywords().getAll().add(keyword);
-        larsson =  supervisorService.save(larsson);
-
-        keyword = createKeyword(keywordTypeArea, "Area3", false);
-        larsson.getKeywords().getAll().add(keyword);
-        hallberg =  supervisorService.save(hallberg);
-
-        QEmployee employee = QEmployee.employee;
-        OrderSpecifier<?> orderBySize = employee.keywords.keywords.size().desc();
-        KeywordType keywordType = keywordTypeDao.findByType(KeywordTypeDao.TYPE.RESEARCH_AREA);
-        BooleanExpression predicate = employee.isNotNull().and(employee.keywords.keywords.any().type.eq(keywordType));
-        for(Employee employee__ : supervisorService.findSupervisorQuery(predicate, orderBySize)) {
-            employeeList.add(employee__);
-        }
-
-        assertFalse(employeeList.isEmpty());
-        if(keywordType.equals(KeywordTypeDao.TYPE.REGULAR)) {
-            assertTrue(employeeList.get(0).equals(tholerus));
-            assertTrue(employeeList.get(1).equals(herder));
-        } else if(keywordType.equals(KeywordTypeDao.TYPE.RESEARCH_AREA)){
-            assertTrue(employeeList.get(0).equals(larsson));
-            assertTrue(employeeList.get(1).equals(hallberg));
-        }
-    }
 }