Merge branch 'develop' of ssh://git.dsv.su.se/git/scipro/scipro into develop

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

@@ -58,7 +58,7 @@ public class ManageKeywordPanel extends Panel {
 		dialog.add(new EmptyPanel("dialogContent"));
 		dialog.setOutputMarkupId(true);
 		
-		keywordsDataProvider = new KeywordsDataProvider(null, keywordType);
+		keywordsDataProvider = new KeywordsDataProvider(keywordType, true);
 		
 		tableContainer = new WebMarkupContainer("table");
 		tableContainer.setOutputMarkupId(true);

src/main/java/se/su/dsv/scipro/match/GreedyMatchingAlgorithm.java

@@ -263,7 +263,7 @@ public class GreedyMatchingAlgorithm implements MatchingAlgorithm {
          */
         @Override
         public int compareTo(Pair otherPair) {
-            if(match.getPoints() > otherPair.getMatch().getPoints()) {
+            if(match.getPoints() > otherPair.getMatch().getPoints()) {    // points is the most important criteria
                 return -1;
             } else if(otherPair.getMatch().getPoints() > match.getPoints()) {
                 return 1;
@@ -272,20 +272,27 @@ public class GreedyMatchingAlgorithm implements MatchingAlgorithm {
                     return -1;
                 } else if(otherPair.getTotalAvailability() > totalAvailability) {
                     return 1;
-                } else {     // the points and the slots are equal, we must now sort on Project Class because a master supervisor can supervise
-                    // both a master project idea and a bachelor project idea, the "best" match however is if a master supervisor supervises a master project idea...
-                    if(match.getProjectIdea().getProjectClass().equals(availability.getProjectClass()) &&
-                            !otherPair.getMatch().getProjectIdea().getProjectClass().equals(otherPair.getAvailability().getProjectClass())) {
-                        return -1;
-                    } else  if(!match.getProjectIdea().getProjectClass().equals(availability.getProjectClass()) &&
-                            otherPair.getMatch().getProjectIdea().getProjectClass().equals(otherPair.getAvailability().getProjectClass())) {
-                        return 1;
-                    } else {   // the supervisor can only one type of project class
-                        return 0;
+                } else {
+                        // we must now sort on Project Class because a master supervisor can supervise both a master project idea and
+                        //  a bachelor project idea, however the "best" match is if a "master supervisor" handles a "master project idea"...
+                        if(match.getProjectIdea().getProjectClass().equals(availability.getProjectClass()) &&
+                                !otherPair.getMatch().getProjectIdea().getProjectClass().equals(otherPair.getAvailability().getProjectClass())) {
+                            return -1;
+                        } else  if(!match.getProjectIdea().getProjectClass().equals(availability.getProjectClass()) &&
+                                otherPair.getMatch().getProjectIdea().getProjectClass().equals(otherPair.getAvailability().getProjectClass())) {
+                            return 1;
+                        } else {
+                                // the most suited supervisor is now the one that has highest slots for the specific project class
+                                if(availability.getAvailability() > otherPair.getAvailability().getAvailability()) {
+                                    return -1;
+                                } else if(otherPair.getAvailability().getAvailability() > availability.getAvailability()) {
+                                    return 1;
+                                } else {   // the project classes is the same
+                                    return 0;
+                                }
+                        }
                     }
                 }
             }
-        }
-        
-	}
+	    }
 }

src/main/java/se/su/dsv/scipro/match/dao/interfaces/KeywordDao.java

@@ -1,8 +1,10 @@
 package se.su.dsv.scipro.match.dao.interfaces;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Set;
 
+import se.su.dsv.scipro.data.dao.interfaces.Dao;
 import se.su.dsv.scipro.data.dao.interfaces.LazyDeleteDao;
 import se.su.dsv.scipro.match.dataobject.Keyword;
 import se.su.dsv.scipro.match.dataobject.KeywordType;
