Coverage Report

Coverage Report - org.kuali.rice.kim.service.impl.GroupServiceBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

GroupServiceBase

0/134

0/98

4.737

 /*
  * Copyright 2007-2010 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.service.impl;
 
 import org.kuali.rice.kim.bo.group.dto.GroupInfo;
 import org.kuali.rice.kim.bo.group.impl.GroupMemberImpl;
 import org.kuali.rice.kim.bo.impl.GroupImpl;
 import org.kuali.rice.kim.service.IdentityManagementNotificationService;
 import org.kuali.rice.kim.util.KIMPropertyConstants;
 import org.kuali.rice.kim.util.KimConstants;
 import org.kuali.rice.kim.util.KimConstants.KimGroupMemberTypes;
 import org.kuali.rice.kns.service.*;
 import org.kuali.rice.ksb.service.KSBServiceLocator;
 
 import javax.xml.namespace.QName;
 import java.util.*;
 
 /**
  * This is a description of what this class does - jjhanso don't forget to fill this in. 
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public abstract class GroupServiceBase {
         private BusinessObjectService businessObjectService;
         private LookupService lookupService;
         
         /**
      * @see org.kuali.rice.kim.service.GroupService#getGroupInfo(java.lang.String)
      */
     public GroupInfo getGroupInfo(String groupId) {
         GroupImpl group = getGroupImpl(groupId);
         return toGroupInfo(group);
     }
     
     
         /**
      * @see org.kuali.rice.kim.service.GroupService#isGroupMemberOfGroup(java.lang.String,
      *      java.lang.String)
      */
         public boolean isGroupMemberOfGroup(String groupMemberId, String groupId) {
         if( groupId == null || groupMemberId == null) {
             return false;
         }
 
         // TODO: should it check for valid group ids here?
 
         return isGroupMemberOfGroupInternal(groupMemberId, groupId);
         }
         
         /**
          * @see org.kuali.rice.kim.service.GroupService#isMemberOfGroup(java.lang.String,
          *      java.lang.String)
          */
         public boolean isMemberOfGroup(String principalId, String groupId) {
                 if ( principalId == null || groupId == null ) {
                         return false;
                 }
                 // we could call the getMemberPrincipalIds method, but this will be more efficient
                 // when group traversal is not needed
                 GroupImpl group = getGroupImpl(groupId);
                 if ( group == null || !group.isActive() ) {
                         return false;
                 }
                 // check the immediate group
                 for (String groupPrincipalId : group.getMemberPrincipalIds() ) {
                         if (groupPrincipalId.equals(principalId)) {
                                 return true;
                         }
                 }
 
                 // check each contained group, returning as soon as a match is found
                 for ( String memberGroupId : group.getMemberGroupIds() ) {
                         if ( isMemberOfGroup( principalId, memberGroupId ) ) {
                                 return true;
                         }
                 }
 
                 // no match found, return false
                 return false;
         }
         
         /**
      * @see org.kuali.rice.kim.service.GroupService#getGroupInfoByName(java.lang.String, java.lang.String)
      */
     public GroupInfo getGroupInfoByName(String namespaceCode, String groupName) {
         return toGroupInfo(getGroupByName(namespaceCode, groupName));
     }
     
          /**
      * @see org.kuali.rice.kim.service.GroupService#getGroupInfos(java.util.List)
      */
     public Map<String, GroupInfo> getGroupInfos(Collection<String> groupIds) {
         Map<String, GroupInfo> result = new HashMap<String, GroupInfo>();
 
         // hopefully there is an efficient orm way to do this
         for (String s : groupIds) {
             GroupImpl group = getGroupImpl(s);
             if (group != null) {
                 result.put(s, toGroupInfo(group));
             }
         }
 
         return result;
     }
     
     protected GroupImpl getGroupImpl(String groupId) {
                 if ( groupId == null ) {
                         return null;
                 }
                 //Map<String,String> criteria = new HashMap<String,String>();
                 //criteria.put(KIMPropertyConstants.Group.GROUP_ID, groupId);
                 return (GroupImpl) getBusinessObjectService().findBySinglePrimaryKey(GroupImpl.class, groupId);
         }
 
         @SuppressWarnings("unchecked")
         protected GroupImpl getGroupByName(String namespaceCode, String groupName) {
                 if ( namespaceCode == null || groupName == null ) {
                         return null;
                 }
                 Map<String,String> criteria = new HashMap<String,String>();
                 criteria.put(KimConstants.UniqueKeyConstants.NAMESPACE_CODE, namespaceCode);
                 criteria.put(KimConstants.UniqueKeyConstants.GROUP_NAME, groupName);
                 Collection<GroupImpl> groups = getBusinessObjectService().findMatching(GroupImpl.class, criteria);
                 if ( groups.size() > 0 ) {
                         return groups.iterator().next();
                 }
                 return null;
         }
         
         protected GroupInfo toGroupInfo(GroupImpl kimGroup) {
         GroupInfo info = null;
 
         if (kimGroup != null) {
             info = new GroupInfo();
 
             info.setActive(kimGroup.isActive());
             info.setGroupDescription(kimGroup.getGroupDescription());
             info.setGroupId(kimGroup.getGroupId());
             info.setGroupName(kimGroup.getGroupName());
             info.setKimTypeId(kimGroup.getKimTypeId());
             info.setNamespaceCode(kimGroup.getNamespaceCode());
 
             info.setAttributes(kimGroup.getAttributes());
         }
 
         return info;
     }
 
     protected List<GroupInfo> toGroupInfo(List<GroupImpl> kimGroups){
             List<GroupInfo> lRet = null;
 
             if(kimGroups != null){
                     lRet = new ArrayList<GroupInfo>();
 
                     for(GroupImpl gi: kimGroups){
                             lRet.add(this.toGroupInfo(gi));
                     }
             }
 
             return lRet;
     }
  
         protected boolean isGroupMemberOfGroupInternal(String groupMemberId, String groupId) {
 
             GroupImpl group = getGroupImpl(groupId);
             if (group == null) {
                     return false;
             }
             if( !group.isActive() ) {
                 return false;
             }
 
             for( String memberGroupId : group.getMemberGroupIds()) {
                 if(memberGroupId.equals(groupMemberId)) {
                     return true;
                 }
                 else if(isGroupMemberOfGroup(groupMemberId, memberGroupId)) {
                     return true;
                 }
             }
 
             return false;
         }
 
         @SuppressWarnings("unchecked")
         protected Map<String,GroupInfo> getDirectParentGroups(String groupId) {
                 if ( groupId == null ) {
                         return Collections.emptyMap();
                 }
                 Map<String,String> criteria = new HashMap<String,String>();
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, groupId);
                 criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimGroupMemberTypes.GROUP_MEMBER_TYPE);
 
                 List<GroupMemberImpl> groupMembers = (List<GroupMemberImpl>)getBusinessObjectService().findMatching(GroupMemberImpl.class, criteria);
                 Set<String> matchingGroupIds = new HashSet<String>();
                 // filter to active groups
                 for ( GroupMemberImpl gm : groupMembers ) {
                         if ( gm.isActive() ) {
                                 matchingGroupIds.add(gm.getGroupId());
                         }
                 }
                 return getGroupInfos(matchingGroupIds);
         }
 
         /**
          * @see org.kuali.rice.kim.service.GroupService#getParentGroups(java.lang.String)
          */
         protected List<GroupInfo> getParentGroups(String groupId) {
                 if ( groupId == null ) {
                         return Collections.emptyList();
                 }
                 Set<GroupInfo> groups = new HashSet<GroupInfo>();
                 getParentGroupsInternal( groupId, groups );
                 return new ArrayList<GroupInfo>( groups );
         }
 
         protected void getParentGroupsInternal( String groupId, Set<GroupInfo> groups ) {
                 Map<String,GroupInfo> parentGroups = getDirectParentGroups( groupId );
                 for ( GroupInfo group : parentGroups.values() ) {
                         if ( !groups.contains( group ) ) {
                                 groups.add( group );
                                 getParentGroupsInternal( group.getGroupId(), groups );
                         }
                 }
         }
         
         public List<String> getMemberPrincipalIds(String groupId) {
                 if ( groupId == null ) {
                         return Collections.emptyList();
                 }
                 Set<String> ids = new HashSet<String>();
                 Set<String> groupIds = new HashSet<String>();
                 
                 GroupImpl group = getGroupImpl(groupId);
                 if ( group == null ) {
                         return Collections.emptyList();
                 }
 
                 ids.addAll( group.getMemberPrincipalIds() );
                 groupIds.add(group.getGroupId());
 
                 for (String memberGroupId : group.getMemberGroupIds()) {
                         if (!groupIds.contains(memberGroupId)){
                                 ids.addAll(getMemberPrincipalIds(memberGroupId));
                         }
                 }
 
                 return new ArrayList<String>(ids);
         }
 
         protected List<String> getMemberPrincipalIdsInternal(String groupId, Set<String> visitedGroupIds) {
                 if ( groupId == null ) {
                         return Collections.emptyList();
                 }
                 Set<String> ids = new HashSet<String>();        
                 GroupImpl group = getGroupImpl(groupId);
                 if ( group == null ) {
                         return Collections.emptyList();
                 }
 
                 ids.addAll( group.getMemberPrincipalIds() );
                 visitedGroupIds.add(group.getGroupId());
 
                 for (String memberGroupId : group.getMemberGroupIds()) {
                         if (!visitedGroupIds.contains(memberGroupId)){
                                 ids.addAll(getMemberPrincipalIdsInternal(memberGroupId, visitedGroupIds));
                         }
                 }
 
                 return new ArrayList<String>(ids);
         }
 
         public boolean isMemberOfGroupInternal(String principalId, String groupId, Set<String> visitedGroupIds) {
                 if ( principalId == null || groupId == null ) {
                         return false;
                 }
                 // we could call the getMemberPrincipalIds method, but this will be more efficient
                 // when group traversal is not needed
                 GroupImpl group = getGroupImpl(groupId);
                 if ( group == null || !group.isActive() ) {
                         return false;
                 }
                 // check the immediate group
                 for (String groupPrincipalId : group.getMemberPrincipalIds() ) {
                         if (groupPrincipalId.equals(principalId)) {
                                 return true;
                         }
                 }
 
                 // check each contained group, returning as soon as a match is found
                 for ( String memberGroupId : group.getMemberGroupIds() ) {
                         if (!visitedGroupIds.contains(memberGroupId)){
                                 visitedGroupIds.add(memberGroupId);
                                 if ( isMemberOfGroupInternal( principalId, memberGroupId, visitedGroupIds ) ) {
                                         return true;
                                 }
                         }
                 }
 
                 // no match found, return false
                 return false;
         }
 
         protected IdentityManagementNotificationService getIdentityManagementNotificationService() {
         return (IdentityManagementNotificationService)KSBServiceLocator.getMessageHelper().getServiceAsynchronously(new QName("KIM", "kimIdentityManagementNotificationService"));
     }
 
         protected BusinessObjectService getBusinessObjectService() {
                 if ( businessObjectService == null ) {
                         businessObjectService = KNSServiceLocator.getBusinessObjectService();
                 }
                 return businessObjectService;
         }
         
     /**
          * @return the lookupService
          */
     protected LookupService getLookupService() {
                 if(lookupService == null) {
                         lookupService = KNSServiceLocatorWeb.getLookupService();
                 }
                 return lookupService;
     }
 }

