Coverage Report

Coverage Report - org.kuali.rice.kim.impl.group.GroupServiceImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

GroupServiceImpl

81%

121/149

61%

61/100

4.524

 /*
  * Copyright 2006-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.kuali.rice.kim.impl.group;
 
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.core.api.criteria.QueryByCriteria;
 import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
 import org.kuali.rice.kim.api.group.Group;
 import org.kuali.rice.kim.api.group.GroupMember;
 import org.kuali.rice.kim.api.group.GroupQueryResults;
 import org.kuali.rice.kim.api.group.GroupService;
 import org.kuali.rice.kim.util.KIMPropertyConstants;
 import org.kuali.rice.kim.util.KimConstants;
 
 import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 public class GroupServiceImpl extends GroupServiceBase implements GroupService {
 
     @Override
     public List<Group> getGroupsForPrincipal(String principalId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(principalId) ) {
                          throw new RiceIllegalArgumentException("principalId is blank");
                 }
         return getGroupsForPrincipalByNamespace( principalId, null );
     }
 
     @Override
     public List<Group> getGroupsForPrincipalByNamespace(String principalId, String namespaceCode) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(principalId) ) {
                          throw new RiceIllegalArgumentException("principalId is blank");
                 }
         Collection<Group> directGroups = getDirectGroupsForPrincipal( principalId, namespaceCode );
                 Set<Group> groups = new HashSet<Group>();
         groups.addAll(directGroups);
                 for ( Group group : directGroups ) {
                         groups.add( group );
                         groups.addAll( getParentGroups( group.getId() ) );
                 }
                 return new ArrayList<Group>( groups );
     }
 
     @Override
     public List<String> findGroupIds(final QueryByCriteria queryByCriteria) {
         GroupQueryResults results = this.findGroups(queryByCriteria);
         List<String> result = new ArrayList<String>();
 
         for (Group group : results.getResults()) {
             result.add(group.getId());
         }
 
         return result;
     }
 
     /*@Override
     public List<Group> lookupGroups(Map<String, String> searchCriteria) {
         List<GroupBo> groupBos = groupDao.getGroups(searchCriteria);
         List<Group> groups = toGroupList(groupBos);
         if (groups == null) {
             return Collections.emptyList();
         }
         return groups;
     }*/
 
     @Override
     public boolean isDirectMemberOfGroup(String principalId, String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
         if ( StringUtils.isEmpty(principalId) ) {
                         throw new RiceIllegalArgumentException("principalId is blank");
                 }
                 Map<String,String> criteria = new HashMap<String,String>();
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, principalId);
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
                 criteria.put(KIMPropertyConstants.GroupMember.GROUP_ID, groupId);
 
                 Collection<GroupMemberBo> groupMembers = businessObjectService.findMatching(GroupMemberBo.class, criteria);
                 for ( GroupMemberBo gm : groupMembers ) {
                         if ( gm.isActive(new Timestamp(System.currentTimeMillis())) ) {
                                 return true;
                         }
                 }
                 return false;
     }
 
     @Override
     public List<String> getGroupIdsForPrincipal(String principalId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(principalId) ) {
                         throw new RiceIllegalArgumentException("principalId is blank");
                 }
         return getGroupIdsForPrincipalByNamespace(principalId, null);
     }
 
     @Override
     public List<String> getGroupIdsForPrincipalByNamespace(String principalId, String namespaceCode) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(principalId) ) {
                          throw new RiceIllegalArgumentException("principalId is blank");
                 }
         List<String> result = new ArrayList<String>();
 
         if (principalId != null) {
             List<Group> groupList = getGroupsForPrincipalByNamespace(principalId, namespaceCode);
 
             for (Group group : groupList) {
                 result.add(group.getId());
             }
         }
 
         return result;
     }
 
     @Override
     public List<String> getDirectGroupIdsForPrincipal(String principalId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(principalId) ) {
                         throw new RiceIllegalArgumentException("principalId is blank");
                 }
         List<String> result = new ArrayList<String>();
 
         if (principalId != null) {
                 Collection<Group> groupList = getDirectGroupsForPrincipal(principalId);
 
             for (Group g : groupList) {
                 result.add(g.getId());
             }
         }
 
         return result;
     }
 
     @Override
     public List<String> getMemberPrincipalIds(String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
                 Set<String> visitedGroupIds = new HashSet<String>();
                 return getMemberPrincipalIdsInternal(groupId, visitedGroupIds);
     }
 
     @Override
     public List<String> getDirectMemberPrincipalIds(String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
         //Group group = getGroup(groupId);
         return this.getMemberIdsByType(getMembersOfGroup(groupId), KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
     }
 
     @Override
     public List<String> getMemberGroupIds(String groupId) throws RiceIllegalArgumentException {
         /*if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
                 Set<String> visitedGroupIds = new HashSet<String>();
                 return getMemberIdsInternalByType(groupId, visitedGroupIds, KimConstants.KimGroupMemberTypes.GROUP_MEMBER_TYPE);
 */
 
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
                 List<GroupBo> groups = getMemberGroupBos( groupId );
                 ArrayList<String> groupIds = new ArrayList<String>( groups.size() );
                 for ( GroupBo group : groups ) {
                         if ( group.isActive() ) {
                                 groupIds.add( group.getId() );
                         }
                 }
                 return groupIds;
     }
 
 
         protected List<GroupBo> getMemberGroupBos(String groupId) {
                 if ( groupId == null ) {
                         return Collections.emptyList();
                 }
                 Set<GroupBo> groups = new HashSet<GroupBo>();
 
                 GroupBo group = getGroupBo(groupId);
                 getMemberGroupsInternal(group, groups);
 
                 return new ArrayList<GroupBo>(groups);
         }
 
     protected void getMemberGroupsInternal( GroupBo group, Set<GroupBo> groups ) {
                 if ( group == null ) {
                         return;
                 }
                 List<String> groupIds = group.getMemberGroupIds();
 
                 for (String id : groupIds) {
                         GroupBo memberGroup = getGroupBo(id);
                         // if we've already seen that group, don't recurse into it
                         if ( memberGroup.isActive() && !groups.contains( memberGroup ) ) {
                                 groups.add(memberGroup);
                                 getMemberGroupsInternal(memberGroup,groups);
                         }
                 }
 
         }
 
     @Override
     public List<String> getDirectMemberGroupIds(String groupId) {
         if ( groupId == null ) {
                         return Collections.emptyList();
                 }
         //Group group = getGroup(groupId);
         return this.getMemberIdsByType(getMembersOfGroup(groupId), KimConstants.KimGroupMemberTypes.GROUP_MEMBER_TYPE);
     }
 
     @Override
     public List<String> getParentGroupIds(String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
         List<String> result = new ArrayList<String>();
         if (groupId != null) {
             List<Group> groupList = getParentGroups(groupId);
 
             for (Group group : groupList) {
                 result.add(group.getId());
             }
         }
 
         return result;
     }
 
     @Override
     public List<String> getDirectParentGroupIds(String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
         List<String> result = new ArrayList<String>();
         if (groupId != null) {
             List<Group> groupList = getDirectParentGroups(groupId);
             for (Group group : groupList) {
                 result.add(group.getId());
             }
         }
 
         return result;
     }
 
     @Override
     public Map<String, String> getAttributes(String groupId) throws RiceIllegalArgumentException {
         if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
 
         if (groupId == null) {
             return Collections.emptyMap();
         }
 
         Group group = getGroup(groupId);
         if (group != null) {
             return group.getAttributes();
         }
         return null;
     }
 
     @Override
     public List<GroupMember> getMembers(List<String> groupIds) {
         if (CollectionUtils.isEmpty(groupIds)) {
             throw new RiceIllegalArgumentException("groupIds is empty");
                 }
 
         //TODO: PRIME example of something for new Criteria API
         List<GroupMember> groupMembers = new ArrayList<GroupMember>();
         for (String groupId : groupIds) {
               groupMembers.addAll(getMembersOfGroup(groupId));
         }
         return groupMembers;
     }
 
    /* @Override
     public Collection<Person> getPersonMembersOfGroup(final String groupId) {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     @Override
     public Collection<Group> getGroupMembersOfGroup(@WebParam(name = "groupId") final String groupId) {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }*/
 
 
         protected List<Group> getParentGroups(String groupId) throws RiceIllegalArgumentException {
                 if ( StringUtils.isEmpty(groupId) ) {
                         throw new RiceIllegalArgumentException("groupId is blank");
                 }
                 Set<Group> groups = new HashSet<Group>();
                 getParentGroupsInternal( groupId, groups );
                 return new ArrayList<Group>( groups );
         }
 
     protected List<String> getMemberPrincipalIdsInternal(String groupId, Set<String> visitedGroupIds) {
                 if ( groupId == null ) {
                         return Collections.emptyList();
                 }
                 Set<String> ids = new HashSet<String>();
                 GroupBo group = getGroupBo(groupId);
                 if ( group == null || !group.isActive()) {
                         return Collections.emptyList();
                 }
 
         //List<String> memberIds = getMemberIdsByType(group, memberType);
         //List<GroupMember> members = new ArrayList<GroupMember>(getMembersOfGroup(group.getId()));
                 ids.addAll( group.getMemberPrincipalIds());
                 visitedGroupIds.add(group.getId());
 
                 for (String memberGroupId : group.getMemberGroupIds()) {
                         if (!visitedGroupIds.contains(memberGroupId)){
                                 ids.addAll(getMemberPrincipalIdsInternal(memberGroupId, visitedGroupIds));
                         }
                 }
 
                 return new ArrayList<String>(ids);
         }
 
     protected Collection<Group> getDirectGroupsForPrincipal( String principalId ) {
                 return getDirectGroupsForPrincipal( principalId, null );
         }
 
     @SuppressWarnings("unchecked")
         protected Collection<Group> getDirectGroupsForPrincipal( String principalId, String namespaceCode ) {
                 if ( principalId == null ) {
                         return Collections.emptyList();
                 }
                 Map<String,Object> criteria = new HashMap<String,Object>();
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, principalId);
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
                 Collection<GroupMemberBo> groupMembers = businessObjectService.findMatching(GroupMemberBo.class, criteria);
                 Set<String> groupIds = new HashSet<String>( groupMembers.size() );
                 // only return the active members
                 for ( GroupMemberBo gm : groupMembers ) {
                         if ( gm.isActive(new Timestamp(System.currentTimeMillis())) ) {
                                 groupIds.add( gm.getGroupId() );
                         }
                 }
                 // pull all the group information for the matching members
                 List<Group> groups = getGroups(groupIds);
                 List<Group> result = new ArrayList<Group>( groups.size() );
                 // filter by namespace if necessary
                 for ( Group group : groups ) {
                         if ( group.isActive() ) {
                                 if ( StringUtils.isBlank(namespaceCode) || StringUtils.equals(namespaceCode, group.getNamespaceCode() ) ) {
                                         result.add(group);
                                 }
                         }
                 }
                 return result;
         }
 }