@@ -10,6 +12,7 @@ import se.su.dsv.scipro.match.dataobject.KeywordType;
 public interface KeywordDao extends LazyDeleteDao<Keyword>{
 
     Set<Keyword> getKeywords(KeywordType type, boolean includeDeleted);
+    List<Keyword> getKeywordList(Params params);
     
     public List<Keyword> findAllFromType(KeywordType kt, boolean includeDeleted);
     
@@ -17,4 +20,41 @@ public interface KeywordDao extends LazyDeleteDao<Keyword>{
     Keyword getKeywordByNameAndType(String keywordName, KeywordType type);
 
 
+    public static class Params extends Dao.SortableParams implements Serializable {
+
+		private static final long serialVersionUID = 5317030582030781723L;
+		
+		private String keyword;
+		private KeywordType type;
+		private boolean includeDeleted = false;
+
+		public Params() {
+			//Sort keywords on their name in ascending order as default when using Params
+			setSortOn("keyword", Sort.ASCENDING);
+		}
+		
+		public void setKeyword(String keyword) {
+			this.keyword = keyword;
+		}
+
+		public String getKeyword() {
+			return keyword;
+		}
+
+		public void setType(KeywordType type) {
+			this.type = type;
+		}
+
+		public KeywordType getType() {
+			return type;
+		}
+
+		public void setIncludeDeleted(boolean includeDeleted) {
+			this.includeDeleted = includeDeleted;
+		}
+
+		public boolean isIncludeDeleted() {
+			return includeDeleted;
+		}
+    }
 }

src/main/java/se/su/dsv/scipro/match/dao/jpa/KeywordDaoJPAImp.java

@@ -14,6 +14,7 @@ import org.springframework.orm.jpa.JpaCallback;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 
+import se.su.dsv.scipro.data.dao.jpa.AbstractQuerySet;
 import se.su.dsv.scipro.data.dao.jpa.AbstractSortableQuerySet;
 import se.su.dsv.scipro.data.dao.jpa.LazyDeleteAbstractDaoJPAImp;
 import se.su.dsv.scipro.data.dao.jpa.Query;
@@ -41,6 +42,18 @@ public class KeywordDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<Keyword> imple
         }
     }
 
