DMC/scipro
7
0
Fork 0
Code Issues28 Pull Requests2 Actions Projects1 Releases Wiki Activity

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

Browse Source
This commit is contained in:
Tom Vahlman 2012-04-10 16:47:08 +02:00
parent 5348f25e54
commit 0225f1dd59
5 changed files with 79 additions and 123 deletions
src
main/java/se/su/dsv/scipro
admin/panels/match
AdminSupervisorKeywordPanel.java
springdata
repos
SupervisorRepo.java
serviceimpls
SupervisorServiceImpl.java
services
SupervisorService.java
test/java/se/su/dsv/scipro/springdata
TestSupervisor.java

32
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!!!!!!
BooleanExpression keywordsHasCorrectType = employee.isNotNull().and(employee.keywords.keywords.any().type.eq(keywordType));
for(Employee employee__ : supervisorService.findSupervisorQuery(keywordsHasCorrectType, orderBySize)) {
employeeList.add(employee__);
if(sortDirection.toString().equals("ASC")) {
for(Employee employee : supervisorService.findSupervisorBySQL(keywordType.getName(), "asc")) {
if(!employeeList.contains(employee)) {
employeeList.add(employee);
}
}
} else {
for(Employee employee : supervisorService.findSupervisorBySQL(keywordType.getName(), "desc")) {
if(!employeeList.contains(employee)) {
employeeList.add(employee);
}
}
}
}
if(supervisorName.toString().isEmpty()) {

11
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);
}

50
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) {
return queryDslPredicateExecutor.findAll(booleanExpression, orderSpecifier);
public List<Employee> findSupervisorDescDirection(String keywordTypeName) {
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;
}
}

17
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>
List<Employee> findAllEmployees(org.springframework.data.domain.Sort orders);
public 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);
}

92
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));
}
}
}