1		/*
2		* Copyright 2006-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package org.kuali.rice.kim.impl.group;
18
19		import org.apache.commons.collections.CollectionUtils;
20		import org.apache.commons.lang.StringUtils;
21		import org.kuali.rice.core.api.criteria.QueryByCriteria;
22		import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
23		import org.kuali.rice.kim.api.group.Group;
24		import org.kuali.rice.kim.api.group.GroupMember;
25		import org.kuali.rice.kim.api.group.GroupQueryResults;
26		import org.kuali.rice.kim.api.group.GroupService;
27		import org.kuali.rice.kim.util.KIMPropertyConstants;
28		import org.kuali.rice.kim.util.KimConstants;
29
30		import java.sql.Timestamp;
31		import java.util.ArrayList;
32		import java.util.Collection;
33		import java.util.Collections;
34		import java.util.HashMap;
35		import java.util.HashSet;
36		import java.util.List;
37		import java.util.Map;
38		import java.util.Set;
39
40
41	20	public class GroupServiceImpl extends GroupServiceBase implements GroupService {
42
43		@Override
44		public List<Group> getGroupsForPrincipal(String principalId) throws RiceIllegalArgumentException {
45	1	if ( StringUtils.isEmpty(principalId) ) {
46	0	throw new RiceIllegalArgumentException("principalId is blank");
47		}
48	1	return getGroupsForPrincipalByNamespace( principalId, null );
49		}
50
51		@Override
52		public List<Group> getGroupsForPrincipalByNamespace(String principalId, String namespaceCode) throws RiceIllegalArgumentException {
53	4	if ( StringUtils.isEmpty(principalId) ) {
54	0	throw new RiceIllegalArgumentException("principalId is blank");
55		}
56	4	Collection<Group> directGroups = getDirectGroupsForPrincipal( principalId, namespaceCode );
57	4	Set<Group> groups = new HashSet<Group>();
58	4	groups.addAll(directGroups);
59	4	for ( Group group : directGroups ) {
60	4	groups.add( group );
61	4	groups.addAll( getParentGroups( group.getId() ) );
62		}
63	4	return new ArrayList<Group>( groups );
64		}
65
66		@Override
67		public List<String> findGroupIds(final QueryByCriteria queryByCriteria) {
68	1	GroupQueryResults results = this.findGroups(queryByCriteria);
69	1	List<String> result = new ArrayList<String>();
70
71	1	for (Group group : results.getResults()) {
72	3	result.add(group.getId());
73		}
74
75	1	return result;
76		}
77
78		/*@Override
79		public List<Group> lookupGroups(Map<String, String> searchCriteria) {
80		List<GroupBo> groupBos = groupDao.getGroups(searchCriteria);
81		List<Group> groups = toGroupList(groupBos);
82		if (groups == null) {
83		return Collections.emptyList();
84		}
85		return groups;
86		}*/
87
88		@Override
89		public boolean isDirectMemberOfGroup(String principalId, String groupId) throws RiceIllegalArgumentException {
90	2	if ( StringUtils.isEmpty(groupId) ) {
91	0	throw new RiceIllegalArgumentException("groupId is blank");
92		}
93	2	if ( StringUtils.isEmpty(principalId) ) {
94	0	throw new RiceIllegalArgumentException("principalId is blank");
95		}
96	2	Map<String,String> criteria = new HashMap<String,String>();
97	2	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, principalId);
98	2	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
99	2	criteria.put(KIMPropertyConstants.GroupMember.GROUP_ID, groupId);
100
101	2	Collection<GroupMemberBo> groupMembers = businessObjectService.findMatching(GroupMemberBo.class, criteria);
102	2	for ( GroupMemberBo gm : groupMembers ) {
103	1	if ( gm.isActive(new Timestamp(System.currentTimeMillis())) ) {
104	1	return true;
105		}
106		}
107	1	return false;
108		}
109
110		@Override
111		public List<String> getGroupIdsForPrincipal(String principalId) throws RiceIllegalArgumentException {
112	1	if ( StringUtils.isEmpty(principalId) ) {
113	0	throw new RiceIllegalArgumentException("principalId is blank");
114		}
115	1	return getGroupIdsForPrincipalByNamespace(principalId, null);
116		}
117
118		@Override
119		public List<String> getGroupIdsForPrincipalByNamespace(String principalId, String namespaceCode) throws RiceIllegalArgumentException {
120	2	if ( StringUtils.isEmpty(principalId) ) {
121	0	throw new RiceIllegalArgumentException("principalId is blank");
122		}
123	2	List<String> result = new ArrayList<String>();
124
125	2	if (principalId != null) {
126	2	List<Group> groupList = getGroupsForPrincipalByNamespace(principalId, namespaceCode);
127
128	2	for (Group group : groupList) {
129	2	result.add(group.getId());
130		}
131		}
132
133	2	return result;
134		}
135
136		@Override
137		public List<String> getDirectGroupIdsForPrincipal(String principalId) throws RiceIllegalArgumentException {
138	1	if ( StringUtils.isEmpty(principalId) ) {
139	0	throw new RiceIllegalArgumentException("principalId is blank");
140		}
141	1	List<String> result = new ArrayList<String>();
142
143	1	if (principalId != null) {
144	1	Collection<Group> groupList = getDirectGroupsForPrincipal(principalId);
145
146	1	for (Group g : groupList) {
147	1	result.add(g.getId());
148		}
149		}
150
151	1	return result;
152		}
153
154		@Override
155		public List<String> getMemberPrincipalIds(String groupId) throws RiceIllegalArgumentException {
156	1	if ( StringUtils.isEmpty(groupId) ) {
157	0	throw new RiceIllegalArgumentException("groupId is blank");
158		}
159	1	Set<String> visitedGroupIds = new HashSet<String>();
160	1	return getMemberPrincipalIdsInternal(groupId, visitedGroupIds);
161		}
162
163		@Override
164		public List<String> getDirectMemberPrincipalIds(String groupId) throws RiceIllegalArgumentException {
165	1	if ( StringUtils.isEmpty(groupId) ) {
166	0	throw new RiceIllegalArgumentException("groupId is blank");
167		}
168		//Group group = getGroup(groupId);
169	1	return this.getMemberIdsByType(getMembersOfGroup(groupId), KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
170		}
171
172		@Override
173		public List<String> getMemberGroupIds(String groupId) throws RiceIllegalArgumentException {
174		/*if ( StringUtils.isEmpty(groupId) ) {
175		throw new RiceIllegalArgumentException("groupId is blank");
176		}
177		Set<String> visitedGroupIds = new HashSet<String>();
178		return getMemberIdsInternalByType(groupId, visitedGroupIds, KimConstants.KimGroupMemberTypes.GROUP_MEMBER_TYPE);
179		*/
180
181	1	if ( StringUtils.isEmpty(groupId) ) {
182	0	throw new RiceIllegalArgumentException("groupId is blank");
183		}
184	1	List<GroupBo> groups = getMemberGroupBos( groupId );
185	1	ArrayList<String> groupIds = new ArrayList<String>( groups.size() );
186	1	for ( GroupBo group : groups ) {
187	1	if ( group.isActive() ) {
188	1	groupIds.add( group.getId() );
189		}
190		}
191	1	return groupIds;
192		}
193
194
195		protected List<GroupBo> getMemberGroupBos(String groupId) {
196	1	if ( groupId == null ) {
197	0	return Collections.emptyList();
198		}
199	1	Set<GroupBo> groups = new HashSet<GroupBo>();
200
201	1	GroupBo group = getGroupBo(groupId);
202	1	getMemberGroupsInternal(group, groups);
203
204	1	return new ArrayList<GroupBo>(groups);
205		}
206
207		protected void getMemberGroupsInternal( GroupBo group, Set<GroupBo> groups ) {
208	2	if ( group == null ) {
209	0	return;
210		}
211	2	List<String> groupIds = group.getMemberGroupIds();
212
213	2	for (String id : groupIds) {
214	1	GroupBo memberGroup = getGroupBo(id);
215		// if we've already seen that group, don't recurse into it
216	1	if ( memberGroup.isActive() && !groups.contains( memberGroup ) ) {
217	1	groups.add(memberGroup);
218	1	getMemberGroupsInternal(memberGroup,groups);
219		}
220	1	}
221
222	2	}
223
224		@Override
225		public List<String> getDirectMemberGroupIds(String groupId) {
226	1	if ( groupId == null ) {
227	0	return Collections.emptyList();
228		}
229		//Group group = getGroup(groupId);
230	1	return this.getMemberIdsByType(getMembersOfGroup(groupId), KimConstants.KimGroupMemberTypes.GROUP_MEMBER_TYPE);
231		}
232
233		@Override
234		public List<String> getParentGroupIds(String groupId) throws RiceIllegalArgumentException {
235	1	if ( StringUtils.isEmpty(groupId) ) {
236	0	throw new RiceIllegalArgumentException("groupId is blank");
237		}
238	1	List<String> result = new ArrayList<String>();
239	1	if (groupId != null) {
240	1	List<Group> groupList = getParentGroups(groupId);
241
242	1	for (Group group : groupList) {
243	1	result.add(group.getId());
244		}
245		}
246
247	1	return result;
248		}
249
250		@Override
251		public List<String> getDirectParentGroupIds(String groupId) throws RiceIllegalArgumentException {
252	1	if ( StringUtils.isEmpty(groupId) ) {
253	0	throw new RiceIllegalArgumentException("groupId is blank");
254		}
255	1	List<String> result = new ArrayList<String>();
256	1	if (groupId != null) {
257	1	List<Group> groupList = getDirectParentGroups(groupId);
258	1	for (Group group : groupList) {
259	1	result.add(group.getId());
260		}
261		}
262
263	1	return result;
264		}
265
266		@Override
267		public Map<String, String> getAttributes(String groupId) throws RiceIllegalArgumentException {
268	0	if ( StringUtils.isEmpty(groupId) ) {
269	0	throw new RiceIllegalArgumentException("groupId is blank");
270		}
271
272	0	if (groupId == null) {
273	0	return Collections.emptyMap();
274		}
275
276	0	Group group = getGroup(groupId);
277	0	if (group != null) {
278	0	return group.getAttributes();
279		}
280	0	return null;
281		}
282
283		@Override
284		public List<GroupMember> getMembers(List<String> groupIds) {
285	1	if (CollectionUtils.isEmpty(groupIds)) {
286	0	throw new RiceIllegalArgumentException("groupIds is empty");
287		}
288
289		//TODO: PRIME example of something for new Criteria API
290	1	List<GroupMember> groupMembers = new ArrayList<GroupMember>();
291	1	for (String groupId : groupIds) {
292	2	groupMembers.addAll(getMembersOfGroup(groupId));
293		}
294	1	return groupMembers;
295		}
296
297		/* @Override
298		public Collection<Person> getPersonMembersOfGroup(final String groupId) {
299		return null; //To change body of implemented methods use File \| Settings \| File Templates.
300		}
301
302		@Override
303		public Collection<Group> getGroupMembersOfGroup(@WebParam(name = "groupId") final String groupId) {
304		return null; //To change body of implemented methods use File \| Settings \| File Templates.
305		}*/
306
307
308		protected List<Group> getParentGroups(String groupId) throws RiceIllegalArgumentException {
309	5	if ( StringUtils.isEmpty(groupId) ) {
310	0	throw new RiceIllegalArgumentException("groupId is blank");
311		}
312	5	Set<Group> groups = new HashSet<Group>();
313	5	getParentGroupsInternal( groupId, groups );
314	5	return new ArrayList<Group>( groups );
315		}
316
317		protected List<String> getMemberPrincipalIdsInternal(String groupId, Set<String> visitedGroupIds) {
318	2	if ( groupId == null ) {
319	0	return Collections.emptyList();
320		}
321	2	Set<String> ids = new HashSet<String>();
322	2	GroupBo group = getGroupBo(groupId);
323	2	if ( group == null \|\| !group.isActive()) {
324	0	return Collections.emptyList();
325		}
326
327		//List<String> memberIds = getMemberIdsByType(group, memberType);
328		//List<GroupMember> members = new ArrayList<GroupMember>(getMembersOfGroup(group.getId()));
329	2	ids.addAll( group.getMemberPrincipalIds());
330	2	visitedGroupIds.add(group.getId());
331
332	2	for (String memberGroupId : group.getMemberGroupIds()) {
333	1	if (!visitedGroupIds.contains(memberGroupId)){
334	1	ids.addAll(getMemberPrincipalIdsInternal(memberGroupId, visitedGroupIds));
335		}
336		}
337
338	2	return new ArrayList<String>(ids);
339		}
340
341		protected Collection<Group> getDirectGroupsForPrincipal( String principalId ) {
342	1	return getDirectGroupsForPrincipal( principalId, null );
343		}
344
345		@SuppressWarnings("unchecked")
346		protected Collection<Group> getDirectGroupsForPrincipal( String principalId, String namespaceCode ) {
347	5	if ( principalId == null ) {
348	0	return Collections.emptyList();
349		}
350	5	Map<String,Object> criteria = new HashMap<String,Object>();
351	5	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, principalId);
352	5	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimConstants.KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
353	5	Collection<GroupMemberBo> groupMembers = businessObjectService.findMatching(GroupMemberBo.class, criteria);
354	5	Set<String> groupIds = new HashSet<String>( groupMembers.size() );
355		// only return the active members
356	5	for ( GroupMemberBo gm : groupMembers ) {
357	5	if ( gm.isActive(new Timestamp(System.currentTimeMillis())) ) {
358	5	groupIds.add( gm.getGroupId() );
359		}
360		}
361		// pull all the group information for the matching members
362	5	List<Group> groups = getGroups(groupIds);
363	5	List<Group> result = new ArrayList<Group>( groups.size() );
364		// filter by namespace if necessary
365	5	for ( Group group : groups ) {
366	5	if ( group.isActive() ) {
367	5	if ( StringUtils.isBlank(namespaceCode) \|\| StringUtils.equals(namespaceCode, group.getNamespaceCode() ) ) {
368	5	result.add(group);
369		}
370		}
371		}
372	5	return result;
373		}
374		}