Groups Filter extracted

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/data/Person.java

@@ -2,6 +2,7 @@ package de.kreth.vaadin.clubhelper.vaadinclubhelper.data;
 
 import java.io.Serializable;
 import java.time.LocalDate;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -57,7 +58,7 @@ public class Person extends BaseEntity implements Serializable {
 	@ManyToMany(fetch = FetchType.EAGER)
 	@JoinTable(name = "persongroup", joinColumns = { @JoinColumn(name = "person_id") }, inverseJoinColumns = {
 			@JoinColumn(name = "group_id") })
-	private List<GroupDef> groups;
+	private Set<GroupDef> groups;
 
 	// bi-directional many-to-one association to Relative
 	@OneToMany(mappedBy = "person1Bean")
@@ -114,16 +115,19 @@ public class Person extends BaseEntity implements Serializable {
 		this.username = username;
 	}
 
-	public List<GroupDef> getGroups() {
+	public Set<GroupDef> getGroups() {
 		return groups;
 	}
 
-	public void setGroups(List<GroupDef> groups) {
+	public void setGroups(Set<GroupDef> groups) {
 		this.groups = groups;
 	}
 
 	public void add(GroupDef group) {
-
+		if (this.groups == null) {
+			this.groups = new HashSet<>();
+		}
+		this.groups.add(group);
 	}
 
 	public Set<ClubEvent> getEvents() {
@@ -211,20 +215,29 @@ public class Person extends BaseEntity implements Serializable {
 		return contact;
 	}
 
-	public List<GroupDef> getPersongroups() {
+	public Set<GroupDef> getPersongroups() {
 		return this.groups;
 	}
 
-	public void setPersongroups(List<GroupDef> persongroups) {
+	public void setPersongroups(Collection<GroupDef> persongroups) {
-		this.groups = persongroups;
+		if (persongroups instanceof Set) {
+			this.groups = (Set<GroupDef>) persongroups;
+		} else {
+			this.groups = new HashSet<>(persongroups);
+		}
 	}
 
 	public void addPersongroup(GroupDef persongroup) {
-		getPersongroups().add(persongroup);
+		if (this.groups == null) {
+			this.groups = new HashSet<>();
+		}
+		this.groups.add(persongroup);
 	}
 
 	public void removePersongroup(GroupDef persongroup) {
-		getPersongroups().remove(persongroup);
+		if (this.groups == null) {
+			this.groups.remove(persongroup);
+		}
 	}
 
 	public List<Relative> getRelatives1() {

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/components/PersonEditDialog.java

@@ -2,6 +2,7 @@ package de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.components;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
 import org.vaadin.teemu.switchui.Switch;
 
@@ -74,7 +75,7 @@ public class PersonEditDialog extends Window {
 
 	private void groupChanged(ValueChangeEvent<Boolean> ev) {
 		GroupDef group = (GroupDef) ((Switch) ev.getComponent()).getData();
-		List<GroupDef> pg = person.getPersongroups();
+		Set<GroupDef> pg = person.getPersongroups();
 		if (ev.getValue()) {
 			pg.add(group);
 		} else {
@@ -82,5 +83,4 @@ public class PersonEditDialog extends Window {
 		}
 	}
 
-	
 }

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/components/PersonFilter.java

@@ -1,5 +1,6 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.components;
 
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -23,14 +24,17 @@ public class PersonFilter implements SerializablePredicate<Person> {
 		if (personSelected(t) == false) {
 			return false;
 		}
-//		if (personInGroup(t) == false) {
+		if (personInGroup(t) == false) {
-//			return false;
+			return false;
-//		}
+		}
 		return true;
 	}
 
 	private boolean personInGroup(Person t) {
-		return selectedGroups != null;
+		if (selectedGroups != null) {
+			return t.getGroups() != null && !Collections.disjoint(t.getGroups(), selectedGroups);
+		}
+		return true;
 	}
 
 	private boolean personSelected(Person t) {
@@ -42,7 +46,7 @@ public class PersonFilter implements SerializablePredicate<Person> {
 		return true;
 	}
 
-	public void setSelected(Set<Person> selected) {
+	public void setSelectedPersons(Set<Person> selected) {
 		if (selected == null) {
 			selectedPersons = null;
 			return;
@@ -53,4 +57,8 @@ public class PersonFilter implements SerializablePredicate<Person> {
 		}
 	}
 
+	public void setSelectedGroups(Set<GroupDef> selected) {
+		this.selectedGroups = selected;
+	}
+
 }

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/components/PersonGrid.java

@@ -141,7 +141,7 @@ public class PersonGrid extends CustomComponent {
 			});
 
 			filter = filter.and(p -> {
-				List<GroupDef> personGroups = p.getPersongroups();
+				Set<GroupDef> personGroups = p.getPersongroups();
 				for (GroupDef pg : personGroups) {
 					if (groupIds.contains(pg.getId())) {
 						return true;

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/components/PersonFilterTest.java

@@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -13,54 +14,100 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.AbstractDatabaseTest;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.GroupDef;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
 
 class PersonFilterTest {
 
 	private PersonFilter filter;
 	private List<Person> persons;
+	private final List<GroupDef> groups;
+
+	public PersonFilterTest() {
+		GroupDef adminGroup = new GroupDef();
+		adminGroup.setId(1);
+		adminGroup.setName("ADMIN");
+
+		GroupDef competitorGroup = new GroupDef();
+		competitorGroup.setName("Wettkämpfer");
+		competitorGroup.setId(2);
+
+		GroupDef participantGroup = new GroupDef();
+		participantGroup.setName("ACTIVE");
+		participantGroup.setId(3);
+
+		GroupDef judgesGroup = new GroupDef();
+		judgesGroup.setName("Kampfrichter");
+		judgesGroup.setId(4);
+
+		groups = Collections
+				.unmodifiableList(Arrays.asList(adminGroup, competitorGroup, participantGroup, judgesGroup));
+
+	}
 
 	@BeforeEach
 	void setUp() throws Exception {
 		filter = new PersonFilter();
 		persons = AbstractDatabaseTest.createPersons(5);
 		assertEquals(5, persons.size());
+
+		for (int i = 0; i < groups.size(); i++) {
+			persons.get(i).add(groups.get(i));
+			persons.get(0).add(groups.get(i)); // Person1 has all Rights.
+		}
+
+		assertEquals(groups.size(), persons.get(0).getGroups().size());
 	}
 
 	@Test
 	void testNoFilterSet() {
-		allAccepted();
+		allPersonsAccepted();
 
 		assertTrue(filter.test(null));
 	}
 
 	@Test
-	void testSelectionFilter() {
+	void testPersonSelectionFilter() {
 		Set<Person> selected = new HashSet<>(persons.subList(2, 4));
-		filter.setSelected(selected);
+		filter.setSelectedPersons(selected);
 		assertFalse(filter.test(persons.get(0)));
 		assertFalse(filter.test(persons.get(1)));
 		assertFalse(filter.test(persons.get(4)));
 		assertTrue(filter.test(persons.get(2)));
 		assertTrue(filter.test(persons.get(3)));
 
-		filter.setSelected(null);
+		filter.setSelectedPersons(null);
 		testNoFilterSet();
 
-		filter.setSelected(Collections.emptySet());
+		filter.setSelectedPersons(Collections.emptySet());
-		allFiltered();
+		allPersonsFiltered();
+
+		filter.setSelectedPersons(new HashSet<>(persons));
+		allPersonsAccepted();
+	}
+
+	@Test
+	void testGroupSelection() {
+		Set<GroupDef> selected = new HashSet<>();
+		selected.add(groups.get(2));
+		filter.setSelectedGroups(selected);
+
+		assertTrue(filter.test(persons.get(0)));
+		assertTrue(filter.test(persons.get(2)));
+
+		assertFalse(filter.test(persons.get(1)));
+		assertFalse(filter.test(persons.get(3)));
+		assertFalse(filter.test(persons.get(4)));
 
-		filter.setSelected(new HashSet<>(persons));
-		allAccepted();
 	}
 
-	public void allAccepted() {
+	public void allPersonsAccepted() {
 		for (Person p : persons) {
 			assertTrue(filter.test(p));
 		}
 	}
 
-	public void allFiltered() {
+	public void allPersonsFiltered() {
 		for (Person p : persons) {
 			assertFalse(filter.test(p));
 		}