+    @Override
+    public List<Keyword> getKeywordList(Params params) {
+    	return getJpaTemplate().execute(createQuerySet(params).fetchCallback());
+    }
+    
+    private AbstractQuerySet<Keyword> createQuerySet(Params params) {
+        return new QuerySet()
+        	.type(params.getType())
+        	.includeDeleted(params.isIncludeDeleted())
+        	.sort(params);
+    }
+    
     private static class QuerySet extends AbstractSortableQuerySet<Keyword> {
         public QuerySet() {
             super(Keyword.class);
@@ -55,6 +68,14 @@ public class KeywordDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<Keyword> imple
             return this;
         }
         
+        public QuerySet includeDeleted(boolean includeDeleted) {
+        	if(!includeDeleted) {
+        		getQuery().combine(
+        				new Query().where("k.deleted = false"));
+        	}
+        	return this;
+        }
+        
         public QuerySet noDeleted() {
         	getQuery().combine(
         		new Query().where("k.deleted = false"));

src/main/java/se/su/dsv/scipro/match/dataobject/Availability.java

@@ -53,7 +53,7 @@ public class Availability implements Serializable {
     public void setNumMatched(Long num) {
     	numMatched = num;
     }
-    
+
     @Override
     public String toString() {
         return "Availability [supervisorId=" + supervisor + ", numMatched="

src/main/java/se/su/dsv/scipro/match/dataprovider/KeywordsDataProvider.java

@@ -5,6 +5,7 @@ import java.util.Iterator;
 import org.apache.wicket.spring.injection.annot.SpringBean;
 
 import se.su.dsv.scipro.data.dao.interfaces.Dao;
+import se.su.dsv.scipro.data.dao.interfaces.Dao.SortableParams.Sort;
 import se.su.dsv.scipro.dataproviders.SortSpecifier;
 import se.su.dsv.scipro.dataproviders.SortableDataProvider;
 import se.su.dsv.scipro.match.dao.interfaces.KeywordDao;
@@ -15,29 +16,34 @@ public class KeywordsDataProvider extends SortableDataProvider<Keyword>{
 
 	private static final long serialVersionUID = 1L;
 
-	private KeywordType keywordType = null;
-
 	@SpringBean
 	protected KeywordDao keywordDao;
+	private KeywordDao.Params params;
 
 	@Override
 	protected Dao<Keyword> getDao() {
 		return keywordDao;
 	}
 	
-	public KeywordsDataProvider(final SortSpecifier sortSpecifier, KeywordType keywordType) {
+	public KeywordsDataProvider(KeywordType keywordType, boolean includeDeleted) {
+		this(null, keywordType, includeDeleted);
+	}
+	
+	public KeywordsDataProvider(final SortSpecifier sortSpecifier, KeywordType keywordType, boolean includeDeleted) {
 		super(sortSpecifier, Keyword.class);
-		this.keywordType = keywordType;
+		params = new KeywordDao.Params();
+		params.setIncludeDeleted(includeDeleted);
+		params.setType(keywordType);
 	}
 	
 	public Iterator<Keyword> iterator(int first, int count) {
-		Iterator<Keyword> iter = keywordDao.getKeywords(keywordType, true).iterator();
+		Iterator<Keyword> iter = keywordDao.getKeywordList(params).iterator();
 		return iter;
 	}
 	
 	@Override
 	public int size() {
-		return keywordDao.getKeywords(keywordType, true).size();
+		return keywordDao.getKeywordList(params).size();
 	}
 
 }

src/main/java/se/su/dsv/scipro/match/panel/FilterFormKeywordPanel.java

@@ -47,8 +47,10 @@ public class FilterFormKeywordPanel extends Panel {
 		
 		
 		KeywordType kwType = keywordTypeDao.findByType(type);
-		Set<Keyword> tmpWords = keywordDao.getKeywords(kwType, true);
-		keywords = new ArrayList<Keyword>(tmpWords);
+		KeywordDao.Params params = new KeywordDao.Params();
+		params.setType(kwType);
+		params.setIncludeDeleted(true);
+		keywords = keywordDao.getKeywordList(params);
 		CompoundPropertyModel<List<Keyword>> keyWordModel = new CompoundPropertyModel<List<Keyword>>(keywords);
 		
 		checkGroup = new CheckGroup<Keyword>("checkGroup", new ArrayList<Keyword>());

src/main/java/se/su/dsv/scipro/project/panels/KeywordSelectionPanel.java

@@ -133,8 +133,9 @@ public class KeywordSelectionPanel extends Panel {
 		if (keywordProvider.getObject() != null) {
 			ideaAreaKeywords = new ArrayList<Keyword>(keywordProvider.getObject().getKeywords().getFiltered(area));
 		}
-		Set<Keyword> areaKeySet = keywordDao.getKeywords(area, false);
-		List<Keyword> areaKeyList = new ArrayList<Keyword>(areaKeySet);
+		KeywordDao.Params params = new KeywordDao.Params();
+		params.setType(area);
+		List<Keyword> areaKeyList = keywordDao.getKeywordList(params);
 		CompoundPropertyModel<List<Keyword>> listModel = new CompoundPropertyModel<List<Keyword>>(areaKeyList);
 		
 		researchAreaGroup = new CheckGroup<Keyword>("researchAreaGroup", ideaAreaKeywords);
@@ -162,13 +163,18 @@ public class KeywordSelectionPanel extends Panel {
 		}
 	}
 	private void addRegularKeywordSelection() {
-		KeywordType keyword = keywordTypeDao.findByType(KeywordTypeDao.TYPE.REGULAR);
-		List<Keyword> selectedWords = keywordProvider.getObject().getKeywords().getFiltered(keyword);
+		KeywordType keywordType = keywordTypeDao.findByType(KeywordTypeDao.TYPE.REGULAR);
+		List<Keyword> selectedWords = keywordProvider.getObject().getKeywords().getFiltered(keywordType);
 		ideaKeywords = new ArrayList<Keyword>();
 		if(!selectedWords.isEmpty()) 
 			ideaKeywords = new ArrayList<Keyword>(selectedWords);
 		
-		Set<Keyword> keySet = keywordDao.getKeywords(keyword, false);
+		KeywordDao.Params params = new KeywordDao.Params();
+		params.setType(keywordType);
+		
+		List<Keyword> keywordList = keywordDao.getKeywordList(params);
+		Set<Keyword> keySet = new HashSet<Keyword>(keywordList);
+		//Set<Keyword> keySet = keywordDao.getKeywords(keywordType, false);
 		regularKeywordsPalette = new Palette<Keyword>("keywordPalette",
 				new ListModel<Keyword>(ideaKeywords),
 				new CollectionModel<Keyword>(keySet),

src/test/java/se/su/dsv/scipro/match/TestGreedyMatchingAlgorithm.java

@@ -71,8 +71,9 @@ public class TestGreedyMatchingAlgorithm {
     private Set<Language> languages;
     private KeywordType keywordTypeArea;
     private KeywordType keywordTypeWord;
+    private ApplicationPeriod applicationPeriod;
 
-    private Employee createSupervisor(final String firstName, final String lastName, Set<Language> languages1) {
+    private Employee createEmployee(final String firstName, final String lastName, Set<Language> languages1) {
         Employee employee = new Employee();
         User user = new User();
         user.setFirstName(firstName);
@@ -109,17 +110,30 @@ public class TestGreedyMatchingAlgorithm {
         keywordTypeWord = keywordTypeDao.save(new KeywordType("Word"));
     }
 
-    private void addKeyWords(final Employee supervisor, final ProjectIdea projectIdea, final Keyword keyword) {
-        supervisor.getKeywords().getAll().add(keyword);
-        projectIdea.getKeywords().getAll().add(keyword);
+    private void addKeyWords(List<Employee> supervisorList, List<ProjectIdea> projectIdeaList, final Keyword keyword) {
+        if(supervisorList != null && !supervisorList.isEmpty()) {
+            for(int i = 0; i < supervisorList.size(); i++) {
+                supervisorList.get(i).getKeywords().getAll().add(keyword);
+            }
+        }
+        if(projectIdeaList != null && !projectIdeaList.isEmpty()) {
+            for(int i = 0; i < projectIdeaList.size(); i++) {
+                projectIdeaList.get(i).getKeywords().getAll().add(keyword); 
+            }
+        }
     }
 
     private Keyword createKeyword(final KeywordType keyWordType , final String keyWordName, final boolean deleted) {
-        Keyword keyword = new Keyword();
-        keyword.setType(keyWordType);
-        keyword.setKeyword(keyWordName);
-        keyword.setDeleted(deleted);
-        return keywordDao.save(keyword);
+        Keyword keyword = keywordDao.getKeywordByNameAndType(keyWordName, keyWordType);
+        if(keyword == null)  {
+            keyword = new Keyword();
+            keyword.setType(keyWordType);
+            keyword.setKeyword(keyWordName);
+            keyword.setDeleted(deleted);
+            return keywordDao.save(keyword);
+        } else {
+            return keyword;
+        }
     }
 
     @Before
@@ -131,17 +145,17 @@ public class TestGreedyMatchingAlgorithm {
         languages = new HashSet<Language>();
         languages.add(languageDao.save(new Language("Swedish")));
         languages.add(languageDao.save(new Language("English")));
-        bachelorSupervisor = createSupervisor("Henrik", "Hansson", languages);
+        bachelorSupervisor = createEmployee("Henrik", "Hansson", languages);
 		bachelorProjectClass = createProjectClass(ProjectClass.BACHELOR, "Bachelor", "Bachelor project class");
         Set<ProjectClass> projectClassSet = new HashSet<ProjectClass>();
         projectClassSet.add(bachelorProjectClass);
         projectClassSet.add(masterProjectClass);
         List<ApplicationPeriod> myList = new ArrayList<ApplicationPeriod>();
         myList.addAll(applicationPeriodDao.findAll());
-        ApplicationPeriod applicationPeriod = applicationPeriodFacade.createApplicationPeriod(projectClassSet, "name1");
+        applicationPeriod = applicationPeriodFacade.createApplicationPeriod(projectClassSet, "name1");
         
         bachelorProjectIdea = createProjectIdea(bachelorProjectClass, applicationPeriod);
-        masterSupervisor = createSupervisor("Birger", "Andersson", languages);
+        masterSupervisor = createEmployee("Birger", "Andersson", languages);
         masterProjectClass = createProjectClass(ProjectClass.MASTER, "Master", "Master project class");
         masterProjectIdea = createProjectIdea(masterProjectClass, applicationPeriod);
 	}
@@ -239,10 +253,14 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /* a bachelor supervisor can handle a projectIdea which has been rejected by another (bachelor) supervisor, even if the other supervisor has a higher score */
     public void testRejectByOtherSupervisor()  {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "test unit", false));   // 3
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "test unit", false));   // 3
         addRejectedMatch(bachelorSupervisor2, bachelorProjectIdea);
         unmatchedProjectIdeas.add(bachelorProjectIdea);
         Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
@@ -256,7 +274,7 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /* a preferred bachelor supervisor should be chosen prior to another bachelor supervisor */
 	public void testPreferredSupervisor() {
-		Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+		Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
 		bachelorProjectIdea.setPreferredSupervisor(bachelorSupervisor2);
@@ -274,7 +292,7 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /* a preferred "bachelor" supervisor should NOT handle a master projectIdea */
     public void testIncorrectProjectClass() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(masterSupervisor, 0L, 1, masterProjectClass));
         masterProjectIdea.setPreferredSupervisor(bachelorSupervisor2);
@@ -291,10 +309,14 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /* keywords of 16 points should supersede a preferred supervisor of 15 points */
     public void testHighestScore() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeArea, "test area", false));   // 10
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "test unit", false));   // 3
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "Java", false));        // 3
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeArea, "test area", false));   // 10
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "test unit", false));   // 3
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Java", false));        // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         bachelorProjectIdea.setPreferredSupervisor(bachelorSupervisor);                                      // 15
@@ -311,10 +333,16 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  keywords of 6 points should supersede keywords of 3 points */
     public void testHighestScore_v2() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "test unit", false));   // 3
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", false));         // 3
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "Design", false));      // 3
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "test unit", false));   // 3
+        supervisorList.clear();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", false));         // 3
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Design", false));      // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -330,10 +358,16 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  deleted keywords of 6 points should NOT supersede valid keywords of 3 points */
     public void testHighestScore_v3() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "test unit", false));   // 3
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", true));         // 3
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "Design", true));      // 3
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "test unit", false));   // 3
+        supervisorList.clear();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", true));         // 3
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Design", true));      // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -352,18 +386,23 @@ public class TestGreedyMatchingAlgorithm {
         Set<Language> languageSet = new HashSet<Language>();
         Language language_sv = languageDao.save(new Language("Swedish"));
         languageSet.add(language_sv);
