OO-662: optimize the members view of course and group. I make three queries to...

OO-662: optimize the members view of course and group. I make three queries to prevent to attack with the o_bs_membership, and prevent a cross product

src/main/java/org/olat/group/BusinessGroupService.java

@@ -520,6 +520,15 @@ public interface BusinessGroupService {
 	 */
 	public List<BusinessGroupMembership> getBusinessGroupMembership(Collection<Long> businessGroups, Identity... identity);
 
+	/**
+	 * Return the list of membership of the groups. A membership per user and per group, but
+	 * a membership can be owner and participant at the same time if the user is owner and
+	 * participant of the group.
+	 * @param businessGroups
+	 * @return
+	 */
+	public List<BusinessGroupMembership> getBusinessGroupsMembership(Collection<BusinessGroup> businessGroups);
+	
 	/**
 	 * Checks if an identity is in a business group with a specific key, either as owner or
 	 * as participant

src/main/java/org/olat/group/manager/BusinessGroupDAO.java

@@ -23,7 +23,9 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import javax.persistence.EntityManager;
 import javax.persistence.LockModeType;
@@ -45,14 +47,17 @@ import org.olat.core.util.StringHelper;
 import org.olat.group.BusinessGroup;
 import org.olat.group.BusinessGroupImpl;
 import org.olat.group.BusinessGroupLazy;
+import org.olat.group.BusinessGroupMembership;
 import org.olat.group.BusinessGroupOrder;
 import org.olat.group.BusinessGroupShort;
 import org.olat.group.BusinessGroupView;
 import org.olat.group.model.BGRepositoryEntryRelation;
 import org.olat.group.model.BGResourceRelation;
+import org.olat.group.model.BusinessGroupMembershipImpl;
 import org.olat.group.model.BusinessGroupMembershipViewImpl;
 import org.olat.group.model.BusinessGroupShortImpl;
 import org.olat.group.model.BusinessGroupViewImpl;
+import org.olat.group.model.IdentityGroupKey;
 import org.olat.group.model.SearchBusinessGroupParams;
 import org.olat.properties.Property;
 import org.olat.repository.model.RepositoryEntryMembership;
@@ -249,6 +254,82 @@ public class BusinessGroupDAO {
 		return group;
 	}
 	
+	public List<BusinessGroupMembership> getBusinessGroupsMembership(Collection<BusinessGroup> groups) {
+		
+		List<Long> ownerGroupKeys = new ArrayList<Long>();
+		List<Long> participantGroupKeys = new ArrayList<Long>();
+		List<Long> waitingGroupKeys = new ArrayList<Long>();
+		Map<Long,Long> secGroupToGroup = new HashMap<Long,Long>();
+		for(BusinessGroup group:groups) {
+			if(group.getOwnerGroup() != null) {
+				ownerGroupKeys.add(group.getOwnerGroup().getKey());
+				secGroupToGroup.put(group.getOwnerGroup().getKey(), group.getKey());
+			}
+			if(group.getPartipiciantGroup() != null) {
+				participantGroupKeys.add(group.getPartipiciantGroup().getKey());
+				secGroupToGroup.put(group.getPartipiciantGroup().getKey(), group.getKey());
+			}
+			if(group.getWaitingListEnabled() != null && group.getWaitingListEnabled().booleanValue()
+					&& group.getWaitingGroup() != null) {
+				waitingGroupKeys.add(group.getWaitingGroup().getKey());
+				secGroupToGroup.put(group.getWaitingGroup().getKey(), group.getKey());
+			}
+		}
+
+		Map<IdentityGroupKey, BusinessGroupMembershipImpl> memberships = new HashMap<IdentityGroupKey, BusinessGroupMembershipImpl>();
+		
+		loadBusinessGroupsMembership(ownerGroupKeys, memberships, secGroupToGroup, true, false, false);
+		loadBusinessGroupsMembership(participantGroupKeys, memberships, secGroupToGroup, false, true, false);
+		loadBusinessGroupsMembership(waitingGroupKeys, memberships, secGroupToGroup, false, false, true);
+
+		return new ArrayList<BusinessGroupMembership>(memberships.values());
+	}
+	
+	private void loadBusinessGroupsMembership(Collection<Long> secGroupKeys,
+			Map<IdentityGroupKey, BusinessGroupMembershipImpl> memberships,
+			Map<Long,Long> secGroupToGroup, boolean owner, boolean participant, boolean waiting) {
+		
+		if(secGroupKeys == null || secGroupKeys.isEmpty()) {
+			return;
+		}
+		
+		StringBuilder sb = new StringBuilder(); 
+		sb.append("select membership.identity.key, membership.creationDate, membership.lastModified, membership.securityGroup.key from ")
+		  .append(SecurityGroupMembershipImpl.class.getName()).append(" as membership ")
+		  .append(" where membership.securityGroup.key in (:secGroupKeys)");
+		
+		List<Object[]> members = dbInstance.getCurrentEntityManager()
+				.createQuery(sb.toString(), Object[].class)
+				.setParameter("secGroupKeys", secGroupKeys)
+				.getResultList();
+		
+		for(Object[] membership:members) {
+			Long identityKey = (Long)membership[0];
+			Date creationDate = (Date)membership[1];
+			Date lastModified = (Date)membership[2];
+			Long secGroupKey = (Long)membership[3];
+			
+			Long groupKey = secGroupToGroup.get(secGroupKey);
+
+			IdentityGroupKey key = new IdentityGroupKey(identityKey, groupKey);
+			if(!memberships.containsKey(key)) {
+				memberships.put(key, new BusinessGroupMembershipImpl(identityKey, groupKey));
+			}
+			BusinessGroupMembershipImpl mb = memberships.get(key);
+			mb.setCreationDate(creationDate);
+			mb.setLastModified(lastModified);
+			if(owner) {
+				mb.setOwner(true);
+			}
+			if(participant) {
+				mb.setParticipant(true);
+			}
+			if(waiting) {
+				mb.setWaiting(true);
+			}	
+		}
+	}
+	
 	public int countMembershipInfoInBusinessGroups(Identity identity, List<Long> groupKeys) {
 		StringBuilder sb = new StringBuilder(); 
 		sb.append("select count(membership) from ").append(BusinessGroupMembershipViewImpl.class.getName()).append(" as membership ")

src/main/java/org/olat/group/manager/BusinessGroupServiceImpl.java

@@ -1654,6 +1654,11 @@ public class BusinessGroupServiceImpl implements BusinessGroupService, UserDataD
 		return false;
 	}
 
+	@Override
+	public List<BusinessGroupMembership> getBusinessGroupsMembership(Collection<BusinessGroup> businessGroups) {
+		return businessGroupDAO.getBusinessGroupsMembership(businessGroups);
+	}
+
 	@Override
 	public List<BusinessGroupMembership> getBusinessGroupMembership(Collection<Long> businessGroups, Identity... identity) {
 		List<BusinessGroupMembershipViewImpl> views =

src/main/java/org/olat/group/ui/main/AbstractMemberListController.java

@@ -558,8 +558,9 @@ public abstract class AbstractMemberListController extends BasicController imple
 			groupKeys.add(group.getKey());
 			keyToGroupMap.put(group.getKey(), group);
 		}
+
 		List<BusinessGroupMembership> memberships = groups.isEmpty() ? Collections.<BusinessGroupMembership>emptyList() :
-				businessGroupService.getBusinessGroupMembership(groupKeys);
+			businessGroupService.getBusinessGroupsMembership(groups);
 
 		//get identities
 		Set<Long> identityKeys = new HashSet<Long>();

src/test/java/org/olat/group/test/BusinessGroupDAOTest.java

@@ -44,6 +44,7 @@ import org.olat.core.logging.OLog;
 import org.olat.core.logging.Tracing;
 import org.olat.group.BusinessGroup;
 import org.olat.group.BusinessGroupLazy;
+import org.olat.group.BusinessGroupMembership;
 import org.olat.group.BusinessGroupOrder;
 import org.olat.group.BusinessGroupShort;
 import org.olat.group.BusinessGroupView;
@@ -1264,6 +1265,65 @@ public class BusinessGroupDAOTest extends OlatTestCase {
 		Assert.assertEquals(3, found);
 	}
 	
+	@Test
+	public void getBusinessGroupsMembership() {
+		Identity id1 = JunitTestHelper.createAndPersistIdentityAsUser("is-in-grp-rev-1" + UUID.randomUUID().toString());
+		Identity id2 = JunitTestHelper.createAndPersistIdentityAsUser("is-in-grp-rev-2" + UUID.randomUUID().toString());
+		BusinessGroup group1 = businessGroupDao.createAndPersist(id1, "is-in-grp-rev-1", "is-in-grp-rev-1-desc", 0, 5, true, false, true, false, false);
+		BusinessGroup group2 = businessGroupDao.createAndPersist(id2, "is-in-grp-rev-2", "is-in-grp-rev-2-desc", 0, 5, true, false, true, false, false);
+		BusinessGroup group3 = businessGroupDao.createAndPersist(null, "is-in-grp-rev-3", "is-in-grp-rev-3-desc", 0, 5, true, false, true, false, false);
+		dbInstance.commitAndCloseSession();
+
+		securityManager.addIdentityToSecurityGroup(id1, group2.getPartipiciantGroup());
+		securityManager.addIdentityToSecurityGroup(id1, group3.getWaitingGroup());
+		securityManager.addIdentityToSecurityGroup(id2, group2.getPartipiciantGroup());
+		securityManager.addIdentityToSecurityGroup(id2, group3.getPartipiciantGroup());
+		dbInstance.commitAndCloseSession();
+		
+		List<BusinessGroup> groups = new ArrayList<BusinessGroup>();
+		groups.add(group1);
+		groups.add(group2);
+		groups.add(group3);
+		List<Long> groupKeys = new ArrayList<Long>();
+		groupKeys.add(group1.getKey());
+		groupKeys.add(group2.getKey());
+		groupKeys.add(group3.getKey());
+
+		//check owner + attendee
+		int countMembership1 = businessGroupDao.countMembershipInfoInBusinessGroups(id1, groupKeys);
+		int countMembership2 = businessGroupDao.countMembershipInfoInBusinessGroups(id2, groupKeys);
+		Assert.assertEquals(3, countMembership1);
+		Assert.assertEquals(3, countMembership2);
+		List<BusinessGroupMembership> memberships = businessGroupDao.getBusinessGroupsMembership(groups);
+		Assert.assertNotNull(memberships);
+		//5: id1 3 membership in group1, group2, group3 and id2 2 memberships in group2 and group3
+		Assert.assertEquals(5, memberships.size());
+
+		int foundOwn = 0;
+		int foundPart = 0;
+		int foundWait = 0;
+		for(BusinessGroupMembership membership:memberships) {
+			Assert.assertNotNull(membership.getIdentityKey());
+			Assert.assertNotNull(membership.getCreationDate());
+			Assert.assertNotNull(membership.getLastModified());
+			Assert.assertNotNull(membership.getGroupKey());
+			Assert.assertTrue(groupKeys.contains(membership.getGroupKey()));
+			if(membership.isOwner()) {
+				foundOwn++;
+			}
+			if(membership.isParticipant()) {
+				foundPart++;
+			}
+			if(membership.isWaiting()) {
+				foundWait++;
+			}
+		}
+		Assert.assertEquals(2, foundOwn);
+		Assert.assertEquals(3, foundPart);
+		Assert.assertEquals(1, foundWait);
+	}
+	
+	
 	@Test
 	public void getMembershipInfoInBusinessGroupsWithoutIdentityParam() {
 		Identity id1 = JunitTestHelper.createAndPersistIdentityAsUser("is-in-grp-" + UUID.randomUUID().toString());