1		/*
2		* Copyright 2007-2010 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		package org.kuali.rice.kim.service.impl;
17
18		import org.kuali.rice.kim.bo.group.dto.GroupInfo;
19		import org.kuali.rice.kim.bo.group.impl.GroupMemberImpl;
20		import org.kuali.rice.kim.bo.impl.GroupImpl;
21		import org.kuali.rice.kim.service.IdentityManagementNotificationService;
22		import org.kuali.rice.kim.util.KIMPropertyConstants;
23		import org.kuali.rice.kim.util.KimConstants;
24		import org.kuali.rice.kim.util.KimConstants.KimGroupMemberTypes;
25		import org.kuali.rice.kns.service.*;
26		import org.kuali.rice.ksb.service.KSBServiceLocator;
27
28		import javax.xml.namespace.QName;
29		import java.util.*;
30
31		/**
32		* This is a description of what this class does - jjhanso don't forget to fill this in.
33		*
34		* @author Kuali Rice Team (rice.collab@kuali.org)
35		*
36		*/
37	0	public abstract class GroupServiceBase {
38		private BusinessObjectService businessObjectService;
39		private LookupService lookupService;
40
41		/**
42		* @see org.kuali.rice.kim.service.GroupService#getGroupInfo(java.lang.String)
43		*/
44		public GroupInfo getGroupInfo(String groupId) {
45	0	GroupImpl group = getGroupImpl(groupId);
46	0	return toGroupInfo(group);
47		}
48
49
50		/**
51		* @see org.kuali.rice.kim.service.GroupService#isGroupMemberOfGroup(java.lang.String,
52		* java.lang.String)
53		*/
54		public boolean isGroupMemberOfGroup(String groupMemberId, String groupId) {
55	0	if( groupId == null \|\| groupMemberId == null) {
56	0	return false;
57		}
58
59		// TODO: should it check for valid group ids here?
60
61	0	return isGroupMemberOfGroupInternal(groupMemberId, groupId);
62		}
63
64		/**
65		* @see org.kuali.rice.kim.service.GroupService#isMemberOfGroup(java.lang.String,
66		* java.lang.String)
67		*/
68		public boolean isMemberOfGroup(String principalId, String groupId) {
69	0	if ( principalId == null \|\| groupId == null ) {
70	0	return false;
71		}
72		// we could call the getMemberPrincipalIds method, but this will be more efficient
73		// when group traversal is not needed
74	0	GroupImpl group = getGroupImpl(groupId);
75	0	if ( group == null \|\| !group.isActive() ) {
76	0	return false;
77		}
78		// check the immediate group
79	0	for (String groupPrincipalId : group.getMemberPrincipalIds() ) {
80	0	if (groupPrincipalId.equals(principalId)) {
81	0	return true;
82		}
83		}
84
85		// check each contained group, returning as soon as a match is found
86	0	for ( String memberGroupId : group.getMemberGroupIds() ) {
87	0	if ( isMemberOfGroup( principalId, memberGroupId ) ) {
88	0	return true;
89		}
90		}
91
92		// no match found, return false
93	0	return false;
94		}
95
96		/**
97		* @see org.kuali.rice.kim.service.GroupService#getGroupInfoByName(java.lang.String, java.lang.String)
98		*/
99		public GroupInfo getGroupInfoByName(String namespaceCode, String groupName) {
100	0	return toGroupInfo(getGroupByName(namespaceCode, groupName));
101		}
102
103		/**
104		* @see org.kuali.rice.kim.service.GroupService#getGroupInfos(java.util.List)
105		*/
106		public Map<String, GroupInfo> getGroupInfos(Collection<String> groupIds) {
107	0	Map<String, GroupInfo> result = new HashMap<String, GroupInfo>();
108
109		// hopefully there is an efficient orm way to do this
110	0	for (String s : groupIds) {
111	0	GroupImpl group = getGroupImpl(s);
112	0	if (group != null) {
113	0	result.put(s, toGroupInfo(group));
114		}
115	0	}
116
117	0	return result;
118		}
119
120		protected GroupImpl getGroupImpl(String groupId) {
121	0	if ( groupId == null ) {
122	0	return null;
123		}
124		//Map<String,String> criteria = new HashMap<String,String>();
125		//criteria.put(KIMPropertyConstants.Group.GROUP_ID, groupId);
126	0	return (GroupImpl) getBusinessObjectService().findBySinglePrimaryKey(GroupImpl.class, groupId);
127		}
128
129		@SuppressWarnings("unchecked")
130		protected GroupImpl getGroupByName(String namespaceCode, String groupName) {
131	0	if ( namespaceCode == null \|\| groupName == null ) {
132	0	return null;
133		}
134	0	Map<String,String> criteria = new HashMap<String,String>();
135	0	criteria.put(KimConstants.UniqueKeyConstants.NAMESPACE_CODE, namespaceCode);
136	0	criteria.put(KimConstants.UniqueKeyConstants.GROUP_NAME, groupName);
137	0	Collection<GroupImpl> groups = getBusinessObjectService().findMatching(GroupImpl.class, criteria);
138	0	if ( groups.size() > 0 ) {
139	0	return groups.iterator().next();
140		}
141	0	return null;
142		}
143
144		protected GroupInfo toGroupInfo(GroupImpl kimGroup) {
145	0	GroupInfo info = null;
146
147	0	if (kimGroup != null) {
148	0	info = new GroupInfo();
149
150	0	info.setActive(kimGroup.isActive());
151	0	info.setGroupDescription(kimGroup.getGroupDescription());
152	0	info.setGroupId(kimGroup.getGroupId());
153	0	info.setGroupName(kimGroup.getGroupName());
154	0	info.setKimTypeId(kimGroup.getKimTypeId());
155	0	info.setNamespaceCode(kimGroup.getNamespaceCode());
156
157	0	info.setAttributes(kimGroup.getAttributes());
158		}
159
160	0	return info;
161		}
162
163		protected List<GroupInfo> toGroupInfo(List<GroupImpl> kimGroups){
164	0	List<GroupInfo> lRet = null;
165
166	0	if(kimGroups != null){
167	0	lRet = new ArrayList<GroupInfo>();
168
169	0	for(GroupImpl gi: kimGroups){
170	0	lRet.add(this.toGroupInfo(gi));
171		}
172		}
173
174	0	return lRet;
175		}
176
177		protected boolean isGroupMemberOfGroupInternal(String groupMemberId, String groupId) {
178
179	0	GroupImpl group = getGroupImpl(groupId);
180	0	if (group == null) {
181	0	return false;
182		}
183	0	if( !group.isActive() ) {
184	0	return false;
185		}
186
187	0	for( String memberGroupId : group.getMemberGroupIds()) {
188	0	if(memberGroupId.equals(groupMemberId)) {
189	0	return true;
190		}
191	0	else if(isGroupMemberOfGroup(groupMemberId, memberGroupId)) {
192	0	return true;
193		}
194		}
195
196	0	return false;
197		}
198
199		@SuppressWarnings("unchecked")
200		protected Map<String,GroupInfo> getDirectParentGroups(String groupId) {
201	0	if ( groupId == null ) {
202	0	return Collections.emptyMap();
203		}
204	0	Map<String,String> criteria = new HashMap<String,String>();
205	0	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_ID, groupId);
206	0	criteria.put(KIMPropertyConstants.GroupMember.MEMBER_TYPE_CODE, KimGroupMemberTypes.GROUP_MEMBER_TYPE);
207
208	0	List<GroupMemberImpl> groupMembers = (List<GroupMemberImpl>)getBusinessObjectService().findMatching(GroupMemberImpl.class, criteria);
209	0	Set<String> matchingGroupIds = new HashSet<String>();
210		// filter to active groups
211	0	for ( GroupMemberImpl gm : groupMembers ) {
212	0	if ( gm.isActive() ) {
213	0	matchingGroupIds.add(gm.getGroupId());
214		}
215		}
216	0	return getGroupInfos(matchingGroupIds);
217		}
218
219		/**
220		* @see org.kuali.rice.kim.service.GroupService#getParentGroups(java.lang.String)
221		*/
222		protected List<GroupInfo> getParentGroups(String groupId) {
223	0	if ( groupId == null ) {
224	0	return Collections.emptyList();
225		}
226	0	Set<GroupInfo> groups = new HashSet<GroupInfo>();
227	0	getParentGroupsInternal( groupId, groups );
228	0	return new ArrayList<GroupInfo>( groups );
229		}
230
231		protected void getParentGroupsInternal( String groupId, Set<GroupInfo> groups ) {
232	0	Map<String,GroupInfo> parentGroups = getDirectParentGroups( groupId );
233	0	for ( GroupInfo group : parentGroups.values() ) {
234	0	if ( !groups.contains( group ) ) {
235	0	groups.add( group );
236	0	getParentGroupsInternal( group.getGroupId(), groups );
237		}
238		}
239	0	}
240
241		public List<String> getMemberPrincipalIds(String groupId) {
242	0	if ( groupId == null ) {
243	0	return Collections.emptyList();
244		}
245	0	Set<String> ids = new HashSet<String>();
246	0	Set<String> groupIds = new HashSet<String>();
247
248	0	GroupImpl group = getGroupImpl(groupId);
249	0	if ( group == null ) {
250	0	return Collections.emptyList();
251		}
252
253	0	ids.addAll( group.getMemberPrincipalIds() );
254	0	groupIds.add(group.getGroupId());
255
256	0	for (String memberGroupId : group.getMemberGroupIds()) {
257	0	if (!groupIds.contains(memberGroupId)){
258	0	ids.addAll(getMemberPrincipalIds(memberGroupId));
259		}
260		}
261
262	0	return new ArrayList<String>(ids);
263		}
264
265		protected List<String> getMemberPrincipalIdsInternal(String groupId, Set<String> visitedGroupIds) {
266	0	if ( groupId == null ) {
267	0	return Collections.emptyList();
268		}
269	0	Set<String> ids = new HashSet<String>();
270	0	GroupImpl group = getGroupImpl(groupId);
271	0	if ( group == null ) {
272	0	return Collections.emptyList();
273		}
274
275	0	ids.addAll( group.getMemberPrincipalIds() );
276	0	visitedGroupIds.add(group.getGroupId());
277
278	0	for (String memberGroupId : group.getMemberGroupIds()) {
279	0	if (!visitedGroupIds.contains(memberGroupId)){
280	0	ids.addAll(getMemberPrincipalIdsInternal(memberGroupId, visitedGroupIds));
281		}
282		}
283
284	0	return new ArrayList<String>(ids);
285		}
286
287		public boolean isMemberOfGroupInternal(String principalId, String groupId, Set<String> visitedGroupIds) {
288	0	if ( principalId == null \|\| groupId == null ) {
289	0	return false;
290		}
291		// we could call the getMemberPrincipalIds method, but this will be more efficient
292		// when group traversal is not needed
293	0	GroupImpl group = getGroupImpl(groupId);
294	0	if ( group == null \|\| !group.isActive() ) {
295	0	return false;
296		}
297		// check the immediate group
298	0	for (String groupPrincipalId : group.getMemberPrincipalIds() ) {
299	0	if (groupPrincipalId.equals(principalId)) {
300	0	return true;
301		}
302		}
303
304		// check each contained group, returning as soon as a match is found
305	0	for ( String memberGroupId : group.getMemberGroupIds() ) {
306	0	if (!visitedGroupIds.contains(memberGroupId)){
307	0	visitedGroupIds.add(memberGroupId);
308	0	if ( isMemberOfGroupInternal( principalId, memberGroupId, visitedGroupIds ) ) {
309	0	return true;
310		}
311		}
312		}
313
314		// no match found, return false
315	0	return false;
316		}
317
318		protected IdentityManagementNotificationService getIdentityManagementNotificationService() {
319	0	return (IdentityManagementNotificationService)KSBServiceLocator.getMessageHelper().getServiceAsynchronously(new QName("KIM", "kimIdentityManagementNotificationService"));
320		}
321
322		protected BusinessObjectService getBusinessObjectService() {
323	0	if ( businessObjectService == null ) {
324	0	businessObjectService = KNSServiceLocator.getBusinessObjectService();
325		}
326	0	return businessObjectService;
327		}
328
329		/**
330		* @return the lookupService
331		*/
332		protected LookupService getLookupService() {
333	0	if(lookupService == null) {
334	0	lookupService = KNSServiceLocatorWeb.getLookupService();
335		}
336	0	return lookupService;
337		}
338		}