-        Employee bachelorSupervisor_sv = createSupervisor("David", "Hallberg", languageSet);
+        Employee bachelorSupervisor_sv = createEmployee("David", "Hallberg", languageSet);
 
         bachelorSupervisor.getCapabilities().getLanguages().clear();
         bachelorSupervisor.getCapabilities().getLanguages().add(languageDao.save(new Language("English")));
         bachelorProjectIdea.getLanguages().clear();
         bachelorProjectIdea.getLanguages().add(language_sv);
         bachelorProjectIdea.setPreferredSupervisor(bachelorSupervisor);                         // 15
-
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "C++", false));      // 3
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "Java", false));     // 3
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "Design", false));   // 3
-        addKeyWords(bachelorSupervisor_sv, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", false));   // 3
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "C++", false));      // 3
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Java", false));     // 3
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Design", false));   // 3
+        supervisorList.clear();
+        supervisorList.add(bachelorSupervisor_sv);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", false));   // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor_sv, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -379,10 +418,14 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  a supervisor should not be chosen if he/she is "deleted"  */
     public void testForDeletedSupervisor() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         bachelorSupervisor2.setDeleted(true);
 
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", false));         // 3
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", false));         // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -399,13 +442,16 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  a supervisor cannot be supervisor to herself  */
     public void testSupervisorCannotSuperviseHerself() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         Role role = new Student();
         role.setUser(bachelorSupervisor2.getUser());
         role = roleDao.save(role);
         bachelorProjectIdea.getAuthors().add((Student) role);
-
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", false));         // 3
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", false));         // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -422,8 +468,12 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  the supervisor with no available "slots" should NOT be chosen even when this supervisor has the highest score */
     public void testNoAvailableSlots() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "Design", false));   // 3
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Design", false));   // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 1L, 1, bachelorProjectClass));    // availability = numCapable - numMatched
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -441,9 +491,12 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  a supervisor with the highest available slot should NOT be chosen when this supervisor has less score */
     public void testHighestAvailableSlot() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-
-        addKeyWords(bachelorSupervisor, bachelorProjectIdea, createKeyword(keywordTypeWord, "UML", false));         // 3
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "UML", false));         // 3
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 4, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -460,7 +513,7 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  test that the number Availability#numMatched has increased with one and that the supervisor with highest available slots are chosen  */
     public void testNumMatchedHasIncreased() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 4, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
@@ -497,10 +550,14 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  neither a bachelor or a master supervisor are preferred to handle a bachelor idea when compatibility, keywords, scores etc are equal   */
     public void testBachelorOrMaster() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+        Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(masterSupervisor, 0L, 1, bachelorProjectClass));
         supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
-        addKeyWords(bachelorSupervisor2, bachelorProjectIdea, createKeyword(keywordTypeWord, "Design", false));
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        projectIdeaList.add(bachelorProjectIdea);
+        List<Employee> supervisorList = new ArrayList<Employee>();
+        supervisorList.add(bachelorSupervisor2);
+        addKeyWords(supervisorList, projectIdeaList, createKeyword(keywordTypeWord, "Design", false));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
         Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
         assertTrue(result.matches.size() > 0);
@@ -514,13 +571,14 @@ public class TestGreedyMatchingAlgorithm {
     @Rollback
     /*  test that a master which has filled up his slot for bachelor but has slots left for master can supervise a bachelor idea */
     public void testSlotForMasterSupervisor() {
-//Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
+//Employee bachelorSupervisor2 = createEmployee("David", "Hallberg", languages);
         supervisorAvailability.add(new Availability(masterSupervisor, 3L, 3, bachelorProjectClass));
         supervisorAvailability.add(new Availability(masterSupervisor, 3L, 4, bachelorProjectClass));
 //supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
         Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
         assertTrue(result.matches.size() > 0);
+
         assertTrue(result.matches.get(0).getProjectIdea().equals(bachelorProjectIdea));
         assertTrue(result.matches.get(0).getSupervisor().equals(masterSupervisor));
         assertTrue(result.unmatched.size() == 0);
@@ -529,71 +587,131 @@ public class TestGreedyMatchingAlgorithm {
     @Test
     @Transactional
     @Rollback
-    /*  test that a master which has filled up his slot for bachelor but has slots left for master can supervise a bachelor idea */
+    /*  test that the supervisor who has the highest total slot available will be chosen */
     public void testIncreaseSlotForMasterSupervisor() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        supervisorAvailability.add(new Availability(masterSupervisor, 3L, 3, bachelorProjectClass));
-        supervisorAvailability.add(new Availability(masterSupervisor, 3L, 4, masterProjectClass));
-        supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
-        unmatchedProjectIdeas.add(bachelorProjectIdea);
-        bachelorProjectIdea.setPreferredSupervisor(masterSupervisor);
-        Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
-        assertTrue(result.matches.size() > 0);
-        assertTrue(result.matches.get(0).getProjectIdea().equals(bachelorProjectIdea));
-        assertTrue(result.matches.get(0).getSupervisor().equals(masterSupervisor));
-        assertTrue(result.unmatched.size() == 0);
-// increase num capable for the supervisor
+        Employee davidH = createEmployee("David", "Hallberg", languages);
+        Employee henrikH = createEmployee("Henrik", "Hansson", languages);
+//ProjectIdea firstBachelorIdea = createProjectIdea(bachelorProjectClass, applicationPeriod);
+        supervisorAvailability.add(new Availability(henrikH, 2L, 3, bachelorProjectClass)); // total slot = 2
+        supervisorAvailability.add(new Availability(henrikH, 3L, 4, masterProjectClass));
+        supervisorAvailability.add(new Availability(davidH, 1L, 1, bachelorProjectClass));          // total slot = 1
+        supervisorAvailability.add(new Availability(davidH, 0L, 1, masterProjectClass));
         unmatchedProjectIdeas.add(masterProjectIdea);
-        for (Availability availability : supervisorAvailability) {
-            if(availability.getProjectClass().equals(masterProjectClass)) {
-                availability.setNumCapable(availability.getNumCapable() + 1);
-            }
-        }
-        result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
+        unmatchedProjectIdeas.add(bachelorProjectIdea);
+
+        Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
         assertTrue(result.matches.size() > 0);
         assertTrue(result.matches.get(0).getProjectIdea().equals(masterProjectIdea));
-        assertTrue(result.matches.get(0).getSupervisor().equals(masterSupervisor));
+        assertTrue(result.matches.get(0).getSupervisor().equals(henrikH));
+        assertTrue(result.matches.get(1).getProjectIdea().equals(bachelorProjectIdea));
+        assertTrue(result.matches.get(1).getSupervisor().equals(henrikH));
         assertTrue(result.unmatched.size() == 0);
     }
 
     @Test
     @Transactional
     @Rollback
-    /*  test that a master which has filled up his slot for bachelor but has slots left for master can supervise a bachelor idea */
+    /*  test that a master supervisor is chosen for a master project idea which has the same points as a bachelor project idea */
     public void testIncreaseSlotForMasterSupervisor_v2() {
-        Employee bachelorSupervisor2 = createSupervisor("David", "Hallberg", languages);
-        supervisorAvailability.add(new Availability(masterSupervisor, 3L, 3, bachelorProjectClass));
-        supervisorAvailability.add(new Availability(masterSupervisor, 3L, 4, masterProjectClass));
-        supervisorAvailability.add(new Availability(bachelorSupervisor2, 0L, 1, bachelorProjectClass));
+        Employee davidH = createEmployee("David", "Hallberg", languages);
+        Employee henrikH = createEmployee("Henrik", "Hansson", languages);
+        supervisorAvailability.add(new Availability(henrikH, 3L, 3, bachelorProjectClass));
+        supervisorAvailability.add(new Availability(henrikH, 3L, 4, masterProjectClass));
+        supervisorAvailability.add(new Availability(davidH, 0L, 1, bachelorProjectClass));
         unmatchedProjectIdeas.add(bachelorProjectIdea);
         unmatchedProjectIdeas.add(masterProjectIdea);
-        bachelorProjectIdea.setPreferredSupervisor(masterSupervisor);
-        masterProjectIdea.setPreferredSupervisor(masterSupervisor);
-        addKeyWords(masterSupervisor, masterProjectIdea, createKeyword(keywordTypeWord, "UML", false));
+        bachelorProjectIdea.setPreferredSupervisor(henrikH);
+        masterProjectIdea.setPreferredSupervisor(henrikH);
         Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
-        assertTrue(result.matches.size() > 0);            
-        boolean foundMasterProjIdea = false;
-        boolean foundMasterSuperVisor= false;
-
-        boolean foundBachelorProjIdea = false;
-        boolean foundBachelorSuperVisor= false;
-
-        for(Match match : result.matches) {
-            if(match.getProjectIdea().equals(masterProjectIdea) && match.getSupervisor().equals(masterSupervisor)) {
-                foundMasterProjIdea = true;
-                foundMasterSuperVisor = true;
-            }
-
-            if(match.getProjectIdea().equals(bachelorProjectIdea) && match.getSupervisor().equals(bachelorSupervisor2)) {
-                foundBachelorProjIdea = true;
-                foundBachelorSuperVisor = true;
-            }
-        }
-        assertTrue(foundMasterProjIdea);
-        assertTrue(foundBachelorProjIdea);
-        assertTrue(foundBachelorSuperVisor);
-        assertTrue(foundMasterSuperVisor);
+        assertTrue(result.matches.size() > 0);
+        assertTrue(result.matches.get(0).getPoints() == 10);
+        assertTrue(result.matches.get(1).getPoints() == 0);
+        assertTrue(result.matches.get(0).getSupervisor().equals(henrikH));
+        assertTrue(result.matches.get(1).getSupervisor().equals(davidH));
+        assertTrue(result.matches.get(0).getProjectIdea().equals(masterProjectIdea));
+        assertTrue(result.matches.get(1).getProjectIdea().equals(bachelorProjectIdea));
         assertTrue(result.unmatched.size() == 0);
     }
 
+    @Test
+    @Transactional
+    @Rollback
+    /*  three supervisors which are matched against three project ideas  */
+    public void testIncreaseSlotForMasterSupervisor_v3() {
+        List<ProjectIdea> projectIdeaList = new ArrayList<ProjectIdea>();
+        List<Employee> supervisorList = new ArrayList<Employee>();
+
+        Employee davidH = createEmployee("David", "Hallberg", languages);
+        supervisorAvailability.clear();
+        supervisorAvailability.add(new Availability(davidH, 0L, 5, bachelorProjectClass));
+        supervisorAvailability.add(new Availability(davidH, 0L, 5, masterProjectClass));
+
+        supervisorList.clear();
+        supervisorList.add(davidH);
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeArea, "IT för lärande", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "Business process management (BPM)", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "Flexibelt lärande", false));
+
+        Employee henrikH = createEmployee("Henrik", "Hansson", languages);
+        supervisorAvailability.add(new Availability(henrikH, 0L, 5, bachelorProjectClass));
+        supervisorAvailability.add(new Availability(henrikH, 0L, 5, masterProjectClass));
+
+        supervisorList.clear();
+        supervisorList.add(henrikH);
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeArea, "Technology Enhanced Learning", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeArea, "ICT for Development", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "Flexibelt lärande", false));
+
+        Employee henrikBergstr = createEmployee("Henrik", "Bergström", languages);        // login henrikbe
+        supervisorAvailability.add(new Availability(henrikBergstr, 0L, 5, bachelorProjectClass));
+        supervisorAvailability.add(new Availability(henrikBergstr, 0L, 5, masterProjectClass));
+
+        supervisorList.clear();
+        supervisorList.add(henrikBergstr);
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "ACT Agera i kommunikation med teknik", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "System development", false));
+        addKeyWords(supervisorList, null, createKeyword(keywordTypeWord, "IT-architectures", false));
+
+        ProjectIdea firstBachelorIdea = createProjectIdea(bachelorProjectClass, applicationPeriod);
+        projectIdeaList.clear();
+        projectIdeaList.add(firstBachelorIdea); // no preferred supervisor for this project idea
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeArea, "ICT for Development", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeWord, "System development", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeWord, "Enterprise 2.0", false));
+
+        ProjectIdea masterIdea = createProjectIdea(masterProjectClass, applicationPeriod);
+        projectIdeaList.clear();
+        projectIdeaList.add(masterIdea); // no preferred supervisor for this project idea
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeArea, "Interaction design", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeArea, "ICT for Development", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeArea, "Digital Systems Security", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeWord, "System development", false));
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeWord, "Information system theory", false));
+
+        ProjectIdea secondBachelorIdea = createProjectIdea(bachelorProjectClass, applicationPeriod);
+        projectIdeaList.clear();
+        projectIdeaList.add(secondBachelorIdea); // David Hallberg is preferred supervisor for this project idea
+        secondBachelorIdea.setPreferredSupervisor(davidH);
+        addKeyWords(null, projectIdeaList, createKeyword(keywordTypeArea, "E-government and E-democracy", false));
+
+        unmatchedProjectIdeas.clear();
+        unmatchedProjectIdeas.add(firstBachelorIdea);
+        unmatchedProjectIdeas.add(secondBachelorIdea);
+        unmatchedProjectIdeas.add(masterIdea);
+
+        Result result = new GreedyMatchingAlgorithm().match(supervisorAvailability, unmatchedProjectIdeas, weights);
+        assertTrue(result.matches.size() == 3);
+
+        assertTrue(result.matches.get(0).getPoints() == 10);
+        assertTrue(result.matches.get(1).getPoints() == 5);
+        assertTrue(result.matches.get(2).getPoints() == 5);
+
+        assertTrue(result.matches.get(0).getSupervisor().equals(davidH));
+        assertTrue(result.matches.get(1).getSupervisor().equals(henrikH));
+        assertTrue(result.matches.get(2).getSupervisor().equals(henrikH));
+
+        assertTrue(result.matches.get(0).getProjectIdea().equals(secondBachelorIdea));
+        assertTrue(result.matches.get(1).getProjectIdea().equals(firstBachelorIdea));
+        assertTrue(result.matches.get(2).getProjectIdea().equals(masterIdea));
+    }
 }

src/test/java/se/su/dsv/scipro/match/dao/TestKeywordDao.java

@@ -1,6 +1,7 @@
 package se.su.dsv.scipro.match.dao;
 
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import org.junit.Assert;
@@ -70,6 +71,12 @@ public class TestKeywordDao {
         Set<Keyword> keywords = target.getKeywords(standard, true);
         Assert.assertEquals(new HashSet<Keyword>(
             Arrays.asList(new Keyword[] { keyword1, keyword2 })), keywords);
+        
+        KeywordDao.Params params = new KeywordDao.Params();
+        params.setType(standard);
+        
+        List<Keyword> keywordList = target.getKeywordList(params);
+        Assert.assertEquals(Arrays.asList(new Keyword[]{keyword1, keyword2}), keywordList);
     }
 
     @Test