001 /**
002 * Copyright 2005-2011 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.kuali.rice.kim.service.impl;
017
018 import org.apache.commons.collections.CollectionUtils;
019 import org.apache.commons.lang.StringUtils;
020 import org.apache.log4j.Logger;
021 import org.joda.time.DateTime;
022 import org.kuali.rice.core.api.config.property.ConfigContext;
023 import org.kuali.rice.core.api.criteria.Predicate;
024 import org.kuali.rice.core.api.criteria.QueryByCriteria;
025 import org.kuali.rice.core.api.membership.MemberType;
026 import org.kuali.rice.core.api.parameter.Parameter;
027 import org.kuali.rice.core.api.uif.RemotableCheckboxGroup;
028 import org.kuali.rice.core.framework.parameter.ParameterService;
029 import org.kuali.rice.core.framework.services.CoreFrameworkServiceLocator;
030 import org.kuali.rice.kim.api.KimConstants;
031 import org.kuali.rice.kim.api.KimConstants.KimGroupMemberTypes;
032 import org.kuali.rice.kim.api.group.Group;
033 import org.kuali.rice.kim.api.group.GroupMember;
034 import org.kuali.rice.kim.api.group.GroupService;
035 import org.kuali.rice.kim.api.identity.IdentityService;
036 import org.kuali.rice.kim.api.identity.Person;
037 import org.kuali.rice.kim.api.identity.address.EntityAddress;
038 import org.kuali.rice.kim.api.identity.address.EntityAddressContract;
039 import org.kuali.rice.kim.api.identity.affiliation.EntityAffiliation;
040 import org.kuali.rice.kim.api.identity.email.EntityEmail;
041 import org.kuali.rice.kim.api.identity.email.EntityEmailContract;
042 import org.kuali.rice.kim.api.identity.employment.EntityEmployment;
043 import org.kuali.rice.kim.api.identity.entity.Entity;
044 import org.kuali.rice.kim.api.identity.name.EntityName;
045 import org.kuali.rice.kim.api.identity.phone.EntityPhone;
046 import org.kuali.rice.kim.api.identity.phone.EntityPhoneContract;
047 import org.kuali.rice.kim.api.identity.principal.Principal;
048 import org.kuali.rice.kim.api.identity.privacy.EntityPrivacyPreferences;
049 import org.kuali.rice.kim.api.identity.type.EntityTypeContactInfo;
050 import org.kuali.rice.kim.api.permission.PermissionService;
051 import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
052 import org.kuali.rice.kim.api.role.Role;
053 import org.kuali.rice.kim.api.role.RoleMember;
054 import org.kuali.rice.kim.api.role.RoleService;
055 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
056 import org.kuali.rice.kim.api.type.KimAttributeField;
057 import org.kuali.rice.kim.api.type.KimType;
058 import org.kuali.rice.kim.api.type.KimTypeAttribute;
059 import org.kuali.rice.kim.api.type.KimTypeInfoService;
060 import org.kuali.rice.kim.bo.ui.GroupDocumentMember;
061 import org.kuali.rice.kim.bo.ui.GroupDocumentQualifier;
062 import org.kuali.rice.kim.bo.ui.KimDocumentRoleMember;
063 import org.kuali.rice.kim.bo.ui.KimDocumentRolePermission;
064 import org.kuali.rice.kim.bo.ui.KimDocumentRoleQualifier;
065 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibility;
066 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibilityAction;
067 import org.kuali.rice.kim.bo.ui.PersonDocumentAddress;
068 import org.kuali.rice.kim.bo.ui.PersonDocumentAffiliation;
069 import org.kuali.rice.kim.bo.ui.PersonDocumentEmail;
070 import org.kuali.rice.kim.bo.ui.PersonDocumentEmploymentInfo;
071 import org.kuali.rice.kim.bo.ui.PersonDocumentGroup;
072 import org.kuali.rice.kim.bo.ui.PersonDocumentName;
073 import org.kuali.rice.kim.bo.ui.PersonDocumentPhone;
074 import org.kuali.rice.kim.bo.ui.PersonDocumentPrivacy;
075 import org.kuali.rice.kim.bo.ui.PersonDocumentRole;
076 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegation;
077 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMember;
078 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMemberQualifier;
079 import org.kuali.rice.kim.document.IdentityManagementGroupDocument;
080 import org.kuali.rice.kim.document.IdentityManagementPersonDocument;
081 import org.kuali.rice.kim.document.IdentityManagementRoleDocument;
082 import org.kuali.rice.kim.framework.services.KimFrameworkServiceLocator;
083 import org.kuali.rice.kim.framework.type.KimTypeService;
084 import org.kuali.rice.kim.impl.KIMPropertyConstants;
085 import org.kuali.rice.kim.impl.common.attribute.KimAttributeDataBo;
086 import org.kuali.rice.kim.impl.common.delegate.DelegateTypeBo;
087 import org.kuali.rice.kim.impl.common.delegate.DelegateMemberAttributeDataBo;
088 import org.kuali.rice.kim.impl.common.delegate.DelegateMemberBo;
089 import org.kuali.rice.kim.impl.group.GroupAttributeBo;
090 import org.kuali.rice.kim.impl.group.GroupBo;
091 import org.kuali.rice.kim.impl.group.GroupMemberBo;
092 import org.kuali.rice.kim.impl.identity.address.EntityAddressBo;
093 import org.kuali.rice.kim.impl.identity.address.EntityAddressTypeBo;
094 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationBo;
095 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationTypeBo;
096 import org.kuali.rice.kim.impl.identity.email.EntityEmailBo;
097 import org.kuali.rice.kim.impl.identity.email.EntityEmailTypeBo;
098 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentBo;
099 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentStatusBo;
100 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentTypeBo;
101 import org.kuali.rice.kim.impl.identity.entity.EntityBo;
102 import org.kuali.rice.kim.impl.identity.name.EntityNameBo;
103 import org.kuali.rice.kim.impl.identity.name.EntityNameTypeBo;
104 import org.kuali.rice.kim.impl.identity.phone.EntityPhoneBo;
105 import org.kuali.rice.kim.impl.identity.phone.EntityPhoneTypeBo;
106 import org.kuali.rice.kim.impl.identity.principal.PrincipalBo;
107 import org.kuali.rice.kim.impl.identity.privacy.EntityPrivacyPreferencesBo;
108 import org.kuali.rice.kim.impl.identity.type.EntityTypeContactInfoBo;
109 import org.kuali.rice.kim.impl.permission.PermissionBo;
110 import org.kuali.rice.kim.impl.responsibility.ResponsibilityInternalService;
111 import org.kuali.rice.kim.impl.role.RoleBo;
112 import org.kuali.rice.kim.impl.role.RoleMemberAttributeDataBo;
113 import org.kuali.rice.kim.impl.role.RoleMemberBo;
114 import org.kuali.rice.kim.impl.role.RolePermissionBo;
115 import org.kuali.rice.kim.impl.role.RoleResponsibilityActionBo;
116 import org.kuali.rice.kim.impl.role.RoleResponsibilityBo;
117 import org.kuali.rice.kim.impl.services.KimImplServiceLocator;
118 import org.kuali.rice.kim.impl.type.KimTypeBo;
119 import org.kuali.rice.kim.service.UiDocumentService;
120 import org.kuali.rice.kim.util.KimCommonUtilsInternal;
121 import org.kuali.rice.kns.datadictionary.exporter.AttributesMapBuilder;
122 import org.kuali.rice.kns.kim.type.DataDictionaryTypeServiceHelper;
123 import org.kuali.rice.krad.bo.BusinessObject;
124 import org.kuali.rice.krad.bo.PersistableBusinessObject;
125 import org.kuali.rice.krad.datadictionary.AttributeDefinition;
126 import org.kuali.rice.krad.datadictionary.exporter.ExportMap;
127 import org.kuali.rice.krad.document.Document;
128 import org.kuali.rice.krad.service.BusinessObjectService;
129 import org.kuali.rice.krad.service.DocumentHelperService;
130 import org.kuali.rice.krad.service.KRADServiceLocator;
131 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
132 import org.kuali.rice.krad.util.KRADConstants;
133 import org.kuali.rice.krad.util.ObjectUtils;
134
135 import java.sql.Timestamp;
136 import java.util.ArrayList;
137 import java.util.Collection;
138 import java.util.Collections;
139 import java.util.Comparator;
140 import java.util.HashMap;
141 import java.util.HashSet;
142 import java.util.List;
143 import java.util.Map;
144 import java.util.Set;
145
146 import static org.kuali.rice.core.api.criteria.PredicateFactory.equal;
147
148 /**
149 * This is a description of what this class does - shyu don't forget to fill this in.
150 *
151 * @author Kuali Rice Team (rice.collab@kuali.org)
152 *
153 */
154 public class UiDocumentServiceImpl implements UiDocumentService {
155 private static final Logger LOG = Logger.getLogger(UiDocumentServiceImpl.class);
156 private static final String SHOW_BLANK_QUALIFIERS = "kim.show.blank.qualifiers";
157
158 private RoleService roleService;
159 private BusinessObjectService businessObjectService;
160 private IdentityService identityService;
161 private PermissionService permissionService;
162 private GroupService groupService;
163 private ResponsibilityService responsibilityService;
164 private ResponsibilityInternalService responsibilityInternalService;
165 private KimTypeInfoService kimTypeInfoService;
166 private DocumentHelperService documentHelperService;
167 private ParameterService parameterService;
168
169
170 /**
171 * @see org.kuali.rice.kim.service.UiDocumentService#saveEntityPerson(IdentityManagementPersonDocument)
172 */
173 public void saveEntityPerson(
174 IdentityManagementPersonDocument identityManagementPersonDocument) {
175 EntityBo kimEntity = new EntityBo();
176 EntityBo origEntity = getEntityBo(identityManagementPersonDocument.getEntityId());
177 boolean creatingNew = true;
178 if (origEntity == null) {
179 origEntity = new EntityBo();
180 kimEntity.setActive(true);
181 } else {
182 // TODO : in order to resolve optimistic locking issue. has to get identity and set the version number if identity records matched
183 // Need to look into this.
184 //kimEntity = origEntity;
185 kimEntity.setActive(origEntity.isActive());
186 kimEntity.setVersionNumber(origEntity.getVersionNumber());
187 creatingNew = false;
188 }
189
190 kimEntity.setId(identityManagementPersonDocument.getEntityId());
191 String initiatorPrincipalId = getInitiatorPrincipalId(identityManagementPersonDocument);
192 boolean inactivatingPrincipal = false;
193 if(canModifyEntity(initiatorPrincipalId, identityManagementPersonDocument.getPrincipalId())){
194 inactivatingPrincipal = setupPrincipal(identityManagementPersonDocument, kimEntity, origEntity.getPrincipals());
195 setupAffiliation(identityManagementPersonDocument, kimEntity, origEntity.getAffiliations(), origEntity.getEmploymentInformation());
196 setupName(identityManagementPersonDocument, kimEntity, origEntity.getNames());
197 // entitytype
198 List<EntityTypeContactInfoBo> entityTypes = new ArrayList<EntityTypeContactInfoBo>();
199 EntityTypeContactInfoBo entityType = new EntityTypeContactInfoBo();
200 entityType.setEntityId(identityManagementPersonDocument.getEntityId());
201 entityType.setEntityTypeCode(KimConstants.EntityTypes.PERSON);
202 entityType.setActive(true);
203 entityTypes.add(entityType);
204 EntityTypeContactInfoBo origEntityType = new EntityTypeContactInfoBo();
205 for (EntityTypeContactInfoBo type : origEntity.getEntityTypeContactInfos()) {
206 // should check identity.entitytypeid, but it's not persist in persondoc yet
207 if (type.getEntityTypeCode()!=null && StringUtils.equals(type.getEntityTypeCode(), entityType.getEntityTypeCode())) {
208 origEntityType = type;
209 entityType.setVersionNumber(type.getVersionNumber());
210 entityType.setActive(type.isActive());
211 }
212 }
213 setupPhone(identityManagementPersonDocument, entityType, origEntityType.getPhoneNumbers());
214 setupEmail(identityManagementPersonDocument, entityType, origEntityType.getEmailAddresses());
215 setupAddress(identityManagementPersonDocument, entityType, origEntityType.getAddresses());
216 kimEntity.setEntityTypeContactInfos(entityTypes);
217 } else{
218 if(ObjectUtils.isNotNull(origEntity.getExternalIdentifiers())) {
219 kimEntity.setExternalIdentifiers(origEntity.getExternalIdentifiers());
220 }
221 if(ObjectUtils.isNotNull(origEntity.getEmploymentInformation())) {
222 kimEntity.setEmploymentInformation(origEntity.getEmploymentInformation());
223 }
224 if(ObjectUtils.isNotNull(origEntity.getAffiliations())) {
225 kimEntity.setAffiliations(origEntity.getAffiliations());
226 }
227 if(ObjectUtils.isNotNull(origEntity.getNames())) {
228 kimEntity.setNames(origEntity.getNames());
229 }
230 if(ObjectUtils.isNotNull(origEntity.getEntityTypeContactInfos())) {
231 kimEntity.setEntityTypeContactInfos(origEntity.getEntityTypeContactInfos());
232 }
233 }
234 if(creatingNew || canOverrideEntityPrivacyPreferences(getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId())) {
235 setupPrivacy(identityManagementPersonDocument, kimEntity, origEntity.getPrivacyPreferences());
236 } else {
237 if(ObjectUtils.isNotNull(origEntity.getPrivacyPreferences())) {
238 kimEntity.setPrivacyPreferences(origEntity.getPrivacyPreferences());
239 }
240 }
241 List <GroupMemberBo> groupPrincipals = populateGroupMembers(identityManagementPersonDocument);
242 List <RoleMemberBo> rolePrincipals = populateRoleMembers(identityManagementPersonDocument);
243 List <DelegateTypeBo> personDelegations = populateDelegations(identityManagementPersonDocument);
244 List <PersistableBusinessObject> bos = new ArrayList<PersistableBusinessObject>();
245 List <RoleResponsibilityActionBo> roleRspActions = populateRoleRspActions(identityManagementPersonDocument);
246 List <RoleMemberAttributeDataBo> blankRoleMemberAttrs = getBlankRoleMemberAttrs(rolePrincipals);
247 bos.add(kimEntity);
248 //if(ObjectUtils.isNotNull(kimEntity.getPrivacyPreferences()))
249 // bos.add(kimEntity.getPrivacyPreferences());
250 bos.addAll(groupPrincipals);
251 bos.addAll(rolePrincipals);
252 bos.addAll(roleRspActions);
253 bos.addAll(personDelegations);
254 // boservice.save(bos) does not handle deleteawarelist
255 getBusinessObjectService().save(bos);
256
257 if (!blankRoleMemberAttrs.isEmpty()) {
258 getBusinessObjectService().delete(blankRoleMemberAttrs);
259 }
260 if ( inactivatingPrincipal ) {
261 //when a person is inactivated, inactivate their group, role, and delegation memberships
262 KimImplServiceLocator.getRoleInternalService().principalInactivated(
263 identityManagementPersonDocument.getPrincipalId());
264 }
265 }
266
267 private String getInitiatorPrincipalId(Document document){
268 try{
269 return document.getDocumentHeader().getWorkflowDocument().getInitiatorPrincipalId();
270 } catch(Exception ex){
271 return null;
272 }
273 }
274
275 public Map<String,Object> getAttributeEntries( List<KimAttributeField> definitions ) {
276 final Map<String,Object> attributeEntries = new HashMap<String,Object>();
277 if (definitions != null) {
278 for (AttributeDefinition definition : DataDictionaryTypeServiceHelper.toKimAttributeDefinitions(definitions)) {
279 final AttributesMapBuilder builder = new AttributesMapBuilder();
280 final ExportMap map = builder.buildAttributeMap(definition, "");
281 attributeEntries.put(definition.getName(),map.getExportData());
282 }
283 }
284 return attributeEntries;
285 }
286
287
288 /**
289 *
290 * @see org.kuali.rice.kim.service.UiDocumentService#loadEntityToPersonDoc(IdentityManagementPersonDocument, String)
291 */
292 public void loadEntityToPersonDoc(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId) {
293 Principal principal = this.getIdentityService().getPrincipal(principalId);
294 if(principal==null) {
295 throw new RuntimeException("Principal does not exist for principal id:"+principalId);
296 }
297
298 identityManagementPersonDocument.setPrincipalId(principal.getPrincipalId());
299 identityManagementPersonDocument.setPrincipalName(principal.getPrincipalName());
300 identityManagementPersonDocument.setPassword(principal.getPassword());
301 identityManagementPersonDocument.setActive(principal.isActive());
302 Entity kimEntity = this.getIdentityService().getEntity(principal.getEntityId());
303 identityManagementPersonDocument.setEntityId(kimEntity.getId());
304 if ( ObjectUtils.isNotNull( kimEntity.getPrivacyPreferences() ) ) {
305 identityManagementPersonDocument.setPrivacy(loadPrivacyReferences(kimEntity.getPrivacyPreferences()));
306 }
307 //identityManagementPersonDocument.setActive(kimEntity.isActive());
308 identityManagementPersonDocument.setAffiliations(loadAffiliations(kimEntity.getAffiliations(),kimEntity.getEmploymentInformation()));
309 identityManagementPersonDocument.setNames(loadNames( identityManagementPersonDocument, principalId, kimEntity.getNames(), identityManagementPersonDocument.getPrivacy().isSuppressName() ));
310 EntityTypeContactInfo entityType = null;
311 for (EntityTypeContactInfo type : kimEntity.getEntityTypeContactInfos()) {
312 if (KimConstants.EntityTypes.PERSON.equals(type.getEntityTypeCode())) {
313 entityType = EntityTypeContactInfo.Builder.create(type).build();
314 }
315 }
316
317 if(entityType!=null){
318 identityManagementPersonDocument.setEmails(loadEmails(identityManagementPersonDocument, principalId, entityType.getEmailAddresses(), identityManagementPersonDocument.getPrivacy().isSuppressEmail()));
319 identityManagementPersonDocument.setPhones(loadPhones(identityManagementPersonDocument, principalId, entityType.getPhoneNumbers(), identityManagementPersonDocument.getPrivacy().isSuppressPhone()));
320 identityManagementPersonDocument.setAddrs(loadAddresses(identityManagementPersonDocument, principalId, entityType.getAddresses(), identityManagementPersonDocument.getPrivacy().isSuppressAddress()));
321 }
322
323 List<Group> groups = getGroupService().getGroups(getGroupService().getDirectGroupIdsByPrincipalId(
324 identityManagementPersonDocument.getPrincipalId()));
325 loadGroupToPersonDoc(identityManagementPersonDocument, groups);
326 loadRoleToPersonDoc(identityManagementPersonDocument);
327 loadDelegationsToPersonDoc(identityManagementPersonDocument);
328 }
329
330 @SuppressWarnings("unchecked")
331 public List<DelegateTypeBo> getPersonDelegations(String principalId){
332 if(principalId==null) {
333 return new ArrayList<DelegateTypeBo>();
334 }
335 Map<String,String> criteria = new HashMap<String,String>(1);
336 criteria.put(KimConstants.PrimaryKeyConstants.MEMBER_ID, principalId);
337 criteria.put( KIMPropertyConstants.DelegationMember.MEMBER_TYPE_CODE, MemberType.PRINCIPAL.getCode() );
338 List<DelegateMemberBo> delegationMembers = (List<DelegateMemberBo>)getBusinessObjectService().findMatching(DelegateMemberBo.class, criteria);
339 List<DelegateTypeBo> delegations = new ArrayList<DelegateTypeBo>();
340 List<String> delegationIds = new ArrayList<String>();
341 if(ObjectUtils.isNotNull(delegationMembers)){
342 for(DelegateMemberBo delegationMember: delegationMembers){
343 if(!delegationIds.contains(delegationMember.getDelegationId())){
344 delegationIds.add(delegationMember.getDelegationId());
345 criteria = new HashMap<String,String>(1);
346 criteria.put(KimConstants.PrimaryKeyConstants.DELEGATION_ID, delegationMember.getDelegationId());
347 delegations.add(getBusinessObjectService().findByPrimaryKey(DelegateTypeBo.class, criteria));
348 }
349 }
350 }
351 return delegations;
352 }
353
354
355 protected void loadDelegationsToPersonDoc(IdentityManagementPersonDocument identityManagementPersonDocument){
356 List<RoleDocumentDelegation> delList = new ArrayList<RoleDocumentDelegation>();
357 RoleDocumentDelegation documentDelegation;
358 List<DelegateTypeBo> origDelegations = getPersonDelegations(identityManagementPersonDocument.getPrincipalId());
359 if(ObjectUtils.isNotNull(origDelegations)){
360 for(DelegateTypeBo del: origDelegations){
361 if(del.isActive()){
362 documentDelegation = new RoleDocumentDelegation();
363 documentDelegation.setActive(del.isActive());
364 documentDelegation.setDelegationId(del.getDelegationId());
365 documentDelegation.setDelegationTypeCode(del.getDelegationTypeCode());
366 documentDelegation.setKimTypeId(del.getKimTypeId());
367 documentDelegation.setMembers(
368 loadDelegationMembers(identityManagementPersonDocument,
369 del.getMembers(), (RoleBo)getMember(MemberType.ROLE, del.getRoleId())));
370 documentDelegation.setRoleId(del.getRoleId());
371 documentDelegation.setEdit(true);
372 delList.add(documentDelegation);
373 }
374 }
375 }
376 identityManagementPersonDocument.setDelegations(delList);
377 setDelegationMembersInDocument(identityManagementPersonDocument);
378 }
379
380 public void setDelegationMembersInDocument(IdentityManagementPersonDocument identityManagementPersonDocument){
381 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getDelegations())){
382 for(RoleDocumentDelegation delegation: identityManagementPersonDocument.getDelegations()){
383 if(CollectionUtils.isNotEmpty(delegation.getMembers())){
384 for(RoleDocumentDelegationMember member: delegation.getMembers()){
385 if (StringUtils.equals(member.getMemberId(), identityManagementPersonDocument.getPrincipalId()))
386 {
387 member.setDelegationTypeCode(delegation.getDelegationTypeCode());
388 identityManagementPersonDocument.getDelegationMembers().add(member);
389 }
390 }
391 }
392 }
393 }
394 }
395
396 protected List<RoleDocumentDelegationMember> loadDelegationMembers(
397 IdentityManagementPersonDocument identityManagementPersonDocument, List<DelegateMemberBo> members, RoleBo roleImpl){
398 List<RoleDocumentDelegationMember> pndMembers = new ArrayList<RoleDocumentDelegationMember>();
399 RoleDocumentDelegationMember pndMember;
400 RoleMemberBo roleMember;
401 if(ObjectUtils.isNotNull(members)){
402 for(DelegateMemberBo member: members){
403 pndMember = new RoleDocumentDelegationMember();
404 pndMember.setActiveFromDate(member.getActiveFromDateValue());
405 pndMember.setActiveToDate(member.getActiveToDateValue());
406 pndMember.setActive(member.isActive(new Timestamp(System.currentTimeMillis())));
407 pndMember.setRoleBo(roleImpl);
408 if(pndMember.isActive()){
409 KimCommonUtilsInternal.copyProperties(pndMember, member);
410 pndMember.setRoleMemberId(member.getRoleMemberId());
411 roleMember = getRoleMemberForRoleMemberId(member.getRoleMemberId());
412 if(roleMember!=null){
413 pndMember.setRoleMemberName(getMemberName(roleMember.getType(), roleMember.getMemberId()));
414 pndMember.setRoleMemberNamespaceCode(getMemberNamespaceCode(roleMember.getType(), roleMember.getMemberId()));
415 }
416 pndMember.setMemberNamespaceCode(getMemberNamespaceCode(member.getType(), member.getMemberId()));
417 pndMember.setMemberName(getMemberName(member.getType(), member.getMemberId()));
418 pndMember.setEdit(true);
419 pndMember.setQualifiers(loadDelegationMemberQualifiers(identityManagementPersonDocument, pndMember.getAttributesHelper().getDefinitions(), member.getAttributeDetails()));
420 pndMembers.add(pndMember);
421 }
422 }
423 }
424 return pndMembers;
425 }
426
427 protected List<RoleDocumentDelegationMemberQualifier> loadDelegationMemberQualifiers(IdentityManagementPersonDocument identityManagementPersonDocument,
428 List<KimAttributeField> origAttributeDefinitions, List<DelegateMemberAttributeDataBo> attributeDataList){
429 List<RoleDocumentDelegationMemberQualifier> pndMemberRoleQualifiers = new ArrayList<RoleDocumentDelegationMemberQualifier>();
430 RoleDocumentDelegationMemberQualifier pndMemberRoleQualifier;
431 boolean attributePresent = false;
432 String origAttributeId;
433 if(origAttributeDefinitions!=null){
434 for(KimAttributeField key: origAttributeDefinitions) {
435 origAttributeId = identityManagementPersonDocument.getKimAttributeDefnId(key);
436 if(ObjectUtils.isNotNull(attributeDataList)){
437 for(DelegateMemberAttributeDataBo memberRoleQualifier: attributeDataList){
438 if(StringUtils.equals(origAttributeId, memberRoleQualifier.getKimAttribute().getId())){
439 pndMemberRoleQualifier = new RoleDocumentDelegationMemberQualifier();
440 pndMemberRoleQualifier.setAttrDataId(memberRoleQualifier.getId());
441 pndMemberRoleQualifier.setAttrVal(memberRoleQualifier.getAttributeValue());
442 pndMemberRoleQualifier.setDelegationMemberId(memberRoleQualifier.getAssignedToId());
443 pndMemberRoleQualifier.setKimTypId(memberRoleQualifier.getKimTypeId());
444 pndMemberRoleQualifier.setKimAttrDefnId(memberRoleQualifier.getKimAttributeId());
445 pndMemberRoleQualifier.setKimAttribute(memberRoleQualifier.getKimAttribute());
446 pndMemberRoleQualifiers.add(pndMemberRoleQualifier);
447 attributePresent = true;
448 }
449 }
450 }
451 if(!attributePresent){
452 pndMemberRoleQualifier = new RoleDocumentDelegationMemberQualifier();
453 pndMemberRoleQualifier.setKimAttrDefnId(origAttributeId);
454 pndMemberRoleQualifiers.add(pndMemberRoleQualifier);
455 }
456 attributePresent = false;
457 }
458 }
459 return pndMemberRoleQualifiers;
460 }
461
462 /**
463 *
464 * This method load related group data to pending document when usert initiate the 'edit'.
465 *
466 * @param identityManagementPersonDocument
467 * @param groups
468 */
469 protected void loadGroupToPersonDoc(IdentityManagementPersonDocument identityManagementPersonDocument, List<? extends Group> groups) {
470 List <PersonDocumentGroup> docGroups = new ArrayList <PersonDocumentGroup>();
471 if(ObjectUtils.isNotNull(groups)){
472 List<String> directMemberPrincipalIds;
473 Collection<GroupMember> groupMemberships;
474 for (Group group: groups) {
475 directMemberPrincipalIds = getGroupService().getDirectMemberPrincipalIds(group.getId());
476 if(ObjectUtils.isNotNull(directMemberPrincipalIds)){
477 directMemberPrincipalIds = new ArrayList<String>(new HashSet<String>(directMemberPrincipalIds));
478 for (String memberId: directMemberPrincipalIds) {
479 // other more direct methods for this ?
480 // can't cast group to 'GroupImpl' because list is GroupInfo type
481 if (StringUtils.equals(memberId, identityManagementPersonDocument.getPrincipalId())) {
482 List<String> groupIds = new ArrayList<String>();
483 groupIds.add(group.getId());
484 groupMemberships = getGroupService().getMembers(groupIds);
485 if(ObjectUtils.isNotNull(groupMemberships)){
486 for (GroupMember groupMember: groupMemberships) {
487 if (groupMember.isActive(new DateTime(System.currentTimeMillis())) && StringUtils.equals(groupMember.getMemberId(), identityManagementPersonDocument.getPrincipalId()) &&
488 KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE.equals(groupMember.getType())) {
489 // create one PersonDocumentGroup per GroupMembershipInfo **
490 PersonDocumentGroup docGroup = new PersonDocumentGroup();
491 docGroup.setGroupId(group.getId());
492 docGroup.setGroupName(group.getName());
493 docGroup.setNamespaceCode(group.getNamespaceCode());
494 docGroup.setPrincipalId(memberId);
495 docGroup.setGroupMemberId(groupMember.getId());
496 if (groupMember.getActiveFromDate() != null) {
497 docGroup.setActiveFromDate(groupMember.getActiveFromDate() == null ? null : new Timestamp(groupMember.getActiveFromDate().getMillis()));
498 }
499 if (groupMember.getActiveToDate() != null) {
500 docGroup.setActiveToDate(groupMember.getActiveToDate() == null ? null : new Timestamp(groupMember.getActiveToDate().getMillis()));
501 }
502 docGroup.setEdit(true);
503 docGroups.add(docGroup);
504 }
505 }
506 }
507 }
508 }
509 }
510 }
511 }
512 identityManagementPersonDocument.setGroups(docGroups);
513 }
514
515 protected void loadRoleToPersonDoc(IdentityManagementPersonDocument identityManagementPersonDocument) {
516 List <PersonDocumentRole> docRoles = new ArrayList <PersonDocumentRole>();
517 List<RoleBo> roles = getRolesForPrincipal(identityManagementPersonDocument.getPrincipalId());
518 List<String> roleIds = new ArrayList<String>();
519 if(ObjectUtils.isNotNull(roles)){
520 for (RoleBo role : roles) {
521 if (!roleIds.contains(role.getId())) {
522 PersonDocumentRole docRole = new PersonDocumentRole();
523 docRole.setKimTypeId(role.getKimTypeId());
524 docRole.setActive(role.isActive());
525 docRole.setNamespaceCode(role.getNamespaceCode());
526 docRole.setEdit(true);
527 docRole.setRoleId(role.getId());
528 docRole.setRoleName(role.getName());
529 docRole.setRolePrncpls(populateDocRolePrncpl(role.getNamespaceCode(), role.getMembers(), identityManagementPersonDocument.getPrincipalId(), getAttributeDefinitionsForRole(docRole)));
530 docRole.refreshReferenceObject("assignedResponsibilities");
531 if(docRole.getRolePrncpls()!=null && !docRole.getRolePrncpls().isEmpty()){
532 docRoles.add(docRole);
533 roleIds.add(role.getId());
534 }
535 }
536 }
537 }
538 for (PersonDocumentRole role : docRoles) {
539 role.setDefinitions(getAttributeDefinitionsForRole(role));
540 // when post again, it will need this during populate
541 role.setNewRolePrncpl(new KimDocumentRoleMember());
542 if(role.getDefinitions()!=null){
543 for (KimAttributeField key : role.getDefinitions()) {
544 KimDocumentRoleQualifier qualifier = new KimDocumentRoleQualifier();
545 //qualifier.setQualifierKey(key);
546 setAttrDefnIdForQualifier(qualifier,key);
547 role.getNewRolePrncpl().getQualifiers().add(qualifier);
548 }
549 }
550 loadRoleRstAction(role);
551 role.setAttributeEntry( getAttributeEntries( role.getDefinitions() ) );
552 }
553 //
554
555 identityManagementPersonDocument.setRoles(docRoles);
556 }
557
558 protected List<KimAttributeField> getAttributeDefinitionsForRole(PersonDocumentRole role) {
559 KimTypeService kimTypeService = KimFrameworkServiceLocator.getKimTypeService(KimTypeBo.to(
560 role.getKimRoleType()));
561 //it is possible that the the kimTypeService is coming from a remote application
562 // and therefore it can't be guarenteed that it is up and working, so using a try/catch to catch this possibility.
563 try {
564 if ( kimTypeService != null ) {
565 return kimTypeService.getAttributeDefinitions(role.getKimTypeId());
566 }
567 } catch (Exception ex) {
568 LOG.warn("Not able to retrieve KimTypeService from remote system for KIM Role Type: " + role.getKimRoleType(), ex);
569 }
570 return Collections.emptyList();
571 }
572
573 protected void loadRoleRstAction(PersonDocumentRole role) {
574 if(role!=null && CollectionUtils.isNotEmpty(role.getRolePrncpls())){
575 for (KimDocumentRoleMember roleMbr : role.getRolePrncpls()) {
576 List<RoleResponsibilityActionBo> actions = getRoleRspActions( roleMbr.getRoleMemberId());
577 if(ObjectUtils.isNotNull(actions)){
578 for (RoleResponsibilityActionBo entRoleRspAction :actions) {
579 KimDocumentRoleResponsibilityAction roleRspAction = new KimDocumentRoleResponsibilityAction();
580 roleRspAction.setRoleResponsibilityId(entRoleRspAction.getRoleResponsibilityId());
581 roleRspAction.setActionTypeCode(entRoleRspAction.getActionTypeCode());
582 roleRspAction.setActionPolicyCode(entRoleRspAction.getActionPolicyCode());
583 roleRspAction.setPriorityNumber(entRoleRspAction.getPriorityNumber());
584 roleRspAction.setRoleResponsibilityActionId(entRoleRspAction.getId());
585 roleRspAction.refreshReferenceObject("roleResponsibility");
586 roleMbr.getRoleRspActions().add(roleRspAction);
587 }
588 }
589 }
590 }
591 }
592
593 protected void setAttrDefnIdForQualifier(KimDocumentRoleQualifier qualifier, KimAttributeField definition) {
594 qualifier.setKimAttrDefnId(getAttributeDefnId(definition));
595 qualifier.refreshReferenceObject("kimAttribute");
596 }
597
598 protected String getAttributeDefnId(KimAttributeField definition) {
599 return definition.getId();
600 }
601
602 private PrincipalBo getPrincipalImpl(String principalId) {
603 Map<String,String> criteria = new HashMap<String,String>(1);
604 criteria.put(KIMPropertyConstants.Principal.PRINCIPAL_ID, principalId);
605 return (PrincipalBo)getBusinessObjectService().findByPrimaryKey(PrincipalBo.class, criteria);
606 }
607
608 public List<EntityEmployment> getEntityEmploymentInformationInfo(String entityId) {
609 EntityBo entityImpl = getEntityBo(entityId);
610 List<EntityEmployment> empInfos = new ArrayList<EntityEmployment>();
611 EntityEmployment empInfo;
612 if(ObjectUtils.isNotNull(entityImpl) && CollectionUtils.isNotEmpty(entityImpl.getEmploymentInformation())){
613 for(EntityEmploymentBo empImpl: entityImpl.getEmploymentInformation()){
614 empInfos.add(EntityEmploymentBo.to(empImpl));
615 }
616 }
617 return empInfos;
618 }
619
620 private EntityBo getEntityBo(String entityId) {
621 EntityBo entityImpl = getBusinessObjectService().findBySinglePrimaryKey(EntityBo.class, entityId);
622 //TODO - remove this hack... This is here because currently jpa only seems to be going 2 levels deep on the eager fetching.
623 if(entityImpl!=null && entityImpl.getEntityTypeContactInfos() != null) {
624 for (EntityTypeContactInfoBo et : entityImpl.getEntityTypeContactInfos()) {
625 et.refresh();
626 }
627 }
628 return entityImpl;
629 }
630
631 @SuppressWarnings("unchecked")
632 protected List<RoleBo> getRolesForPrincipal(String principalId) {
633 if ( principalId == null ) {
634 return new ArrayList<RoleBo>();
635 }
636 Map<String,String> criteria = new HashMap<String,String>( 2 );
637 criteria.put("members.memberId", principalId);
638 criteria.put("members.typeCode", MemberType.PRINCIPAL.getCode());
639 return (List<RoleBo>)getBusinessObjectService().findMatching(RoleBo.class, criteria);
640 }
641
642 @SuppressWarnings("unchecked")
643 protected List<RoleMemberBo> getRoleMembersForPrincipal(String principalId) {
644 if ( principalId == null ) {
645 return new ArrayList<RoleMemberBo>();
646 }
647 Map<String,String> criteria = new HashMap<String,String>( 2 );
648 criteria.put("memberId", principalId);
649 criteria.put("typeCode", MemberType.PRINCIPAL.getCode());
650 return (List<RoleMemberBo>)getBusinessObjectService().findMatching(RoleMemberBo.class, criteria);
651 }
652
653 public RoleMemberBo getRoleMember(String roleMemberId) {
654 if ( roleMemberId == null ) {
655 return null;
656 }
657 Map<String,String> criteria = new HashMap<String,String>( 2 );
658 criteria.put("roleMemberId", roleMemberId);
659 return getBusinessObjectService().findByPrimaryKey(RoleMemberBo.class, criteria);
660 }
661
662 @SuppressWarnings("unchecked")
663 protected List<RoleResponsibilityActionBo> getRoleRspActions(String roleMemberId) {
664 Map<String,String> criteria = new HashMap<String,String>( 1 );
665 criteria.put(KIMPropertyConstants.RoleMember.ROLE_MEMBER_ID, roleMemberId);
666 return (List<RoleResponsibilityActionBo>)getBusinessObjectService().findMatching(RoleResponsibilityActionBo.class, criteria);
667 }
668
669 protected List<KimDocumentRoleMember> populateDocRolePrncpl(String namespaceCode, List <RoleMemberBo> roleMembers, String principalId, List<KimAttributeField> definitions) {
670 List <KimDocumentRoleMember> docRoleMembers = new ArrayList <KimDocumentRoleMember>();
671 if(ObjectUtils.isNotNull(roleMembers)){
672 for (RoleMemberBo rolePrincipal : roleMembers) {
673 if (rolePrincipal.isActive(new Timestamp(System.currentTimeMillis())) && MemberType.PRINCIPAL.equals(
674 rolePrincipal.getType()) &&
675 StringUtils.equals(rolePrincipal.getMemberId(), principalId)) {
676 KimDocumentRoleMember docRolePrncpl = new KimDocumentRoleMember();
677 docRolePrncpl.setMemberId(rolePrincipal.getMemberId());
678 docRolePrncpl.setRoleMemberId(rolePrincipal.getId());
679 docRolePrncpl.setActive(rolePrincipal.isActive(new Timestamp(System.currentTimeMillis())));
680 docRolePrncpl.setRoleId(rolePrincipal.getRoleId());
681 docRolePrncpl.setActiveFromDate(rolePrincipal.getActiveFromDateValue());
682 docRolePrncpl.setActiveToDate(rolePrincipal.getActiveToDateValue());
683 docRolePrncpl.setQualifiers(populateDocRoleQualifier(namespaceCode, rolePrincipal.getAttributeDetails(), definitions));
684 docRolePrncpl.setEdit(true);
685 docRoleMembers.add(docRolePrncpl);
686 }
687 }
688 }
689 return docRoleMembers;
690 }
691
692 // UI layout for rolequalifier is a little different from kimroleattribute set up.
693 // each principal may have member with same role multiple times with different qualifier, but the role
694 // only displayed once, and the qualifier displayed multiple times.
695 protected List<KimDocumentRoleQualifier> populateDocRoleQualifier(String namespaceCode, List <RoleMemberAttributeDataBo> qualifiers, List<KimAttributeField> definitions) {
696
697 List <KimDocumentRoleQualifier> docRoleQualifiers = new ArrayList <KimDocumentRoleQualifier>();
698 if(definitions!=null){
699 for (KimAttributeField definition : definitions) {
700 String attrDefId=definition.getId();
701 boolean qualifierFound = false;
702 if(ObjectUtils.isNotNull(qualifiers)){
703 for (RoleMemberAttributeDataBo qualifier : qualifiers) {
704 if (attrDefId!=null && StringUtils.equals(attrDefId, qualifier.getKimAttributeId())) {
705 KimDocumentRoleQualifier docRoleQualifier = new KimDocumentRoleQualifier();
706 docRoleQualifier.setAttrDataId(qualifier.getId());
707 docRoleQualifier.setAttrVal(qualifier.getAttributeValue());
708 docRoleQualifier.setKimAttrDefnId(qualifier.getKimAttributeId());
709 docRoleQualifier.setKimAttribute(qualifier.getKimAttribute());
710 docRoleQualifier.setKimTypId(qualifier.getKimTypeId());
711 docRoleQualifier.setRoleMemberId(qualifier.getAssignedToId());
712 docRoleQualifier.setEdit(true);
713 formatAttrValIfNecessary(docRoleQualifier);
714 docRoleQualifiers.add(docRoleQualifier);
715 qualifierFound = true;
716 break;
717 }
718 }
719 }
720 if (!qualifierFound) {
721 KimDocumentRoleQualifier docRoleQualifier = new KimDocumentRoleQualifier();
722 docRoleQualifier.setAttrVal("");
723 docRoleQualifier.setKimAttrDefnId(attrDefId);
724 docRoleQualifier.refreshReferenceObject("kimAttribute");
725 docRoleQualifiers.add(docRoleQualifier);
726 }
727 }
728 // If all of the qualifiers are empty, return an empty list
729 // This is to prevent dynamic qualifiers from appearing in the
730 // person maintenance roles tab. see KULRICE-3989 for more detail
731 // and KULRICE-5071 for detail on switching from config value to
732 // application-scoped parameter
733 if (!isBlankRoleQualifierVisible(namespaceCode)) {
734 int qualCount = 0;
735 for (KimDocumentRoleQualifier qual : docRoleQualifiers){
736 if (StringUtils.isEmpty(qual.getAttrVal())){
737 qualCount++;
738 }
739 }
740 if (qualCount == docRoleQualifiers.size()){
741 return new ArrayList <KimDocumentRoleQualifier>();
742 }
743 }
744 }
745 return docRoleQualifiers;
746 }
747
748 protected List<PersonDocumentName> loadNames( IdentityManagementPersonDocument personDoc, String principalId, List <EntityName> names, boolean suppressDisplay ) {
749 List<PersonDocumentName> docNames = new ArrayList<PersonDocumentName>();
750 if(ObjectUtils.isNotNull(names)){
751 for (EntityName name: names) {
752 if(name.isActive()){
753 PersonDocumentName docName = new PersonDocumentName();
754 if (name.getNameType() != null) {
755 docName.setNameCode(name.getNameType().getCode());
756 }
757
758 //We do not need to check the privacy setting here - The UI should care of it
759 docName.setFirstName(name.getFirstNameUnmasked());
760 docName.setLastName(name.getLastNameUnmasked());
761 docName.setMiddleName(name.getMiddleNameUnmasked());
762 docName.setNamePrefix(name.getNamePrefixUnmasked());
763 docName.setNameSuffix(name.getNameSuffixUnmasked());
764
765 docName.setActive(name.isActive());
766 docName.setDflt(name.isDefaultValue());
767 docName.setEdit(true);
768 docName.setEntityNameId(name.getId());
769 docNames.add(docName);
770 }
771 }
772 }
773 return docNames;
774 }
775
776 public boolean canModifyEntity( String currentUserPrincipalId, String toModifyPrincipalId ){
777 return (StringUtils.isNotBlank(currentUserPrincipalId) && StringUtils.isNotBlank(toModifyPrincipalId) &&
778 currentUserPrincipalId.equals(toModifyPrincipalId)) ||
779 getPermissionService().isAuthorized(
780 currentUserPrincipalId,
781 KimConstants.NAMESPACE_CODE,
782 KimConstants.PermissionNames.MODIFY_ENTITY,
783 Collections.<String, String>emptyMap(),
784 Collections.singletonMap(KimConstants.AttributeConstants.PRINCIPAL_ID, currentUserPrincipalId));
785 }
786
787 public boolean canOverrideEntityPrivacyPreferences( String currentUserPrincipalId, String toModifyPrincipalId ){
788 return (StringUtils.isNotBlank(currentUserPrincipalId) && StringUtils.isNotBlank(toModifyPrincipalId) &&
789 currentUserPrincipalId.equals(toModifyPrincipalId)) ||
790 getPermissionService().isAuthorized(
791 currentUserPrincipalId,
792 KimConstants.NAMESPACE_CODE,
793 KimConstants.PermissionNames.OVERRIDE_ENTITY_PRIVACY_PREFERENCES,
794 Collections.<String, String>emptyMap(),
795 Collections.singletonMap(KimConstants.AttributeConstants.PRINCIPAL_ID, currentUserPrincipalId) );
796 }
797
798 protected boolean canAssignToRole(IdentityManagementRoleDocument document, String initiatorPrincipalId){
799 boolean rulePassed = true;
800 Map<String,String> additionalPermissionDetails = new HashMap<String,String>();
801 additionalPermissionDetails.put(KimConstants.AttributeConstants.NAMESPACE_CODE, document.getRoleNamespace());
802 additionalPermissionDetails.put(KimConstants.AttributeConstants.ROLE_NAME, document.getRoleName());
803 if(!getDocumentHelperService().getDocumentAuthorizer(document).isAuthorizedByTemplate(
804 document, KimConstants.NAMESPACE_CODE, KimConstants.PermissionTemplateNames.ASSIGN_ROLE,
805 initiatorPrincipalId, additionalPermissionDetails, null)){
806 rulePassed = false;
807 }
808 return rulePassed;
809 }
810
811 protected List<PersonDocumentAffiliation> loadAffiliations(List <EntityAffiliation> affiliations, List<EntityEmployment> empInfos) {
812 List<PersonDocumentAffiliation> docAffiliations = new ArrayList<PersonDocumentAffiliation>();
813 if(ObjectUtils.isNotNull(affiliations)){
814 for (EntityAffiliation affiliation: affiliations) {
815 if(affiliation.isActive()){
816 PersonDocumentAffiliation docAffiliation = new PersonDocumentAffiliation();
817 docAffiliation.setAffiliationTypeCode(affiliation.getAffiliationType().getCode());
818 docAffiliation.setCampusCode(affiliation.getCampusCode());
819 docAffiliation.setActive(affiliation.isActive());
820 docAffiliation.setDflt(affiliation.isDefaultValue());
821 docAffiliation.setEntityAffiliationId(affiliation.getId());
822 docAffiliation.refreshReferenceObject("affiliationType");
823 // EntityAffiliationImpl does not define empinfos as collection
824 docAffiliations.add(docAffiliation);
825 docAffiliation.setEdit(true);
826 // employment informations
827 List<PersonDocumentEmploymentInfo> docEmploymentInformations = new ArrayList<PersonDocumentEmploymentInfo>();
828 if(ObjectUtils.isNotNull(empInfos)){
829 for (EntityEmployment empInfo: empInfos) {
830 if (empInfo.isActive()
831 && StringUtils.equals(docAffiliation.getEntityAffiliationId(),
832 (empInfo.getEntityAffiliation() != null ? empInfo.getEntityAffiliation().getId() : null))) {
833 PersonDocumentEmploymentInfo docEmpInfo = new PersonDocumentEmploymentInfo();
834 docEmpInfo.setEntityEmploymentId(empInfo.getEmployeeId());
835 docEmpInfo.setEmployeeId(empInfo.getEmployeeId());
836 docEmpInfo.setEmploymentRecordId(empInfo.getEmploymentRecordId());
837 docEmpInfo.setBaseSalaryAmount(empInfo.getBaseSalaryAmount());
838 docEmpInfo.setPrimaryDepartmentCode(empInfo.getPrimaryDepartmentCode());
839 docEmpInfo.setEmploymentStatusCode(empInfo.getEmployeeStatus() != null ? empInfo.getEmployeeStatus().getCode() : null);
840 docEmpInfo.setEmploymentTypeCode(empInfo.getEmployeeType() != null ? empInfo.getEmployeeType().getCode() : null);
841 docEmpInfo.setActive(empInfo.isActive());
842 docEmpInfo.setPrimary(empInfo.isPrimary());
843 docEmpInfo.setEntityAffiliationId(empInfo.getEntityAffiliation() != null ? empInfo.getEntityAffiliation().getId() : null);
844 // there is no version number on KimEntityEmploymentInformationInfo
845 //docEmpInfo.setVersionNumber(empInfo.getVersionNumber());
846 docEmpInfo.setEdit(true);
847 docEmpInfo.refreshReferenceObject("employmentType");
848 docEmploymentInformations.add(docEmpInfo);
849 }
850 }
851 }
852 docAffiliation.setEmpInfos(docEmploymentInformations);
853 }
854 }
855 }
856 return docAffiliations;
857
858 }
859
860 protected boolean setupPrincipal(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity, List<PrincipalBo> origPrincipals) {
861 boolean inactivatingPrincipal = false;
862 List<PrincipalBo> principals = new ArrayList<PrincipalBo>();
863 Principal.Builder principal = Principal.Builder.create(identityManagementPersonDocument.getPrincipalName());
864 principal.setPrincipalId(identityManagementPersonDocument.getPrincipalId());
865 principal.setPassword(identityManagementPersonDocument.getPassword());
866 principal.setActive(identityManagementPersonDocument.isActive());
867 principal.setEntityId(identityManagementPersonDocument.getEntityId());
868 if(ObjectUtils.isNotNull(origPrincipals)){
869 for (PrincipalBo prncpl : origPrincipals) {
870 if (prncpl.getPrincipalId()!=null && StringUtils.equals(prncpl.getPrincipalId(), principal.getPrincipalId())) {
871 principal.setVersionNumber(prncpl.getVersionNumber());
872 principal.setObjectId(prncpl.getObjectId());
873 // check if inactivating the principal
874 if ( prncpl.isActive() && !principal.isActive() ) {
875 inactivatingPrincipal = true;
876 }
877 }
878 }
879 }
880 principals.add(PrincipalBo.from(principal.build()));
881
882 kimEntity.setPrincipals(principals);
883 return inactivatingPrincipal;
884 }
885
886 protected void setupPrivacy(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity, EntityPrivacyPreferencesBo origPrivacy) {
887 EntityPrivacyPreferencesBo privacyPreferences = new EntityPrivacyPreferencesBo();
888 privacyPreferences.setEntityId(identityManagementPersonDocument.getEntityId());
889 privacyPreferences.setSuppressAddress(identityManagementPersonDocument.getPrivacy().isSuppressAddress());
890 privacyPreferences.setSuppressEmail(identityManagementPersonDocument.getPrivacy().isSuppressEmail());
891 privacyPreferences.setSuppressName(identityManagementPersonDocument.getPrivacy().isSuppressName());
892 privacyPreferences.setSuppressPhone(identityManagementPersonDocument.getPrivacy().isSuppressPhone());
893 privacyPreferences.setSuppressPersonal(identityManagementPersonDocument.getPrivacy().isSuppressPersonal());
894 if (ObjectUtils.isNotNull(origPrivacy)) {
895 privacyPreferences.setVersionNumber(origPrivacy.getVersionNumber());
896 privacyPreferences.setObjectId(origPrivacy.getObjectId());
897 }
898 kimEntity.setPrivacyPreferences(privacyPreferences);
899 }
900 protected PersonDocumentPrivacy loadPrivacyReferences(EntityPrivacyPreferences privacyPreferences) {
901 PersonDocumentPrivacy docPrivacy = new PersonDocumentPrivacy();
902 docPrivacy.setSuppressAddress(privacyPreferences.isSuppressAddress());
903 docPrivacy.setSuppressEmail(privacyPreferences.isSuppressEmail());
904 docPrivacy.setSuppressName(privacyPreferences.isSuppressName());
905 docPrivacy.setSuppressPhone(privacyPreferences.isSuppressPhone());
906 docPrivacy.setSuppressPersonal(privacyPreferences.isSuppressPersonal());
907 docPrivacy.setEdit(true);
908 return docPrivacy;
909 }
910
911 protected void setupName(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity, List<EntityNameBo> origNames) {
912 if ( !identityManagementPersonDocument.getPrivacy().isSuppressName() ||
913 canOverrideEntityPrivacyPreferences( getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId() ) ) {
914 List<EntityNameBo> entityNames = new ArrayList<EntityNameBo>();
915 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getNames())){
916 for (PersonDocumentName name : identityManagementPersonDocument.getNames()) {
917 EntityNameBo entityName = new EntityNameBo();
918 entityName.setNameCode(name.getNameCode());
919 if (name.getEntityNameType() != null) {
920 entityName.setNameType(name.getEntityNameType());
921 } else {
922 if (StringUtils.isNotEmpty(name.getNameCode())) {
923 entityName.setNameType(
924 EntityNameTypeBo.from(getIdentityService().getNameType(name.getNameCode())));
925 }
926 }
927 entityName.setFirstName(name.getFirstName());
928 entityName.setLastName(name.getLastName());
929 entityName.setMiddleName(name.getMiddleName());
930 entityName.setNamePrefix(name.getNamePrefix());
931 entityName.setNameSuffix(name.getNameSuffix());
932 entityName.setActive(name.isActive());
933 entityName.setDefaultValue(name.isDflt());
934 entityName.setId(name.getEntityNameId());
935 entityName.setEntityId(identityManagementPersonDocument.getEntityId());
936 if(ObjectUtils.isNotNull(origNames)){
937 for (EntityNameBo origName : origNames) {
938 if (origName.getId()!=null && StringUtils.equals(origName.getId(), entityName.getId())) {
939 entityName.setVersionNumber(origName.getVersionNumber());
940 }
941
942 }
943 }
944 entityNames.add(entityName);
945 }
946 }
947 kimEntity.setNames(entityNames);
948 }
949 }
950
951 protected void setupAffiliation(IdentityManagementPersonDocument identityManagementPersonDocument, EntityBo kimEntity,List<EntityAffiliationBo> origAffiliations, List<EntityEmploymentBo> origEmpInfos) {
952 List<EntityAffiliationBo> entityAffiliations = new ArrayList<EntityAffiliationBo>();
953 // employment informations
954 List<EntityEmploymentBo> entityEmploymentInformations = new ArrayList<EntityEmploymentBo>();
955 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getAffiliations())){
956 for (PersonDocumentAffiliation affiliation : identityManagementPersonDocument.getAffiliations()) {
957 EntityAffiliationBo entityAffiliation = new EntityAffiliationBo();
958 entityAffiliation.setAffiliationTypeCode(affiliation.getAffiliationTypeCode());
959 if (affiliation.getAffiliationType() != null) {
960 entityAffiliation.setAffiliationType(affiliation.getAffiliationType());
961 } else {
962 if (StringUtils.isNotEmpty(affiliation.getAffiliationTypeCode())) {
963 entityAffiliation.setAffiliationType(EntityAffiliationTypeBo.from(getIdentityService().getAffiliationType(
964 affiliation.getAffiliationTypeCode())));
965 }
966 }
967 entityAffiliation.setCampusCode(affiliation.getCampusCode());
968 entityAffiliation.setActive(affiliation.isActive());
969 entityAffiliation.setDefaultValue(affiliation.isDflt());
970 entityAffiliation.setEntityId(identityManagementPersonDocument.getEntityId());
971 entityAffiliation.setId(affiliation.getEntityAffiliationId());
972 if(ObjectUtils.isNotNull(origAffiliations)){
973 // EntityAffiliationImpl does not define empinfos as collection
974 for (EntityAffiliationBo origAffiliation : origAffiliations) {
975 if(isSameAffiliation(origAffiliation, entityAffiliation)){
976 entityAffiliation.setId(origAffiliation.getId());
977 }
978 if (origAffiliation.getId()!=null && StringUtils.equals(origAffiliation.getId(), entityAffiliation.getId())) {
979 entityAffiliation.setVersionNumber(origAffiliation.getVersionNumber());
980 }
981 }
982 }
983 entityAffiliations.add(entityAffiliation);
984 int employeeRecordCounter = origEmpInfos==null?0:origEmpInfos.size();
985 if(CollectionUtils.isNotEmpty(affiliation.getEmpInfos())){
986 for (PersonDocumentEmploymentInfo empInfo : affiliation.getEmpInfos()) {
987 EntityEmploymentBo entityEmpInfo = new EntityEmploymentBo();
988 entityEmpInfo.setId(empInfo.getEntityEmploymentId());
989 entityEmpInfo.setEmployeeId(empInfo.getEmployeeId());
990 entityEmpInfo.setEmploymentRecordId(empInfo.getEmploymentRecordId());
991 entityEmpInfo.setBaseSalaryAmount(empInfo.getBaseSalaryAmount());
992 entityEmpInfo.setPrimaryDepartmentCode(empInfo.getPrimaryDepartmentCode());
993 entityEmpInfo.setEmployeeStatusCode(empInfo.getEmploymentStatusCode());
994 if (empInfo.getEmploymentStatus() != null) {
995 entityEmpInfo.setEmployeeStatus(empInfo.getEmploymentStatus());
996 } else {
997 if (StringUtils.isNotEmpty(empInfo.getEmploymentStatusCode())) {
998 entityEmpInfo.setEmployeeStatus(EntityEmploymentStatusBo
999 .from(getIdentityService().getEmploymentStatus(empInfo.getEmploymentStatusCode())));
1000 }
1001 }
1002 entityEmpInfo.setEmployeeTypeCode(empInfo.getEmploymentTypeCode());
1003 if (empInfo.getEmploymentType() != null) {
1004 entityEmpInfo.setEmployeeType(empInfo.getEmploymentType());
1005 } else {
1006 if (StringUtils.isNotEmpty(empInfo.getEmploymentTypeCode())) {
1007 entityEmpInfo.setEmployeeType(EntityEmploymentTypeBo
1008 .from(getIdentityService().getEmploymentType(empInfo.getEmploymentTypeCode())));
1009 }
1010 }
1011 entityEmpInfo.setActive(empInfo.isActive());
1012 entityEmpInfo.setPrimary(empInfo.isPrimary());
1013 entityEmpInfo.setEntityId(identityManagementPersonDocument.getEntityId());
1014 entityEmpInfo.setEntityAffiliationId(empInfo.getEntityAffiliationId());
1015 if(ObjectUtils.isNotNull(origEmpInfos)){
1016 for (EntityEmploymentBo origEmpInfo : origEmpInfos) {
1017 if(isSameEmpInfo(origEmpInfo, entityEmpInfo)){
1018 entityEmpInfo.setId(entityEmpInfo.getEntityId());
1019 }
1020
1021 if (origEmpInfo.getId()!=null && StringUtils.equals(origEmpInfo.getId(), entityEmpInfo.getId())) {
1022 entityEmpInfo.setVersionNumber(origEmpInfo.getVersionNumber());
1023 entityEmpInfo.setEmploymentRecordId(empInfo.getEmploymentRecordId());
1024 }
1025 }
1026 }
1027 if(StringUtils.isEmpty(entityEmpInfo.getEmploymentRecordId())){
1028 employeeRecordCounter++;
1029 entityEmpInfo.setEmploymentRecordId(employeeRecordCounter+"");
1030 }
1031 entityEmploymentInformations.add(entityEmpInfo);
1032 }
1033 }
1034 }
1035 }
1036 kimEntity.setEmploymentInformation(entityEmploymentInformations);
1037 kimEntity.setAffiliations(entityAffiliations);
1038 }
1039
1040 /*
1041 * Added to address KULRICE-5071 : "Move the 'show blank qualifier' kim toggle from a Config param to a System param"
1042 *
1043 * This method first checks for a namespace specific parameter with a detailTypeCode of "All" and parameterName of "KIM_SHOW_BLANK_QUALIFIERS".
1044 * If no parameter is found, it checks for the config property "kim.show.blank.qualifiers", and defaults to true if no config property exists.
1045 *
1046 */
1047 private boolean isBlankRoleQualifierVisible(String namespaceCode) {
1048 boolean showBlankQualifiers = true;
1049
1050 Parameter param = getParameterService().getParameter(namespaceCode, KRADConstants.DetailTypes.ALL_DETAIL_TYPE, KimConstants.ParameterKey.SHOW_BLANK_QUALIFIERS);
1051 if (param != null) {
1052 showBlankQualifiers = "Y".equals(param.getValue());
1053 } else {
1054 String configProperty = ConfigContext.getCurrentContextConfig().getProperty(SHOW_BLANK_QUALIFIERS);
1055 if (configProperty != null) {
1056 showBlankQualifiers = Boolean.valueOf(configProperty);
1057 }
1058 }
1059
1060 return showBlankQualifiers;
1061 }
1062
1063 private boolean isSameAffiliation(EntityAffiliationBo origAffiliation, EntityAffiliationBo entityAffiliation){
1064 //entityId
1065 //affiliationTypeCode
1066 //campusCode
1067 return (origAffiliation!=null && entityAffiliation!=null) &&
1068 (StringUtils.isNotEmpty(origAffiliation.getCampusCode()) && StringUtils.equals(origAffiliation.getCampusCode(), entityAffiliation.getCampusCode()))
1069 &&
1070 (StringUtils.isNotEmpty(origAffiliation.getAffiliationTypeCode()) && StringUtils.equals(origAffiliation.getAffiliationTypeCode(), entityAffiliation.getAffiliationTypeCode()))
1071 &&
1072 (StringUtils.isNotEmpty(origAffiliation.getEntityId()) && StringUtils.equals(origAffiliation.getEntityId(), entityAffiliation.getEntityId()));
1073 }
1074
1075 private boolean isSameEmpInfo(EntityEmploymentBo origEmpInfo, EntityEmploymentBo entityEmpInfo){
1076 //emp_info:
1077 //employmentRecordId
1078 //entityId
1079 //These should be unique - add a business rule
1080 return (origEmpInfo!=null && entityEmpInfo!=null)
1081 && (StringUtils.isNotEmpty(origEmpInfo.getEmploymentRecordId())
1082 && StringUtils.equals(origEmpInfo.getEmploymentRecordId(), entityEmpInfo.getEmploymentRecordId() )
1083 )
1084 && StringUtils.equals( origEmpInfo.getEntityId(),entityEmpInfo.getEntityId());
1085 }
1086
1087 protected void setupPhone(IdentityManagementPersonDocument identityManagementPersonDocument, EntityTypeContactInfoBo entityType, List<EntityPhoneBo> origPhones) {
1088 if ( !identityManagementPersonDocument.getPrivacy().isSuppressPhone() || canOverrideEntityPrivacyPreferences(getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId()) ) {
1089 List<EntityPhoneBo> entityPhones = new ArrayList<EntityPhoneBo>();
1090 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getPhones())){
1091 for (PersonDocumentPhone phone : identityManagementPersonDocument.getPhones()) {
1092 EntityPhoneBo entityPhone = new EntityPhoneBo();
1093 entityPhone.setPhoneTypeCode(phone.getPhoneTypeCode());
1094 if (phone.getPhoneType() != null) {
1095 entityPhone.setPhoneType(phone.getPhoneType());
1096 } else {
1097 if (StringUtils.isNotEmpty(phone.getPhoneTypeCode())) {
1098 entityPhone.setPhoneType(EntityPhoneTypeBo
1099 .from(getIdentityService().getAddressType(phone.getPhoneTypeCode())));
1100 }
1101 }
1102 entityPhone.setEntityId(identityManagementPersonDocument.getEntityId());
1103 entityPhone.setId(phone.getEntityPhoneId());
1104 entityPhone.setEntityTypeCode(entityType.getEntityTypeCode());
1105 entityPhone.setPhoneNumber(phone.getPhoneNumber());
1106 entityPhone.setCountryCode(phone.getCountryCode());
1107 entityPhone.setExtension(phone.getExtension());
1108 entityPhone.setExtensionNumber(phone.getExtensionNumber());
1109 entityPhone.setActive(phone.isActive());
1110 entityPhone.setDefaultValue(phone.isDflt());
1111 if(ObjectUtils.isNotNull(origPhones)){
1112 for (EntityPhoneContract origPhone : origPhones) {
1113 if (origPhone.getId()!=null && StringUtils.equals(origPhone.getId(), entityPhone.getId())) {
1114 entityPhone.setVersionNumber(origPhone.getVersionNumber());
1115 }
1116 }
1117 }
1118 entityPhone.setId(phone.getEntityPhoneId());
1119 entityPhones.add(entityPhone);
1120 }
1121 }
1122 entityType.setPhoneNumbers(entityPhones);
1123 }
1124 }
1125
1126 protected List<PersonDocumentPhone> loadPhones(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId, List<EntityPhone> entityPhones, boolean suppressDisplay ) {
1127 List<PersonDocumentPhone> docPhones = new ArrayList<PersonDocumentPhone>();
1128 if(ObjectUtils.isNotNull(entityPhones)){
1129 for (EntityPhone phone: entityPhones) {
1130 if(phone.isActive()){
1131 PersonDocumentPhone docPhone = new PersonDocumentPhone();
1132 if (phone.getPhoneType() != null) {
1133 docPhone.setPhoneTypeCode(phone.getPhoneType().getCode());
1134 }
1135 //docPhone.setPhoneType(((KimEntityPhoneImpl)phone).getPhoneType());
1136 docPhone.setEntityTypeCode(phone.getEntityTypeCode());
1137 //We do not need to check the privacy setting here - The UI should care of it
1138 docPhone.setPhoneNumber(phone.getPhoneNumberUnmasked());
1139 docPhone.setCountryCode(phone.getCountryCodeUnmasked());
1140 docPhone.setExtensionNumber(phone.getExtensionNumberUnmasked());
1141
1142 docPhone.setActive(phone.isActive());
1143 docPhone.setDflt(phone.isDefaultValue());
1144 docPhone.setEntityPhoneId(phone.getId());
1145 docPhone.setEdit(true);
1146 docPhones.add(docPhone);
1147 }
1148 }
1149 }
1150 return docPhones;
1151
1152 }
1153
1154 protected void setupEmail(
1155 IdentityManagementPersonDocument identityManagementPersonDocument,
1156 EntityTypeContactInfoBo entityType, List<EntityEmailBo> origEmails) {
1157 if ( !identityManagementPersonDocument.getPrivacy().isSuppressEmail() || canOverrideEntityPrivacyPreferences(getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId()) ) {
1158 List<EntityEmailBo> entityEmails = new ArrayList<EntityEmailBo>();
1159 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getEmails())){
1160 for (PersonDocumentEmail email : identityManagementPersonDocument.getEmails()) {
1161 EntityEmailBo entityEmail = new EntityEmailBo();
1162 entityEmail.setEntityId(identityManagementPersonDocument.getEntityId());
1163 entityEmail.setEntityTypeCode(entityType.getEntityTypeCode());
1164 if (email.getEmailType() != null) {
1165 entityEmail.setEmailType(email.getEmailType());
1166 } else {
1167 if (StringUtils.isNotEmpty(email.getEmailTypeCode())) {
1168 entityEmail.setEmailType(
1169 EntityEmailTypeBo.from(getIdentityService().getEmailType(email.getEmailTypeCode())));
1170 }
1171 }
1172 entityEmail.setEmailTypeCode(email.getEmailTypeCode());
1173 entityEmail.setEmailAddress(email.getEmailAddress());
1174 entityEmail.setActive(email.isActive());
1175 entityEmail.setDefaultValue(email.isDflt());
1176 entityEmail.setId(email.getEntityEmailId());
1177 if(ObjectUtils.isNotNull(origEmails)){
1178 for (EntityEmailContract origEmail : origEmails) {
1179 if (origEmail.getId()!=null && StringUtils.equals(origEmail.getId(), entityEmail.getId())) {
1180 entityEmail.setVersionNumber(origEmail.getVersionNumber());
1181 }
1182 }
1183 }
1184 entityEmails.add(entityEmail);
1185 }
1186 }
1187 entityType.setEmailAddresses(entityEmails);
1188 }
1189 }
1190 protected List<PersonDocumentEmail> loadEmails(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId, List<EntityEmail> entityEmails, boolean suppressDisplay ) {
1191 List<PersonDocumentEmail> emails = new ArrayList<PersonDocumentEmail>();
1192 if(ObjectUtils.isNotNull(entityEmails)){
1193 for (EntityEmail email: entityEmails) {
1194 if(email.isActive()){
1195 PersonDocumentEmail docEmail = new PersonDocumentEmail();
1196 //docEmail.setEntityId(email.getEntityId());
1197 docEmail.setEntityTypeCode(email.getEntityTypeCode());
1198 if (email.getEmailType() != null) {
1199 docEmail.setEmailTypeCode(email.getEmailType().getCode());
1200 }
1201 // EmailType not on info object.
1202 //docEmail.setEmailType(((KimEntityEmailImpl)email).getEmailType());
1203 //We do not need to check the privacy setting here - The UI should care of it
1204 docEmail.setEmailAddress(email.getEmailAddressUnmasked());
1205
1206 docEmail.setActive(email.isActive());
1207 docEmail.setDflt(email.isDefaultValue());
1208 docEmail.setEntityEmailId(email.getId());
1209 docEmail.setEdit(true);
1210 emails.add(docEmail);
1211 }
1212 }
1213 }
1214 return emails;
1215 }
1216
1217 protected void setupAddress(
1218 IdentityManagementPersonDocument identityManagementPersonDocument,
1219 EntityTypeContactInfoBo entityType, List<EntityAddressBo> origAddresses) {
1220 if ( !identityManagementPersonDocument.getPrivacy().isSuppressAddress() || canOverrideEntityPrivacyPreferences(getInitiatorPrincipalId(identityManagementPersonDocument), identityManagementPersonDocument.getPrincipalId()) ) {
1221 List<EntityAddressBo> entityAddresses = new ArrayList<EntityAddressBo>();
1222 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getAddrs())){
1223 for (PersonDocumentAddress address : identityManagementPersonDocument.getAddrs()) {
1224 EntityAddressBo entityAddress = new EntityAddressBo();
1225 entityAddress.setEntityId(identityManagementPersonDocument.getEntityId());
1226 entityAddress.setEntityTypeCode(entityType.getEntityTypeCode());
1227 entityAddress.setAddressTypeCode(address.getAddressTypeCode());
1228 if (address.getAddressType() != null) {
1229 entityAddress.setAddressType(address.getAddressType());
1230 } else {
1231 if (StringUtils.isNotEmpty(address.getAddressTypeCode())) {
1232 entityAddress.setAddressType(EntityAddressTypeBo.from(
1233 getIdentityService().getAddressType(address.getAddressTypeCode())));
1234 }
1235 }
1236 entityAddress.setLine1(address.getLine1());
1237 entityAddress.setLine2(address.getLine2());
1238 entityAddress.setLine3(address.getLine3());
1239 entityAddress.setStateProvinceCode(address.getStateProvinceCode());
1240 entityAddress.setPostalCode(address.getPostalCode());
1241 entityAddress.setCountryCode(address.getCountryCode());
1242 entityAddress.setCity(address.getCity());
1243 entityAddress.setActive(address.isActive());
1244 entityAddress.setDefaultValue(address.isDflt());
1245 entityAddress.setId(address.getEntityAddressId());
1246 if(ObjectUtils.isNotNull(origAddresses)){
1247 for (EntityAddressContract origAddress : origAddresses) {
1248 if (origAddress.getId()!=null && StringUtils.equals(origAddress.getId(), entityAddress.getId())) {
1249 entityAddress.setVersionNumber(origAddress.getVersionNumber());
1250 }
1251 }
1252 }
1253 entityAddresses.add(entityAddress);
1254 }
1255 }
1256 entityType.setAddresses(entityAddresses);
1257 }
1258 }
1259
1260 protected List<PersonDocumentAddress> loadAddresses(IdentityManagementPersonDocument identityManagementPersonDocument, String principalId, List<EntityAddress> entityAddresses, boolean suppressDisplay ) {
1261 List<PersonDocumentAddress> docAddresses = new ArrayList<PersonDocumentAddress>();
1262 if(ObjectUtils.isNotNull(entityAddresses)){
1263 for (EntityAddress address: entityAddresses) {
1264 if(address.isActive()){
1265 PersonDocumentAddress docAddress = new PersonDocumentAddress();
1266 docAddress.setEntityTypeCode(address.getEntityTypeCode());
1267 docAddress.setAddressTypeCode(address.getAddressType().getCode());
1268
1269 //We do not need to check the privacy setting here - The UI should care of it
1270 docAddress.setLine1(address.getLine1Unmasked());
1271 docAddress.setLine2(address.getLine2Unmasked());
1272 docAddress.setLine3(address.getLine3Unmasked());
1273 docAddress.setStateProvinceCode(address.getStateProvinceCodeUnmasked());
1274 docAddress.setPostalCode(address.getPostalCodeUnmasked());
1275 docAddress.setCountryCode(address.getCountryCodeUnmasked());
1276 docAddress.setCity(address.getCityUnmasked());
1277
1278 docAddress.setActive(address.isActive());
1279 docAddress.setDflt(address.isDefaultValue());
1280 docAddress.setEntityAddressId(address.getId());
1281 docAddress.setEdit(true);
1282 docAddresses.add(docAddress);
1283 }
1284 }
1285 }
1286 return docAddresses;
1287 }
1288
1289
1290 protected List <GroupMemberBo> populateGroupMembers(IdentityManagementPersonDocument identityManagementPersonDocument) {
1291 List <GroupMemberBo> groupPrincipals = new ArrayList<GroupMemberBo>();
1292 // List<? extends Group> origGroups = getGroupService().getGroupsByPrincipalId(identityManagementPersonDocument.getPrincipalId());
1293 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getGroups())){
1294 for (PersonDocumentGroup group : identityManagementPersonDocument.getGroups()) {
1295 GroupMember.Builder groupPrincipalImpl = GroupMember.Builder.create(group.getGroupId(), identityManagementPersonDocument.getPrincipalId(), KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE);
1296 if (group.getActiveFromDate() != null) {
1297 groupPrincipalImpl.setActiveFromDate(new DateTime(group.getActiveFromDate().getTime()));
1298 }
1299 if (group.getActiveToDate() != null) {
1300 groupPrincipalImpl.setActiveToDate(new DateTime(group.getActiveToDate().getTime()));
1301 }
1302 groupPrincipalImpl.setId(group.getGroupMemberId());
1303
1304
1305 //groupPrincipalImpl.setVersionNumber(group.getVersionNumber());
1306 // get the ORM-layer optimisic locking value
1307 // TODO: this should be replaced with the retrieval and storage of that value
1308 // in the document tables and not re-retrieved here
1309 Collection<GroupMember> currGroupMembers = getGroupService().getMembers(Collections.singletonList(group.getGroupId()));
1310 if(ObjectUtils.isNotNull(currGroupMembers)){
1311 for (GroupMember origGroupMember: currGroupMembers) {
1312 if (origGroupMember.isActive(new DateTime(System.currentTimeMillis()))
1313 && KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE.equals(origGroupMember.getType())) {
1314 if(origGroupMember.getId()!=null && StringUtils.equals(origGroupMember.getId(), group.getGroupMemberId())){
1315 groupPrincipalImpl.setObjectId(origGroupMember.getObjectId());
1316 groupPrincipalImpl.setVersionNumber(origGroupMember.getVersionNumber());
1317 }
1318 }
1319 }
1320 }
1321
1322 groupPrincipals.add(GroupMemberBo.from(groupPrincipalImpl.build()));
1323
1324 }
1325 }
1326 return groupPrincipals;
1327 }
1328
1329 protected List<RoleMemberBo> populateRoleMembers(IdentityManagementPersonDocument identityManagementPersonDocument) {
1330 List<RoleBo> origRoles = getRolesForPrincipal(identityManagementPersonDocument.getPrincipalId());
1331
1332 List <RoleMemberBo> roleMembers = new ArrayList<RoleMemberBo>();
1333 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getRoles())){
1334 for (PersonDocumentRole role : identityManagementPersonDocument.getRoles()) {
1335 //if(role.isEditable()){
1336 List<RoleMemberBo> origRoleMembers = new ArrayList<RoleMemberBo>();
1337 if(ObjectUtils.isNotNull(origRoles)){
1338 for (RoleBo origRole : origRoles) {
1339 if (origRole.getId()!=null && StringUtils.equals(origRole.getId(), role.getRoleId())) {
1340 origRoleMembers = origRole.getMembers();
1341 break;
1342 }
1343 }
1344 }
1345 if (role.getRolePrncpls().isEmpty()) {
1346 if (!role.getDefinitions().isEmpty()) {
1347 RoleMemberBo roleMemberImpl = new RoleMemberBo();
1348 roleMemberImpl.setRoleId(role.getRoleId());
1349 roleMemberImpl.setMemberId(identityManagementPersonDocument.getPrincipalId());
1350 roleMemberImpl.setType(MemberType.PRINCIPAL);
1351 roleMembers.add(roleMemberImpl);
1352 }
1353 } else {
1354 for (KimDocumentRoleMember roleMember : role.getRolePrncpls()) {
1355 RoleMemberBo roleMemberImpl = new RoleMemberBo();
1356 roleMemberImpl.setRoleId(role.getRoleId());
1357 // TODO : principalId is not ready here yet ?
1358 roleMemberImpl.setMemberId(identityManagementPersonDocument.getPrincipalId());
1359 roleMemberImpl.setType(MemberType.PRINCIPAL);
1360 roleMemberImpl.setId(roleMember.getRoleMemberId());
1361 if (roleMember.getActiveFromDate() != null) {
1362 roleMemberImpl.setActiveFromDateValue(
1363 new java.sql.Timestamp(roleMember.getActiveFromDate().getTime()));
1364 }
1365 if (roleMember.getActiveToDate() != null) {
1366 roleMemberImpl.setActiveToDateValue(
1367 new java.sql.Timestamp(roleMember.getActiveToDate().getTime()));
1368 }
1369 List<RoleMemberAttributeDataBo> origAttributes = new ArrayList<RoleMemberAttributeDataBo>();
1370 if(ObjectUtils.isNotNull(origRoleMembers)){
1371 for (RoleMemberBo origMember : origRoleMembers) {
1372 if (origMember.getId()!=null && StringUtils.equals(origMember.getId(), roleMember.getRoleMemberId())) {
1373 origAttributes = origMember.getAttributeDetails();
1374 roleMemberImpl.setVersionNumber(origMember.getVersionNumber());
1375 }
1376 }
1377 }
1378 List<RoleMemberAttributeDataBo> attributes = new ArrayList<RoleMemberAttributeDataBo>();
1379 if(CollectionUtils.isNotEmpty(roleMember.getQualifiers())){
1380 for (KimDocumentRoleQualifier qualifier : roleMember.getQualifiers()) {
1381 //if (StringUtils.isNotBlank(qualifier.getAttrVal())) {
1382 RoleMemberAttributeDataBo attribute = new RoleMemberAttributeDataBo();
1383 attribute.setId(qualifier.getAttrDataId());
1384 attribute.setAttributeValue(qualifier.getAttrVal());
1385 attribute.setKimAttributeId(qualifier.getKimAttrDefnId());
1386 attribute.setAssignedToId(qualifier.getRoleMemberId());
1387 attribute.setKimTypeId(qualifier.getKimTypId());
1388
1389 updateAttrValIfNecessary(attribute);
1390
1391 if(ObjectUtils.isNotNull(origAttributes)){
1392 for (RoleMemberAttributeDataBo origAttribute : origAttributes) {
1393 if (origAttribute.getId()!=null && StringUtils.equals(origAttribute.getId(), qualifier.getAttrDataId())) {
1394 attribute.setVersionNumber(origAttribute.getVersionNumber());
1395 }
1396 }
1397 }
1398 if (attribute.getVersionNumber() != null || StringUtils.isNotBlank(qualifier.getAttrVal())) {
1399 attributes.add(attribute);
1400 }
1401 //}
1402 }
1403 }
1404 roleMemberImpl.setAttributeDetails(attributes);
1405 roleMembers.add(roleMemberImpl);
1406 }
1407 }
1408 //}
1409 }
1410 }
1411 return roleMembers;
1412 }
1413
1414 protected List<DelegateTypeBo> populateDelegations(IdentityManagementPersonDocument identityManagementPersonDocument){
1415 List<DelegateTypeBo> origDelegations = getPersonDelegations(identityManagementPersonDocument.getPrincipalId());
1416 List<DelegateTypeBo> kimDelegations = new ArrayList<DelegateTypeBo>();
1417 DelegateTypeBo newKimDelegation;
1418 DelegateTypeBo origDelegationImplTemp = null;
1419 List<DelegateMemberBo> origMembers;
1420 boolean activatingInactive = false;
1421 String newDelegationIdAssigned = "";
1422 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getDelegations())){
1423 for(RoleDocumentDelegation roleDocumentDelegation: identityManagementPersonDocument.getDelegations()){
1424 newKimDelegation = new DelegateTypeBo();
1425 KimCommonUtilsInternal.copyProperties(newKimDelegation, roleDocumentDelegation);
1426 newKimDelegation.setRoleId(roleDocumentDelegation.getRoleId());
1427 if(ObjectUtils.isNotNull(origDelegations)){
1428 for(DelegateTypeBo origDelegationImpl: origDelegations){
1429 if((origDelegationImpl.getRoleId()!=null && StringUtils.equals(origDelegationImpl.getRoleId(), newKimDelegation.getRoleId())) &&
1430 (origDelegationImpl.getDelegationId()!=null && StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId()))){
1431 //TODO: verify if you want to add && newRoleMember.isActive() condition to if...
1432 newDelegationIdAssigned = newKimDelegation.getDelegationId();
1433 newKimDelegation.setDelegationId(origDelegationImpl.getDelegationId());
1434 activatingInactive = true;
1435 }
1436 if(origDelegationImpl.getDelegationId()!=null && StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId())){
1437 newKimDelegation.setVersionNumber(origDelegationImpl.getVersionNumber());
1438 origDelegationImplTemp = origDelegationImpl;
1439 }
1440 }
1441 }
1442 origMembers = (origDelegationImplTemp==null || origDelegationImplTemp.getMembers()==null)?
1443 new ArrayList<DelegateMemberBo>():origDelegationImplTemp.getMembers();
1444 newKimDelegation.setMembers(getDelegationMembers(roleDocumentDelegation.getMembers(), origMembers, activatingInactive, newDelegationIdAssigned));
1445 kimDelegations.add(newKimDelegation);
1446 activatingInactive = false;
1447 }
1448 }
1449 return kimDelegations;
1450 }
1451
1452 protected List <RoleMemberAttributeDataBo> getBlankRoleMemberAttrs(List <RoleMemberBo> rolePrncpls) {
1453
1454 List <RoleMemberAttributeDataBo> blankRoleMemberAttrs = new ArrayList<RoleMemberAttributeDataBo>();
1455 if(ObjectUtils.isNotNull(rolePrncpls)){
1456 for (RoleMemberBo roleMbr : rolePrncpls) {
1457 List <RoleMemberAttributeDataBo> roleMemberAttrs = new ArrayList<RoleMemberAttributeDataBo>();
1458 if (CollectionUtils.isNotEmpty(roleMbr.getAttributeDetails())) {
1459 for (RoleMemberAttributeDataBo attr : roleMbr.getAttributeDetails()) {
1460 if (StringUtils.isBlank(attr.getAttributeValue())) {
1461 roleMemberAttrs.add(attr);
1462 }
1463 }
1464 if (!roleMemberAttrs.isEmpty()) {
1465 roleMbr.getAttributeDetails().removeAll(roleMemberAttrs);
1466 blankRoleMemberAttrs.addAll(roleMemberAttrs);
1467 }
1468
1469 }
1470 }
1471 }
1472
1473 return blankRoleMemberAttrs;
1474
1475 }
1476
1477 protected List <RoleResponsibilityActionBo> populateRoleRspActions(IdentityManagementPersonDocument identityManagementPersonDocument) {
1478 // List<RoleImpl> origRoles = getRolesForPrincipal(identityManagementPersonDocument.getPrincipalId());
1479
1480 List <RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
1481 if(CollectionUtils.isNotEmpty(identityManagementPersonDocument.getRoles())){
1482 for (PersonDocumentRole role : identityManagementPersonDocument.getRoles()) {
1483 if(CollectionUtils.isNotEmpty(role.getRolePrncpls())){
1484 for (KimDocumentRoleMember roleMbr : role.getRolePrncpls()) {
1485 if(CollectionUtils.isNotEmpty(roleMbr.getRoleRspActions())){
1486 for (KimDocumentRoleResponsibilityAction roleRspAction : roleMbr.getRoleRspActions()) {
1487 RoleResponsibilityActionBo entRoleRspAction = new RoleResponsibilityActionBo();
1488 entRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
1489 entRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
1490 entRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
1491 entRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
1492 entRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
1493 entRoleRspAction.setRoleResponsibilityId(roleRspAction.getRoleResponsibilityId());
1494 List<RoleResponsibilityActionBo> actions = getRoleRspActions( roleMbr.getRoleMemberId());
1495 if(ObjectUtils.isNotNull(actions)){
1496 for(RoleResponsibilityActionBo orgRspAction : actions) {
1497 if (orgRspAction.getId()!=null && StringUtils.equals(orgRspAction.getId(), roleRspAction.getRoleResponsibilityActionId())) {
1498 entRoleRspAction.setVersionNumber(orgRspAction.getVersionNumber());
1499 }
1500 }
1501 }
1502 roleRspActions.add(entRoleRspAction);
1503 }
1504 }
1505 }
1506 }
1507 }
1508 }
1509 return roleRspActions;
1510
1511 }
1512
1513 protected BusinessObjectService getBusinessObjectService() {
1514 if ( businessObjectService == null ) {
1515 businessObjectService = KRADServiceLocator.getBusinessObjectService();
1516 }
1517 return businessObjectService;
1518 }
1519
1520 protected IdentityService getIdentityService() {
1521 if ( identityService == null ) {
1522 identityService = KimApiServiceLocator.getIdentityService();
1523 }
1524 return identityService;
1525 }
1526
1527 protected GroupService getGroupService() {
1528 if ( groupService == null ) {
1529 groupService = KimApiServiceLocator.getGroupService();
1530 }
1531 return groupService;
1532 }
1533
1534 protected DocumentHelperService getDocumentHelperService() {
1535 if ( documentHelperService == null ) {
1536 documentHelperService = KRADServiceLocatorWeb.getDocumentHelperService();
1537 }
1538 return this.documentHelperService;
1539 }
1540
1541 protected RoleService getRoleService() {
1542 if(roleService == null){
1543 roleService = KimApiServiceLocator.getRoleService();
1544 }
1545 return roleService;
1546 }
1547
1548 public void setRoleService(RoleService roleService) {
1549 this.roleService = roleService;
1550 }
1551
1552 protected ResponsibilityService getResponsibilityService() {
1553 if ( responsibilityService == null ) {
1554 responsibilityService = KimApiServiceLocator.getResponsibilityService();
1555 }
1556 return responsibilityService;
1557 }
1558
1559 public void setResponsibilityService(ResponsibilityService responsibilityService) {
1560 this.responsibilityService = responsibilityService;
1561 }
1562
1563
1564 /* Role document methods */
1565 @SuppressWarnings("unchecked")
1566 public void loadRoleDoc(IdentityManagementRoleDocument identityManagementRoleDocument, Role role){
1567 Map<String, String> criteria = new HashMap<String, String>();
1568 criteria.put(KimConstants.PrimaryKeyConstants.ROLE_ID, role.getId());
1569 RoleBo roleBo = getBusinessObjectService().findByPrimaryKey(RoleBo.class, criteria);
1570
1571 Map<String, String> subClassCriteria = new HashMap<String, String>();
1572 subClassCriteria.put(KimConstants.PrimaryKeyConstants.SUB_ROLE_ID, role.getId());
1573
1574 identityManagementRoleDocument.setRoleId(roleBo.getId());
1575 identityManagementRoleDocument.setKimType(KimTypeBo.to(roleBo.getKimRoleType()));
1576 identityManagementRoleDocument.setRoleTypeName(roleBo.getKimRoleType().getName());
1577 identityManagementRoleDocument.setRoleTypeId(roleBo.getKimTypeId());
1578 identityManagementRoleDocument.setRoleName(roleBo.getName());
1579 identityManagementRoleDocument.setRoleDescription(roleBo.getDescription());
1580 identityManagementRoleDocument.setActive(roleBo.isActive());
1581 identityManagementRoleDocument.setRoleNamespace(roleBo.getNamespaceCode());
1582 identityManagementRoleDocument.setEditing(true);
1583
1584 identityManagementRoleDocument.setPermissions(loadPermissions((List<RolePermissionBo>)getBusinessObjectService().findMatching(RolePermissionBo.class, subClassCriteria)));
1585 identityManagementRoleDocument.setResponsibilities(loadResponsibilities((List<RoleResponsibilityBo>)getBusinessObjectService().findMatching(RoleResponsibilityBo.class, subClassCriteria)));
1586 loadResponsibilityRoleRspActions(identityManagementRoleDocument);
1587 identityManagementRoleDocument.setMembers(loadRoleMembers(identityManagementRoleDocument, roleBo.getMembers()));
1588 loadMemberRoleRspActions(identityManagementRoleDocument);
1589 identityManagementRoleDocument.setDelegations(loadRoleDocumentDelegations(identityManagementRoleDocument, getRoleDelegations(roleBo.getId())));
1590 //Since delegation members are flattened out on the UI...
1591 setDelegationMembersInDocument(identityManagementRoleDocument);
1592 identityManagementRoleDocument.setKimType(KimTypeBo.to(roleBo.getKimRoleType()));
1593 }
1594
1595 public void setDelegationMembersInDocument(IdentityManagementRoleDocument identityManagementRoleDocument){
1596 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getDelegations())){
1597 for(RoleDocumentDelegation delegation: identityManagementRoleDocument.getDelegations()){
1598 if(CollectionUtils.isNotEmpty(delegation.getMembers())){
1599 for(RoleDocumentDelegationMember member: delegation.getMembers()){
1600 member.setDelegationTypeCode(delegation.getDelegationTypeCode());
1601 identityManagementRoleDocument.getDelegationMembers().add(member);
1602 }
1603 }
1604 }
1605 }
1606 }
1607
1608 protected List<KimDocumentRoleResponsibility> loadResponsibilities(List<RoleResponsibilityBo> roleResponsibilities){
1609 List<KimDocumentRoleResponsibility> documentRoleResponsibilities = new ArrayList<KimDocumentRoleResponsibility>();
1610 if(ObjectUtils.isNotNull(roleResponsibilities)){
1611 for(RoleResponsibilityBo roleResponsibility: roleResponsibilities){
1612 if(roleResponsibility.isActive()) {
1613 KimDocumentRoleResponsibility roleResponsibilityCopy = new KimDocumentRoleResponsibility();
1614 KimCommonUtilsInternal.copyProperties(roleResponsibilityCopy, roleResponsibility);
1615 roleResponsibilityCopy.setEdit(true);
1616 documentRoleResponsibilities.add(roleResponsibilityCopy);
1617 }
1618 }
1619 }
1620 return documentRoleResponsibilities;
1621 }
1622
1623 protected List<KimDocumentRolePermission> loadPermissions(List<RolePermissionBo> rolePermissions){
1624 List<KimDocumentRolePermission> documentRolePermissions = new ArrayList<KimDocumentRolePermission>();
1625 KimDocumentRolePermission rolePermissionCopy;
1626 if(ObjectUtils.isNotNull(rolePermissions)){
1627 for(RolePermissionBo rolePermission: rolePermissions){
1628 if ( rolePermission.isActive() ) {
1629 rolePermissionCopy = new KimDocumentRolePermission();
1630 rolePermissionCopy.setRolePermissionId(rolePermission.getId());
1631 rolePermissionCopy.setRoleId(rolePermission.getRoleId());
1632 rolePermissionCopy.setPermissionId(rolePermission.getPermissionId());
1633 rolePermissionCopy.setPermission(PermissionBo.to(rolePermission.getPermission()));
1634 rolePermissionCopy.setEdit(true);
1635 documentRolePermissions.add(rolePermissionCopy);
1636 }
1637 }
1638 }
1639 return documentRolePermissions;
1640 }
1641
1642 protected List<KimDocumentRoleMember> loadRoleMembers(
1643 IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleMemberBo> members){
1644 List<KimDocumentRoleMember> pndMembers = new ArrayList<KimDocumentRoleMember>();
1645 KimDocumentRoleMember pndMember;
1646 if(ObjectUtils.isNotNull(members)){
1647 for(RoleMemberBo member: members){
1648 pndMember = new KimDocumentRoleMember();
1649 pndMember.setActiveFromDate(member.getActiveFromDateValue());
1650 pndMember.setActiveToDate(member.getActiveToDateValue());
1651 pndMember.setActive(member.isActive(new Timestamp(System.currentTimeMillis())));
1652 if(pndMember.isActive()){
1653 pndMember.setRoleMemberId(member.getId());
1654 pndMember.setRoleId(member.getRoleId());
1655 pndMember.setMemberId(member.getMemberId());
1656 pndMember.setMemberNamespaceCode(getMemberNamespaceCode(member.getType(), member.getMemberId()));
1657 pndMember.setMemberName(getMemberName(member.getType(), member.getMemberId()));
1658 pndMember.setMemberFullName(getMemberFullName(member.getType(), member.getMemberId()));
1659 pndMember.setMemberTypeCode(member.getType().getCode());
1660 pndMember.setQualifiers(loadRoleMemberQualifiers(identityManagementRoleDocument, member.getAttributeDetails()));
1661 pndMember.setEdit(true);
1662 pndMembers.add(pndMember);
1663 }
1664 }
1665 }
1666 Collections.sort(pndMembers, identityManagementRoleDocument.getMemberMetaDataType());
1667 return pndMembers;
1668 }
1669
1670 protected void loadResponsibilityRoleRspActions(IdentityManagementRoleDocument identityManagementRoleDocument){
1671 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
1672 for(KimDocumentRoleResponsibility responsibility: identityManagementRoleDocument.getResponsibilities()){
1673 responsibility.getRoleRspActions().addAll(loadKimDocumentRoleRespActions(
1674 getRoleResponsibilityActionImpls(responsibility.getRoleResponsibilityId())));
1675 }
1676 }
1677 }
1678
1679 @SuppressWarnings("unchecked")
1680 protected List<RoleResponsibilityActionBo> getRoleResponsibilityActionImpls(String roleResponsibilityId){
1681 Map<String, String> criteria = new HashMap<String, String>();
1682 criteria.put(KimConstants.PrimaryKeyConstants.ROLE_MEMBER_ID, "*");
1683 criteria.put(KimConstants.PrimaryKeyConstants.ROLE_RESPONSIBILITY_ID, roleResponsibilityId);
1684 return (List<RoleResponsibilityActionBo>)
1685 getBusinessObjectService().findMatching(RoleResponsibilityActionBo.class, criteria);
1686 }
1687
1688 @SuppressWarnings("unchecked")
1689 public List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActionImpls(String roleMemberId){
1690 Map<String, String> criteria = new HashMap<String, String>(1);
1691 criteria.put(KimConstants.PrimaryKeyConstants.ROLE_MEMBER_ID, roleMemberId);
1692 return (List<RoleResponsibilityActionBo>)
1693 getBusinessObjectService().findMatching(RoleResponsibilityActionBo.class, criteria);
1694 }
1695
1696 protected void loadMemberRoleRspActions(IdentityManagementRoleDocument identityManagementRoleDocument){
1697 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getMembers())){
1698 for(KimDocumentRoleMember member: identityManagementRoleDocument.getMembers()){
1699 member.getRoleRspActions().addAll(loadKimDocumentRoleRespActions(
1700 getRoleMemberResponsibilityActionImpls(member.getRoleMemberId()) ) );
1701 }
1702 }
1703 }
1704
1705 protected List<KimDocumentRoleResponsibilityAction> loadKimDocumentRoleRespActions(
1706 List<RoleResponsibilityActionBo> roleRespActionImpls){
1707 List<KimDocumentRoleResponsibilityAction> documentRoleRespActions = new ArrayList<KimDocumentRoleResponsibilityAction>();
1708 KimDocumentRoleResponsibilityAction documentRoleRespAction;
1709 if(ObjectUtils.isNotNull(roleRespActionImpls)){
1710 for(RoleResponsibilityActionBo roleRespActionImpl: roleRespActionImpls){
1711 documentRoleRespAction = new KimDocumentRoleResponsibilityAction();
1712 KimCommonUtilsInternal.copyProperties(documentRoleRespAction, roleRespActionImpl);
1713 // handle the roleResponsibility object being null since not all may be defined when ID value is "*"
1714 if ( ObjectUtils.isNotNull(roleRespActionImpl.getRoleResponsibility()) ) {
1715 documentRoleRespAction.setKimResponsibility(roleRespActionImpl.getRoleResponsibility().getKimResponsibility());
1716 }
1717 documentRoleRespActions.add(documentRoleRespAction);
1718 }
1719 }
1720 return documentRoleRespActions;
1721 }
1722
1723 public BusinessObject getMember(MemberType memberType, String memberId){
1724 Class<? extends BusinessObject> roleMemberTypeClass = null;
1725 String roleMemberIdName = "";
1726 if(MemberType.PRINCIPAL.equals(memberType)) {
1727 roleMemberTypeClass = PrincipalBo.class;
1728 roleMemberIdName = KimConstants.PrimaryKeyConstants.PRINCIPAL_ID;
1729 Principal principalInfo = getIdentityService().getPrincipal(memberId);
1730 if (principalInfo != null) {
1731
1732 }
1733 } else if(MemberType.GROUP.equals(memberType)){
1734 roleMemberTypeClass = GroupBo.class;
1735 roleMemberIdName = KimConstants.PrimaryKeyConstants.GROUP_ID;
1736 Group groupInfo = null;
1737 groupInfo = getGroupService().getGroup(memberId);
1738 if (groupInfo != null) {
1739
1740 }
1741 } else if(MemberType.ROLE.equals(memberType)){
1742 roleMemberTypeClass = RoleBo.class;
1743 roleMemberIdName = KimConstants.PrimaryKeyConstants.ROLE_ID;
1744 Role role = getRoleService().getRole(memberId);
1745 if (role != null) {
1746
1747 }
1748 }
1749 Map<String, String> criteria = new HashMap<String, String>();
1750 criteria.put(roleMemberIdName, memberId);
1751 return getBusinessObjectService().findByPrimaryKey(roleMemberTypeClass, criteria);
1752 }
1753
1754 public String getMemberName(MemberType memberType, String memberId){
1755 if (memberType == null || StringUtils.isEmpty(memberId)) { return "";}
1756 BusinessObject member = getMember(memberType, memberId);
1757 if (member == null) { //not a REAL principal, try to fake the name
1758 String fakeName = "";
1759 Principal kp = KimApiServiceLocator.getIdentityService().getPrincipal(memberId);
1760 if(kp != null && kp.getPrincipalName() != null && !"".equals(kp.getPrincipalName())){
1761 fakeName = kp.getPrincipalName();
1762 }
1763
1764 return fakeName;
1765 }
1766 return getMemberName(memberType, member);
1767 }
1768
1769 public String getMemberFullName(MemberType memberType, String memberId){
1770 if(memberType == null || StringUtils.isEmpty(memberId)) {return "";}
1771 String memberFullName = "";
1772 if(MemberType.PRINCIPAL.equals(memberType)){
1773 Principal principalInfo = null;
1774 principalInfo = getIdentityService().getPrincipal(memberId);
1775 if (principalInfo != null) {
1776 String principalName = principalInfo.getPrincipalName();
1777 Person psn = KimApiServiceLocator.getPersonService().getPersonByPrincipalName(principalName);
1778 memberFullName = psn.getFirstName() + " " + psn.getLastName();
1779 }
1780 } else if(MemberType.GROUP.equals(memberType)){
1781 Group group = null;
1782 group = getGroupService().getGroup(memberId);
1783 if (group != null) {
1784 memberFullName = group.getName();
1785 }
1786
1787 } else if(MemberType.ROLE.equals(memberType)){
1788 Role role = getRoleService().getRole(memberId);
1789 memberFullName = role.getName();
1790 }
1791 return memberFullName;
1792 }
1793
1794 public String getMemberNamespaceCode(MemberType memberType, String memberId){
1795 if(memberType == null || StringUtils.isEmpty(memberId)) {return "";}
1796 String roleMemberNamespaceCode = "";
1797 if(MemberType.PRINCIPAL.equals(memberType)){
1798 roleMemberNamespaceCode = "";
1799 } else if(MemberType.GROUP.equals(memberType)){
1800 Group groupInfo = getGroupService().getGroup(memberId);
1801 if (groupInfo!= null) {
1802 roleMemberNamespaceCode = groupInfo.getNamespaceCode();
1803 }
1804 } else if(MemberType.ROLE.equals(memberType)){
1805 Role role = getRoleService().getRole(memberId);
1806 if (role != null) {
1807 roleMemberNamespaceCode = role.getNamespaceCode();
1808 }
1809 }
1810 return roleMemberNamespaceCode;
1811 }
1812
1813 public String getMemberIdByName(MemberType memberType, String memberNamespaceCode, String memberName){
1814 String memberId = "";
1815 if(MemberType.PRINCIPAL.equals(memberType)){
1816 Principal principal = getIdentityService().getPrincipalByPrincipalName(memberName);
1817 if(principal!=null) {
1818 memberId = principal.getPrincipalId();
1819 }
1820
1821 } else if(MemberType.GROUP.equals(memberType)){
1822 Group groupInfo = getGroupService().getGroupByNameAndNamespaceCode(memberNamespaceCode, memberName);
1823 if (groupInfo!=null) {
1824 memberId = groupInfo.getId();
1825 }
1826
1827 } else if(MemberType.ROLE.equals(memberType)){
1828 memberId = getRoleService().getRoleIdByNameAndNamespaceCode(memberNamespaceCode, memberName);
1829 }
1830 return memberId;
1831 }
1832
1833 public String getMemberName(MemberType memberType, BusinessObject member){
1834 String roleMemberName = "";
1835 if(MemberType.PRINCIPAL.equals(memberType)){
1836 roleMemberName = ((PrincipalBo)member).getPrincipalName();
1837 } else if(MemberType.GROUP.equals(memberType)){
1838 roleMemberName = ((GroupBo)member).getName();
1839 } else if(MemberType.ROLE.equals(memberType)){
1840 roleMemberName = ((RoleBo)member).getName();
1841 }
1842 return roleMemberName;
1843 }
1844
1845 public String getMemberNamespaceCode(MemberType memberType, BusinessObject member){
1846 String roleMemberNamespaceCode = "";
1847 if(MemberType.PRINCIPAL.equals(memberType)){
1848 roleMemberNamespaceCode = "";
1849 } else if(MemberType.GROUP.equals(memberType)){
1850 roleMemberNamespaceCode = ((GroupBo)member).getNamespaceCode();
1851 } else if(MemberType.ROLE.equals(memberType)){
1852 roleMemberNamespaceCode = ((RoleBo)member).getNamespaceCode();
1853 }
1854 return roleMemberNamespaceCode;
1855 }
1856
1857 protected List<KimDocumentRoleQualifier> loadRoleMemberQualifiers(IdentityManagementRoleDocument identityManagementRoleDocument,
1858 List<RoleMemberAttributeDataBo> attributeDataList){
1859 List<KimDocumentRoleQualifier> pndMemberRoleQualifiers = new ArrayList<KimDocumentRoleQualifier>();
1860 KimDocumentRoleQualifier pndMemberRoleQualifier;
1861
1862 // add all attributes from attributeDataList
1863 if(attributeDataList!=null){
1864 for(RoleMemberAttributeDataBo memberRoleQualifier: attributeDataList){
1865 pndMemberRoleQualifier = new KimDocumentRoleQualifier();
1866 pndMemberRoleQualifier.setAttrDataId(memberRoleQualifier.getId());
1867 pndMemberRoleQualifier.setAttrVal(memberRoleQualifier.getAttributeValue());
1868 pndMemberRoleQualifier.setRoleMemberId(memberRoleQualifier.getAssignedToId());
1869 pndMemberRoleQualifier.setKimTypId(memberRoleQualifier.getKimTypeId());
1870 pndMemberRoleQualifier.setKimAttrDefnId(memberRoleQualifier.getKimAttributeId());
1871 pndMemberRoleQualifier.setKimAttribute(memberRoleQualifier.getKimAttribute());
1872 formatAttrValIfNecessary(pndMemberRoleQualifier);
1873 pndMemberRoleQualifiers.add(pndMemberRoleQualifier);
1874 }
1875 }
1876 // also add any attributes already in the document that are not in the attributeDataList
1877 int countOfOriginalAttributesNotPresent = 0;
1878 List<KimDocumentRoleQualifier> fillerRoleQualifiers = new ArrayList<KimDocumentRoleQualifier>();
1879
1880 List<KimAttributeField> origAttributes = identityManagementRoleDocument.getDefinitions();
1881 if ( origAttributes != null ) {
1882 for(KimAttributeField key: origAttributes) {
1883 boolean attributePresent = false;
1884 String origAttributeId = identityManagementRoleDocument.getKimAttributeDefnId(key);
1885 if(attributeDataList!=null){
1886 for(RoleMemberAttributeDataBo memberRoleQualifier: attributeDataList){
1887 if(origAttributeId!=null && StringUtils.equals(origAttributeId, memberRoleQualifier.getKimAttribute().getId())){
1888 attributePresent = true;
1889 break;
1890 }
1891 }
1892 }
1893 if(!attributePresent){
1894 countOfOriginalAttributesNotPresent++;
1895 pndMemberRoleQualifier = new KimDocumentRoleQualifier();
1896 pndMemberRoleQualifier.setKimAttrDefnId(origAttributeId);
1897 pndMemberRoleQualifier.refreshReferenceObject("kimAttribute");
1898 fillerRoleQualifiers.add(pndMemberRoleQualifier);
1899 }
1900 }
1901
1902 if(countOfOriginalAttributesNotPresent != origAttributes.size()) {
1903 pndMemberRoleQualifiers.addAll(fillerRoleQualifiers);
1904 }
1905 }
1906 return pndMemberRoleQualifiers;
1907 }
1908
1909 @SuppressWarnings("unchecked")
1910 public List<DelegateTypeBo> getRoleDelegations(String roleId){
1911 if(roleId==null) {
1912 return new ArrayList<DelegateTypeBo>();
1913 }
1914 Map<String,String> criteria = new HashMap<String,String>(1);
1915 criteria.put("roleId", roleId);
1916 return (List<DelegateTypeBo>)getBusinessObjectService().findMatching(DelegateTypeBo.class, criteria);
1917 }
1918
1919 protected List<RoleDocumentDelegation> loadRoleDocumentDelegations(IdentityManagementRoleDocument identityManagementRoleDocument, List<DelegateTypeBo> delegations){
1920 List<RoleDocumentDelegation> delList = new ArrayList<RoleDocumentDelegation>();
1921 RoleDocumentDelegation documentDelegation;
1922 if(ObjectUtils.isNotNull(delegations)){
1923 for(DelegateTypeBo del: delegations){
1924 documentDelegation = new RoleDocumentDelegation();
1925 documentDelegation.setActive(del.isActive());
1926 if(documentDelegation.isActive()){
1927 documentDelegation.setDelegationId(del.getDelegationId());
1928 documentDelegation.setDelegationTypeCode(del.getDelegationTypeCode());
1929 documentDelegation.setKimTypeId(del.getKimTypeId());
1930 documentDelegation.setMembers(loadDelegationMembers(identityManagementRoleDocument, del.getMembers()));
1931 documentDelegation.setRoleId(del.getRoleId());
1932 documentDelegation.setEdit(true);
1933 delList.add(documentDelegation);
1934 }
1935 }
1936 }
1937 return delList;
1938 }
1939
1940 protected List<RoleDocumentDelegationMember> loadDelegationMembers(IdentityManagementRoleDocument identityManagementRoleDocument, List<DelegateMemberBo> members){
1941 List<RoleDocumentDelegationMember> pndMembers = new ArrayList<RoleDocumentDelegationMember>();
1942 RoleDocumentDelegationMember pndMember;
1943 RoleMemberBo roleMember;
1944 if(ObjectUtils.isNotNull(members)){
1945 for(DelegateMemberBo member: members){
1946 pndMember = new RoleDocumentDelegationMember();
1947 pndMember.setActiveFromDate(member.getActiveFromDateValue());
1948 pndMember.setActiveToDate(member.getActiveToDateValue());
1949 pndMember.setActive(member.isActive(new Timestamp(System.currentTimeMillis())));
1950 if(pndMember.isActive()){
1951 KimCommonUtilsInternal.copyProperties(pndMember, member);
1952 pndMember.setRoleMemberId(member.getRoleMemberId());
1953 roleMember = getRoleMemberForRoleMemberId(member.getRoleMemberId());
1954 if(roleMember!=null){
1955 pndMember.setRoleMemberName(getMemberName(roleMember.getType(), roleMember.getMemberId()));
1956 pndMember.setRoleMemberNamespaceCode(getMemberNamespaceCode(roleMember.getType(), roleMember.getMemberId()));
1957 }
1958 pndMember.setMemberNamespaceCode(getMemberNamespaceCode(member.getType(), member.getMemberId()));
1959 pndMember.setMemberName(getMemberName(member.getType(), member.getMemberId()));
1960 pndMember.setEdit(true);
1961 pndMember.setQualifiers(loadDelegationMemberQualifiers(identityManagementRoleDocument, member.getAttributeDetails()));
1962 pndMembers.add(pndMember);
1963 }
1964 }
1965 }
1966 return pndMembers;
1967 }
1968
1969 protected RoleMemberBo getRoleMemberForRoleMemberId(String roleMemberId){
1970 Map<String,String> criteria = new HashMap<String,String>( 2 );
1971 criteria.put(KimConstants.PrimaryKeyConstants.ID, roleMemberId);
1972 return getBusinessObjectService().findByPrimaryKey(RoleMemberBo.class, criteria);
1973 }
1974
1975 protected List<RoleDocumentDelegationMemberQualifier> loadDelegationMemberQualifiers(IdentityManagementRoleDocument identityManagementRoleDocument,
1976 List<DelegateMemberAttributeDataBo> attributeDataList){
1977 List<RoleDocumentDelegationMemberQualifier> pndMemberRoleQualifiers = new ArrayList<RoleDocumentDelegationMemberQualifier>();
1978 RoleDocumentDelegationMemberQualifier pndMemberRoleQualifier;
1979 List<KimAttributeField> origAttributes = identityManagementRoleDocument.getDefinitions();
1980 boolean attributePresent = false;
1981 String origAttributeId;
1982 if(origAttributes!=null){
1983 for(KimAttributeField key: origAttributes) {
1984 origAttributeId = identityManagementRoleDocument.getKimAttributeDefnId(key);
1985 if(attributeDataList!=null){
1986 for(DelegateMemberAttributeDataBo memberRoleQualifier: attributeDataList){
1987 if(origAttributeId!=null && StringUtils.equals(origAttributeId, memberRoleQualifier.getKimAttribute().getId())){
1988 pndMemberRoleQualifier = new RoleDocumentDelegationMemberQualifier();
1989 pndMemberRoleQualifier.setAttrDataId(memberRoleQualifier.getId());
1990 pndMemberRoleQualifier.setAttrVal(memberRoleQualifier.getAttributeValue());
1991 pndMemberRoleQualifier.setDelegationMemberId(memberRoleQualifier.getAssignedToId());
1992 pndMemberRoleQualifier.setKimTypId(memberRoleQualifier.getKimTypeId());
1993 pndMemberRoleQualifier.setKimAttrDefnId(memberRoleQualifier.getKimAttributeId());
1994 pndMemberRoleQualifier.setKimAttribute(memberRoleQualifier.getKimAttribute());
1995 pndMemberRoleQualifiers.add(pndMemberRoleQualifier);
1996 attributePresent = true;
1997 }
1998 }
1999 }
2000 if(!attributePresent){
2001 pndMemberRoleQualifier = new RoleDocumentDelegationMemberQualifier();
2002 pndMemberRoleQualifier.setKimAttrDefnId(origAttributeId);
2003 pndMemberRoleQualifier.refreshReferenceObject("kimAttribute");
2004 pndMemberRoleQualifiers.add(pndMemberRoleQualifier);
2005 }
2006 attributePresent = false;
2007 }
2008 }
2009 return pndMemberRoleQualifiers;
2010 }
2011
2012 /**
2013 * @see org.kuali.rice.kim.service.UiDocumentService#saveEntityPerson(IdentityManagementPersonDocument)
2014 */
2015 @SuppressWarnings("unchecked")
2016 public void saveRole(IdentityManagementRoleDocument identityManagementRoleDocument) {
2017 RoleBo roleBo = new RoleBo();
2018 Map<String, String> criteria = new HashMap<String, String>();
2019 String roleId = identityManagementRoleDocument.getRoleId();
2020 criteria.put(KimConstants.PrimaryKeyConstants.ID, roleId);
2021 RoleBo origRole = getBusinessObjectService().findByPrimaryKey(RoleBo.class, criteria);
2022
2023 List<RolePermissionBo> origRolePermissions = new ArrayList<RolePermissionBo>();
2024 List<RoleResponsibilityBo> origRoleResponsibilities = new ArrayList<RoleResponsibilityBo>();
2025 List<RoleMemberBo> origRoleMembers = new ArrayList<RoleMemberBo>();
2026 List<DelegateTypeBo> origRoleDelegations = new ArrayList<DelegateTypeBo>();
2027
2028 roleBo.setId(identityManagementRoleDocument.getRoleId());
2029 roleBo.setKimTypeId(identityManagementRoleDocument.getRoleTypeId());
2030 roleBo.setNamespaceCode(identityManagementRoleDocument.getRoleNamespace());
2031 roleBo.setName(identityManagementRoleDocument.getRoleName());
2032 roleBo.setDescription(identityManagementRoleDocument.getRoleDescription());
2033
2034 if (origRole == null) {
2035 origRole = new RoleBo();
2036 roleBo.setActive(true);
2037 } else {
2038 roleBo.setActive(identityManagementRoleDocument.isActive());
2039 roleBo.setVersionNumber(origRole.getVersionNumber());
2040 Map<String, String> altCriteria = new HashMap<String, String>();
2041 altCriteria.put(KimConstants.PrimaryKeyConstants.SUB_ROLE_ID, roleId);
2042 origRolePermissions = new ArrayList<RolePermissionBo>(getBusinessObjectService().findMatching(RolePermissionBo.class, altCriteria));
2043 origRoleResponsibilities = (List<RoleResponsibilityBo>)getBusinessObjectService().findMatching(RoleResponsibilityBo.class, altCriteria);
2044 origRoleMembers = (List<RoleMemberBo>)getBusinessObjectService().findMatching(RoleMemberBo.class, altCriteria);
2045 origRoleDelegations = (List<DelegateTypeBo>)getBusinessObjectService().findMatching(DelegateTypeBo.class, altCriteria);
2046 }
2047
2048 if( getKimTypeInfoService().getKimType(identityManagementRoleDocument.getRoleTypeId()) == null ) {
2049 LOG.error( "Kim type not found for:"+identityManagementRoleDocument.getRoleTypeId(), new Throwable() );
2050 }
2051
2052 List<PersistableBusinessObject> bos = new ArrayList<PersistableBusinessObject>();
2053
2054 bos.add(roleBo);
2055 bos.addAll(getRolePermissions(identityManagementRoleDocument, origRolePermissions));
2056 bos.addAll(getRoleResponsibilities(identityManagementRoleDocument, origRoleResponsibilities));
2057 bos.addAll(getRoleResponsibilitiesActions(identityManagementRoleDocument));
2058 String initiatorPrincipalId = getInitiatorPrincipalId(identityManagementRoleDocument);
2059
2060 if(canAssignToRole(identityManagementRoleDocument, initiatorPrincipalId)){
2061 List<RoleMemberBo> newRoleMembersList = getRoleMembers(identityManagementRoleDocument, origRoleMembers);
2062 roleBo.setMembers(newRoleMembersList);
2063
2064 bos.addAll(getRoleMemberResponsibilityActions(newRoleMembersList));
2065 //bos.addAll(getRoleMemberResponsibilityActions(identityManagementRoleDocument));
2066 bos.addAll(getRoleDelegations(identityManagementRoleDocument, origRoleDelegations));
2067 }
2068 // bos.add(roleBo);
2069 getBusinessObjectService().save(bos);
2070 KimImplServiceLocator.getResponsibilityInternalService().updateActionRequestsForResponsibilityChange(getChangedRoleResponsibilityIds(identityManagementRoleDocument, origRoleResponsibilities));
2071 if(!roleBo.isActive()){
2072 // when a role is inactivated, inactivate the memberships of principals, groups, and roles in
2073 // that role, delegations, and delegation members, and that roles memberships in other roles
2074 KimImplServiceLocator.getRoleInternalService().roleInactivated(identityManagementRoleDocument.getRoleId());
2075 }
2076 }
2077
2078 protected List<RolePermissionBo> getRolePermissions(
2079 IdentityManagementRoleDocument identityManagementRoleDocument, List<RolePermissionBo> origRolePermissions){
2080 List<RolePermissionBo> rolePermissions = new ArrayList<RolePermissionBo>();
2081 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getPermissions())){
2082 for(KimDocumentRolePermission documentRolePermission: identityManagementRoleDocument.getPermissions()){
2083 RolePermissionBo newRolePermission = new RolePermissionBo();
2084 newRolePermission.setId(documentRolePermission.getRolePermissionId());
2085 newRolePermission.setRoleId(identityManagementRoleDocument.getRoleId());
2086 newRolePermission.setPermissionId(documentRolePermission.getPermissionId());
2087 newRolePermission.setActive( documentRolePermission.isActive() );
2088
2089 newRolePermission.setActive(documentRolePermission.isActive());
2090 if (ObjectUtils.isNotNull(origRolePermissions)) {
2091 for (RolePermissionBo origPermissionImpl : origRolePermissions) {
2092 if (!StringUtils.equals(origPermissionImpl.getRoleId(), newRolePermission.getRoleId())
2093 && StringUtils.equals(origPermissionImpl.getPermissionId(), newRolePermission.getPermissionId())
2094 && origPermissionImpl.isActive()
2095 && newRolePermission.isActive()) {
2096 newRolePermission.setId(origPermissionImpl.getId());
2097 }
2098 if(origPermissionImpl.getId()!=null && StringUtils.equals(origPermissionImpl.getId(), newRolePermission.getId())){
2099 newRolePermission.setVersionNumber(origPermissionImpl.getVersionNumber());
2100 newRolePermission.setObjectId(origPermissionImpl.getObjectId());
2101 }
2102 }
2103 }
2104 rolePermissions.add(newRolePermission);
2105 }
2106 }
2107 return rolePermissions;
2108 }
2109
2110 protected List<RoleResponsibilityBo> getRoleResponsibilities(
2111 IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleResponsibilityBo> origRoleResponsibilities){
2112 List<RoleResponsibilityBo> roleResponsibilities = new ArrayList<RoleResponsibilityBo>();
2113 RoleResponsibilityBo newRoleResponsibility;
2114 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2115 for(KimDocumentRoleResponsibility documentRoleResponsibility: identityManagementRoleDocument.getResponsibilities()){
2116 newRoleResponsibility = new RoleResponsibilityBo();
2117 KimCommonUtilsInternal.copyProperties(newRoleResponsibility, documentRoleResponsibility);
2118 newRoleResponsibility.setActive(documentRoleResponsibility.isActive());
2119 newRoleResponsibility.setRoleId(identityManagementRoleDocument.getRoleId());
2120 if(ObjectUtils.isNotNull(origRoleResponsibilities)){
2121 for(RoleResponsibilityBo origResponsibilityImpl: origRoleResponsibilities){
2122 if(!StringUtils.equals(origResponsibilityImpl.getRoleId(), newRoleResponsibility.getRoleId()) &&
2123 StringUtils.equals(origResponsibilityImpl.getResponsibilityId(), newRoleResponsibility.getResponsibilityId()) &&
2124 !origResponsibilityImpl.isActive() && newRoleResponsibility.isActive()){
2125 newRoleResponsibility.setRoleResponsibilityId(origResponsibilityImpl.getRoleResponsibilityId());
2126 }
2127 if(origResponsibilityImpl.getRoleResponsibilityId()!=null && StringUtils.equals(origResponsibilityImpl.getRoleResponsibilityId(), newRoleResponsibility.getRoleResponsibilityId())) {
2128 newRoleResponsibility.setVersionNumber(origResponsibilityImpl.getVersionNumber());
2129 newRoleResponsibility.setObjectId(origResponsibilityImpl.getObjectId());
2130 }
2131 }
2132 }
2133 roleResponsibilities.add(newRoleResponsibility);
2134 }
2135 }
2136 return roleResponsibilities;
2137 }
2138
2139
2140 protected List <RoleResponsibilityActionBo> getRoleResponsibilitiesActions(
2141 IdentityManagementRoleDocument identityManagementRoleDocument){
2142 List <RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2143 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2144 // loop over the responsibilities assigned to the role
2145 for(KimDocumentRoleResponsibility roleResponsibility : identityManagementRoleDocument.getResponsibilities()){
2146 // only process if the actions are not assigned at the role member level
2147 if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResponsibility.getResponsibilityId())){
2148 List<KimDocumentRoleResponsibilityAction> documentRoleResponsibilityActions = roleResponsibility.getRoleRspActions();
2149 if( ObjectUtils.isNotNull(documentRoleResponsibilityActions)
2150 && !documentRoleResponsibilityActions.isEmpty()
2151 && StringUtils.isNotBlank(documentRoleResponsibilityActions.get(0).getRoleResponsibilityActionId() ) ) {
2152 RoleResponsibilityActionBo roleRspAction = new RoleResponsibilityActionBo();
2153 roleRspAction.setId(documentRoleResponsibilityActions.get(0).getRoleResponsibilityActionId());
2154 roleRspAction.setActionPolicyCode(documentRoleResponsibilityActions.get(0).getActionPolicyCode());
2155 roleRspAction.setActionTypeCode(documentRoleResponsibilityActions.get(0).getActionTypeCode());
2156 roleRspAction.setPriorityNumber(documentRoleResponsibilityActions.get(0).getPriorityNumber());
2157 roleRspAction.setForceAction(documentRoleResponsibilityActions.get(0).isForceAction());
2158 roleRspAction.setRoleMemberId("*");
2159 roleRspAction.setRoleResponsibilityId(documentRoleResponsibilityActions.get(0).getRoleResponsibilityId());
2160 updateResponsibilityActionVersionNumber(roleRspAction, getRoleResponsibilityActionImpls(roleResponsibility.getRoleResponsibilityId()));
2161 roleRspActions.add(roleRspAction);
2162 }
2163 }
2164 }
2165 }
2166 return roleRspActions;
2167 }
2168
2169 // FIXME: This should be pulling by the PK, not using another method which pulls multiple records and then finds
2170 // the right one here!
2171 protected void updateResponsibilityActionVersionNumber(RoleResponsibilityActionBo newRoleRspAction,
2172 List<RoleResponsibilityActionBo> origRoleRespActionImpls){
2173 if(ObjectUtils.isNotNull(origRoleRespActionImpls)){
2174 for(RoleResponsibilityActionBo origRoleResponsibilityActionImpl: origRoleRespActionImpls){
2175 if(origRoleResponsibilityActionImpl.getId()!=null && StringUtils.equals(origRoleResponsibilityActionImpl.getId(),
2176 newRoleRspAction.getId())) {
2177 newRoleRspAction.setVersionNumber(origRoleResponsibilityActionImpl.getVersionNumber());
2178 break;
2179 }
2180 }
2181 }
2182 }
2183
2184 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(List<RoleMemberBo> newRoleMembersList){
2185 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2186 if(ObjectUtils.isNotNull(newRoleMembersList)){
2187 for(RoleMemberBo roleMember: newRoleMembersList){
2188 roleRspActions.addAll(roleMember.getRoleRspActions());
2189 }
2190 }
2191 return roleRspActions;
2192 }
2193
2194 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(IdentityManagementRoleDocument identityManagementRoleDocument){
2195 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2196 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getMembers())){
2197 for(KimDocumentRoleMember roleMember: identityManagementRoleDocument.getMembers()){
2198 for(KimDocumentRoleResponsibilityAction roleRspAction : roleMember.getRoleRspActions()){
2199 RoleResponsibilityActionBo entRoleRspAction = new RoleResponsibilityActionBo();
2200 entRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
2201 entRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
2202 entRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
2203 entRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
2204 entRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
2205 entRoleRspAction.setForceAction(roleRspAction.isForceAction());
2206 entRoleRspAction.setRoleResponsibilityId(roleRspAction.getRoleResponsibilityId());
2207 List<RoleResponsibilityActionBo> actions = getRoleRspActions(roleMember.getRoleMemberId());
2208 if(ObjectUtils.isNotNull(actions)){
2209 for(RoleResponsibilityActionBo orgRspAction : actions) {
2210 if (orgRspAction.getId()!=null && StringUtils.equals(orgRspAction.getId(), roleRspAction.getRoleResponsibilityActionId())) {
2211 entRoleRspAction.setVersionNumber(orgRspAction.getVersionNumber());
2212 }
2213 }
2214 }
2215 roleRspActions.add(entRoleRspAction);
2216 }
2217 }
2218 }
2219 return roleRspActions;
2220 }
2221
2222 protected List<RoleMemberBo> getRoleMembers(IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleMemberBo> origRoleMembers){
2223 List<RoleMemberBo> roleMembers = new ArrayList<RoleMemberBo>();
2224 RoleMemberBo newRoleMember;
2225 RoleMemberBo origRoleMemberImplTemp;
2226 List<RoleMemberAttributeDataBo> origAttributes;
2227 boolean activatingInactive = false;
2228 String newRoleMemberIdAssigned = "";
2229
2230 identityManagementRoleDocument.setKimType(KimApiServiceLocator.getKimTypeInfoService().getKimType(identityManagementRoleDocument.getRoleTypeId()));
2231 KimTypeService kimTypeService = KimFrameworkServiceLocator.getKimTypeService(identityManagementRoleDocument.getKimType());
2232
2233 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getMembers())){
2234 for(KimDocumentRoleMember documentRoleMember: identityManagementRoleDocument.getMembers()){
2235 origRoleMemberImplTemp = null;
2236
2237 newRoleMember = new RoleMemberBo();
2238 KimCommonUtilsInternal.copyProperties(newRoleMember, documentRoleMember);
2239 newRoleMember.setId(documentRoleMember.getRoleMemberId());
2240 newRoleMember.setRoleId(identityManagementRoleDocument.getRoleId());
2241 if(ObjectUtils.isNotNull(origRoleMembers)){
2242 for(RoleMemberBo origRoleMemberImpl: origRoleMembers){
2243 if((origRoleMemberImpl.getRoleId()!=null && StringUtils.equals(origRoleMemberImpl.getRoleId(), newRoleMember.getRoleId())) &&
2244 (origRoleMemberImpl.getMemberId()!=null && StringUtils.equals(origRoleMemberImpl.getMemberId(), newRoleMember.getMemberId())) &&
2245 (origRoleMemberImpl.getType()!=null && org.apache.commons.lang.ObjectUtils.equals(origRoleMemberImpl.getType(), newRoleMember.getType())) &&
2246 !origRoleMemberImpl.isActive() &&
2247 !kimTypeService.validateAttributesAgainstExisting(identityManagementRoleDocument.getKimType().getId(),
2248 documentRoleMember.getQualifierAsMap(), origRoleMemberImpl.getAttributes()).isEmpty()) {
2249
2250 //TODO: verify if you want to add && newRoleMember.isActive() condition to if...
2251
2252 newRoleMemberIdAssigned = newRoleMember.getId();
2253 newRoleMember.setId(origRoleMemberImpl.getId());
2254 activatingInactive = true;
2255 }
2256 if(origRoleMemberImpl.getId()!=null && StringUtils.equals(origRoleMemberImpl.getId(), newRoleMember.getId())){
2257 newRoleMember.setVersionNumber(origRoleMemberImpl.getVersionNumber());
2258 origRoleMemberImplTemp = origRoleMemberImpl;
2259 }
2260 }
2261 }
2262 origAttributes = (origRoleMemberImplTemp==null || origRoleMemberImplTemp.getAttributes()==null)?
2263 new ArrayList<RoleMemberAttributeDataBo>():origRoleMemberImplTemp.getAttributeDetails();
2264 newRoleMember.setActiveFromDateValue(documentRoleMember.getActiveFromDate());
2265 newRoleMember.setActiveToDateValue(documentRoleMember.getActiveToDate());
2266 newRoleMember.setAttributeDetails(getRoleMemberAttributeData(documentRoleMember.getQualifiers(), origAttributes, activatingInactive, newRoleMemberIdAssigned));
2267 newRoleMember.setRoleRspActions(getRoleMemberResponsibilityActions(documentRoleMember, origRoleMemberImplTemp, activatingInactive, newRoleMemberIdAssigned));
2268 newRoleMember.setType(MemberType.fromCode(documentRoleMember.getMemberTypeCode()));
2269 roleMembers.add(newRoleMember);
2270 activatingInactive = false;
2271 }
2272 }
2273 return roleMembers;
2274 }
2275
2276 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(
2277 KimDocumentRoleMember documentRoleMember, RoleMemberBo origRoleMemberImplTemp, boolean activatingInactive, String newRoleMemberIdAssigned){
2278 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2279 List<RoleResponsibilityActionBo> origActions = new ArrayList<RoleResponsibilityActionBo>();
2280 if(origRoleMemberImplTemp!=null) {
2281 origActions = getRoleRspActions(origRoleMemberImplTemp.getId());
2282 }
2283 if(CollectionUtils.isNotEmpty(documentRoleMember.getRoleRspActions())){
2284 for(KimDocumentRoleResponsibilityAction roleRspAction : documentRoleMember.getRoleRspActions()){
2285 RoleResponsibilityActionBo newRoleRspAction = new RoleResponsibilityActionBo();
2286 newRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
2287 newRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
2288 newRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
2289 newRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
2290 newRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
2291 newRoleRspAction.setForceAction(roleRspAction.isForceAction());
2292 newRoleRspAction.setRoleResponsibilityId("*");
2293 if(ObjectUtils.isNotNull(origActions)){
2294 for(RoleResponsibilityActionBo origRspAction: origActions) {
2295 if(activatingInactive && StringUtils.equals(origRspAction.getRoleResponsibilityId(), newRoleRspAction.getRoleResponsibilityId()) &&
2296 StringUtils.equals(newRoleRspAction.getRoleMemberId(), newRoleMemberIdAssigned)){
2297 newRoleRspAction.setRoleMemberId(origRspAction.getRoleMemberId());
2298 newRoleRspAction.setId(origRspAction.getId());
2299 }
2300 if (origRspAction.getId()!=null && StringUtils.equals(origRspAction.getId(), newRoleRspAction.getId())) {
2301 newRoleRspAction.setVersionNumber(origRspAction.getVersionNumber());
2302 }
2303 }
2304 }
2305 roleRspActions.add(newRoleRspAction);
2306 }
2307 }
2308 return roleRspActions;
2309 }
2310
2311 protected List<RoleMemberAttributeDataBo> getRoleMemberAttributeData(List<KimDocumentRoleQualifier> qualifiers,
2312 List<RoleMemberAttributeDataBo> origAttributes, boolean activatingInactive, String newRoleMemberIdAssigned){
2313 List<RoleMemberAttributeDataBo> roleMemberAttributeDataList = new ArrayList<RoleMemberAttributeDataBo>();
2314 RoleMemberAttributeDataBo newRoleMemberAttributeData;
2315 if(CollectionUtils.isNotEmpty(qualifiers)){
2316 for(KimDocumentRoleQualifier memberRoleQualifier: qualifiers){
2317 if(StringUtils.isNotBlank(memberRoleQualifier.getAttrVal())){
2318 newRoleMemberAttributeData = new RoleMemberAttributeDataBo();
2319 newRoleMemberAttributeData.setId(memberRoleQualifier.getAttrDataId());
2320 newRoleMemberAttributeData.setAttributeValue(memberRoleQualifier.getAttrVal());
2321 newRoleMemberAttributeData.setAssignedToId(memberRoleQualifier.getRoleMemberId());
2322 newRoleMemberAttributeData.setKimTypeId(memberRoleQualifier.getKimTypId());
2323 newRoleMemberAttributeData.setKimAttributeId(memberRoleQualifier.getKimAttrDefnId());
2324
2325 updateAttrValIfNecessary(newRoleMemberAttributeData);
2326
2327 if(ObjectUtils.isNotNull(origAttributes)){
2328 for(RoleMemberAttributeDataBo origAttribute: origAttributes){
2329 if(activatingInactive && StringUtils.equals(origAttribute.getKimAttributeId(), newRoleMemberAttributeData.getKimAttributeId()) &&
2330 StringUtils.equals(newRoleMemberAttributeData.getAssignedToId(), newRoleMemberIdAssigned)){
2331 newRoleMemberAttributeData.setAssignedToId(origAttribute.getAssignedToId());
2332 newRoleMemberAttributeData.setId(origAttribute.getId());
2333 }
2334 if(origAttribute.getId()!=null && StringUtils.equals(origAttribute.getId(), newRoleMemberAttributeData.getId())){
2335 newRoleMemberAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2336 }
2337 }
2338 }
2339 roleMemberAttributeDataList.add(newRoleMemberAttributeData);
2340 }
2341 }
2342 }
2343 return roleMemberAttributeDataList;
2344 }
2345
2346 /**
2347 * Determines if the attribute value on the attribute data should be updated; if so, it performs some attribute value formatting.
2348 * In the default implementation, this method formats checkbox controls
2349 *
2350 * @param roleMemberAttributeData a role member qualifier attribute to update
2351 */
2352 protected void updateAttrValIfNecessary(RoleMemberAttributeDataBo roleMemberAttributeData) {
2353 if (doCheckboxLogic(roleMemberAttributeData.getKimTypeId(), roleMemberAttributeData.getKimAttributeId())) {
2354 convertCheckboxAttributeData(roleMemberAttributeData);
2355 }
2356 }
2357
2358 protected void formatAttrValIfNecessary(KimDocumentRoleQualifier roleQualifier) {
2359 if (doCheckboxLogic(roleQualifier.getKimTypId(), roleQualifier.getKimAttrDefnId())) {
2360 formatCheckboxAttributeData(roleQualifier);
2361 }
2362 }
2363
2364 private boolean doCheckboxLogic(String kimTypeId, String attrId) {
2365 final KimAttributeField attributeDefinition = getAttributeDefinition(kimTypeId, attrId);
2366 return attributeDefinition != null && attributeDefinition.getAttributeField().getControl() != null && attributeDefinition.getAttributeField().getControl() instanceof RemotableCheckboxGroup;
2367 }
2368
2369 protected void formatCheckboxAttributeData(KimDocumentRoleQualifier roleQualifier) {
2370 if (roleQualifier.getAttrVal().equals(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE)) {
2371 roleQualifier.setAttrVal(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE_DISPLAY);
2372 } else if (roleQualifier.getAttrVal().equals(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE)) {
2373 roleQualifier.setAttrVal(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE_DISPLAY);
2374 }
2375 }
2376
2377 /**
2378 * Finds the KNS attribute used to render the given KimAttributeData
2379 *
2380 * @return the KNS attribute used to render that qualifier, or null if the AttributeDefinition cannot be determined
2381 */
2382 protected KimAttributeField getAttributeDefinition(String kimTypId, String attrDefnId) {
2383 final KimType type = getKimTypeInfoService().getKimType(kimTypId);
2384 if (type != null) {
2385 final KimTypeService typeService = (KimTypeService) KimImplServiceLocator.getBean(type.getServiceName());
2386 if (typeService != null) {
2387 final KimTypeAttribute attributeInfo = type.getAttributeDefinitionById(attrDefnId);
2388 if (attributeInfo != null) {
2389 final List<KimAttributeField> attributeMap = typeService.getAttributeDefinitions(type.getId());
2390 if (attributeMap != null) {
2391 return DataDictionaryTypeServiceHelper.findAttributeField(
2392 attributeInfo.getKimAttribute().getAttributeName(), attributeMap);
2393 }
2394 }
2395 }
2396 }
2397 return null;
2398 }
2399
2400 /**
2401 * Formats the attribute value on this checkbox attribute, changing "on" to "Y" and "off" to "N"
2402 *
2403 * @param roleMemberAttributeData the attribute data to format the attribute value of
2404 */
2405 protected void convertCheckboxAttributeData(RoleMemberAttributeDataBo roleMemberAttributeData) {
2406 if (roleMemberAttributeData.getAttributeValue().equalsIgnoreCase(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE_DISPLAY)) {
2407 roleMemberAttributeData.setAttributeValue(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE);
2408 } else if (roleMemberAttributeData.getAttributeValue().equalsIgnoreCase(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE_DISPLAY)) {
2409 roleMemberAttributeData.setAttributeValue(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE);
2410 }
2411 }
2412
2413 protected List<DelegateTypeBo> getRoleDelegations(IdentityManagementRoleDocument identityManagementRoleDocument, List<DelegateTypeBo> origDelegations){
2414 List<DelegateTypeBo> kimDelegations = new ArrayList<DelegateTypeBo>();
2415 DelegateTypeBo newKimDelegation;
2416 DelegateTypeBo origDelegationImplTemp = null;
2417 List<DelegateMemberBo> origMembers;
2418 boolean activatingInactive = false;
2419 String newDelegationIdAssigned = "";
2420 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getDelegations())){
2421 for(RoleDocumentDelegation roleDocumentDelegation: identityManagementRoleDocument.getDelegations()){
2422 newKimDelegation = new DelegateTypeBo();
2423 KimCommonUtilsInternal.copyProperties(newKimDelegation, roleDocumentDelegation);
2424 newKimDelegation.setRoleId(identityManagementRoleDocument.getRoleId());
2425 if(ObjectUtils.isNotNull(origDelegations)){
2426 for(DelegateTypeBo origDelegationImpl: origDelegations){
2427 if(StringUtils.equals(origDelegationImpl.getRoleId(), newKimDelegation.getRoleId()) &&
2428 StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId())){
2429 //TODO: verify if you want to add && newRoleMember.isActive() condition to if...
2430 newDelegationIdAssigned = newKimDelegation.getDelegationId();
2431 newKimDelegation.setDelegationId(origDelegationImpl.getDelegationId());
2432 activatingInactive = true;
2433 }
2434 if(origDelegationImpl.getDelegationId()!=null && StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId())){
2435 newKimDelegation.setVersionNumber(origDelegationImpl.getVersionNumber());
2436 origDelegationImplTemp = origDelegationImpl;
2437 }
2438 }
2439 }
2440 origMembers = (origDelegationImplTemp == null || origDelegationImplTemp.getMembers()==null)?
2441 new ArrayList<DelegateMemberBo>():origDelegationImplTemp.getMembers();
2442 newKimDelegation.setMembers(getDelegationMembers(roleDocumentDelegation.getMembers(), origMembers, activatingInactive, newDelegationIdAssigned));
2443 kimDelegations.add(newKimDelegation);
2444 activatingInactive = false;
2445 }
2446 }
2447 return kimDelegations;
2448 }
2449
2450 protected List<DelegateMemberBo> getDelegationMembers(List<RoleDocumentDelegationMember> delegationMembers,
2451 List<DelegateMemberBo> origDelegationMembers, boolean activatingInactive, String newDelegationIdAssigned){
2452 List<DelegateMemberBo> delegationsMembersList = new ArrayList<DelegateMemberBo>();
2453 DelegateMemberBo newDelegationMemberImpl;
2454 DelegateMemberBo origDelegationMemberImplTemp = null;
2455 List<DelegateMemberAttributeDataBo> origAttributes;
2456 String delegationMemberId = "";
2457 if(CollectionUtils.isNotEmpty(delegationMembers)){
2458 for(RoleDocumentDelegationMember delegationMember: delegationMembers){
2459 newDelegationMemberImpl = new DelegateMemberBo();
2460 KimCommonUtilsInternal.copyProperties(newDelegationMemberImpl, delegationMember);
2461 newDelegationMemberImpl.setType(MemberType.fromCode(delegationMember.getMemberTypeCode()));
2462 if(ObjectUtils.isNotNull(origDelegationMembers)){
2463 for(DelegateMemberBo origDelegationMember: origDelegationMembers){
2464 if(activatingInactive && StringUtils.equals(origDelegationMember.getMemberId(), newDelegationMemberImpl.getMemberId()) &&
2465 StringUtils.equals(newDelegationMemberImpl.getDelegationId(), newDelegationIdAssigned) &&
2466 !origDelegationMember.isActive(new Timestamp(System.currentTimeMillis()))){
2467 newDelegationMemberImpl.setDelegationId(origDelegationMember.getDelegationId());
2468 delegationMemberId = newDelegationMemberImpl.getDelegationMemberId();
2469 newDelegationMemberImpl.setDelegationMemberId(origDelegationMember.getDelegationMemberId());
2470 }
2471 if(origDelegationMember.getDelegationMemberId()!=null && StringUtils.equals(origDelegationMember.getDelegationMemberId(), newDelegationMemberImpl.getDelegationMemberId())){
2472 newDelegationMemberImpl.setVersionNumber(origDelegationMember.getVersionNumber());
2473 origDelegationMemberImplTemp = origDelegationMember;
2474 }
2475 }
2476 }
2477 origAttributes = (origDelegationMemberImplTemp==null || origDelegationMemberImplTemp.getAttributeDetails()==null)?
2478 new ArrayList<DelegateMemberAttributeDataBo>():origDelegationMemberImplTemp.getAttributeDetails();
2479 newDelegationMemberImpl.setAttributeDetails(getDelegationMemberAttributeData(delegationMember.getQualifiers(), origAttributes, activatingInactive, delegationMemberId));
2480 newDelegationMemberImpl.setActiveFromDateValue(delegationMember.getActiveFromDate());
2481 newDelegationMemberImpl.setActiveToDateValue(delegationMember.getActiveToDate());
2482 delegationsMembersList.add(newDelegationMemberImpl);
2483 }
2484 }
2485 return delegationsMembersList;
2486 }
2487
2488 //TODO: implement logic same as role members - do not insert qualifiers with blank values
2489 protected List<DelegateMemberAttributeDataBo> getDelegationMemberAttributeData(
2490 List<RoleDocumentDelegationMemberQualifier> qualifiers, List<DelegateMemberAttributeDataBo> origAttributes,
2491 boolean activatingInactive, String delegationMemberId){
2492 List<DelegateMemberAttributeDataBo> delegationMemberAttributeDataList = new ArrayList<DelegateMemberAttributeDataBo>();
2493 DelegateMemberAttributeDataBo newDelegationMemberAttributeData;
2494 if(CollectionUtils.isNotEmpty(qualifiers)){
2495 for(RoleDocumentDelegationMemberQualifier memberRoleQualifier: qualifiers){
2496 if(StringUtils.isNotBlank(memberRoleQualifier.getAttrVal())){
2497 newDelegationMemberAttributeData = new DelegateMemberAttributeDataBo();
2498 newDelegationMemberAttributeData.setId(memberRoleQualifier.getAttrDataId());
2499 newDelegationMemberAttributeData.setAttributeValue(memberRoleQualifier.getAttrVal());
2500 newDelegationMemberAttributeData.setAssignedToId(memberRoleQualifier.getDelegationMemberId());
2501 newDelegationMemberAttributeData.setKimTypeId(memberRoleQualifier.getKimTypId());
2502 newDelegationMemberAttributeData.setKimAttributeId(memberRoleQualifier.getKimAttrDefnId());
2503 if(ObjectUtils.isNotNull(origAttributes)){
2504 for(DelegateMemberAttributeDataBo origAttribute: origAttributes){
2505 if(activatingInactive && StringUtils.equals(origAttribute.getKimAttributeId(), newDelegationMemberAttributeData.getKimAttributeId()) &&
2506 StringUtils.equals(newDelegationMemberAttributeData.getAssignedToId(), delegationMemberId)){
2507 newDelegationMemberAttributeData.setAssignedToId(origAttribute.getAssignedToId());
2508 newDelegationMemberAttributeData.setId(origAttribute.getId());
2509 }
2510 if(StringUtils.equals(origAttribute.getId(), newDelegationMemberAttributeData.getId())){
2511 newDelegationMemberAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2512 }
2513 }
2514 }
2515 delegationMemberAttributeDataList.add(newDelegationMemberAttributeData);
2516 }
2517 }
2518 }
2519 return delegationMemberAttributeDataList;
2520 }
2521
2522 /* Group document methods */
2523 public void loadGroupDoc(IdentityManagementGroupDocument identityManagementGroupDocument, Group groupInfo){
2524 //Map<String, String> criteria = new HashMap<String, String>();
2525 //criteria.put(KimApiConstants.PrimaryKeyConstants.GROUP_ID, groupInfo.getId());
2526 //GroupImpl kimGroupImpl = (GroupImpl)
2527 // getBusinessObjectService().findByPrimaryKey(GroupImpl.class, criteria);
2528
2529 identityManagementGroupDocument.setGroupId(groupInfo.getId());
2530 KimType kimType = KimApiServiceLocator.getKimTypeInfoService().getKimType(groupInfo.getKimTypeId());
2531 identityManagementGroupDocument.setKimType(kimType);
2532 identityManagementGroupDocument.setGroupTypeName(kimType.getName());
2533 identityManagementGroupDocument.setGroupTypeId(kimType.getId());
2534 identityManagementGroupDocument.setGroupName(groupInfo.getName());
2535 identityManagementGroupDocument.setGroupDescription(groupInfo.getDescription());
2536 identityManagementGroupDocument.setActive(groupInfo.isActive());
2537 identityManagementGroupDocument.setGroupNamespace(groupInfo.getNamespaceCode());
2538
2539 List<GroupMember> members = new ArrayList(KimApiServiceLocator.getGroupService().getMembersOfGroup(groupInfo.getId()));
2540 identityManagementGroupDocument.setMembers(loadGroupMembers(identityManagementGroupDocument, members));
2541
2542
2543
2544 identityManagementGroupDocument.setQualifiers(loadGroupQualifiers(identityManagementGroupDocument, groupInfo.getAttributes()));
2545 identityManagementGroupDocument.setEditing(true);
2546 }
2547
2548 protected static class GroupMemberNameComparator implements Comparator<GroupDocumentMember> {
2549 /**
2550 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
2551 */
2552 public int compare(GroupDocumentMember m1, GroupDocumentMember m2) {
2553 return m1.getMemberName().compareToIgnoreCase(m2.getMemberName());
2554 }
2555 }
2556
2557 protected GroupMemberNameComparator groupMemberNameComparator = new GroupMemberNameComparator();
2558
2559 protected List<GroupDocumentMember> loadGroupMembers(
2560 IdentityManagementGroupDocument identityManagementGroupDocument, List<GroupMember> members){
2561 List<GroupDocumentMember> pndMembers = new ArrayList<GroupDocumentMember>();
2562 GroupDocumentMember pndMember = new GroupDocumentMember();
2563 if(ObjectUtils.isNotNull(members)){
2564 for(GroupMember member: members){
2565 pndMember = new GroupDocumentMember();
2566
2567 pndMember.setActiveFromDate(member.getActiveFromDate() == null ? null : new Timestamp(member.getActiveFromDate().getMillis()));
2568 pndMember.setActiveToDate(member.getActiveToDate() == null ? null : new Timestamp(member.getActiveToDate().getMillis()));
2569 //pndMember.setActive(member.isActive());
2570 if(pndMember.isActive()){
2571 pndMember.setGroupMemberId(member.getMemberId());
2572 pndMember.setGroupId(member.getGroupId());
2573 pndMember.setMemberId(member.getMemberId());
2574 pndMember.setMemberName(getMemberName(member.getType(), member.getMemberId()));
2575 pndMember.setMemberFullName(getMemberFullName(member.getType(), member.getMemberId()));
2576 pndMember.setMemberTypeCode(member.getType().getCode());
2577 pndMember.setEdit(true);
2578 pndMembers.add(pndMember);
2579 }
2580 }
2581 }
2582 Collections.sort(pndMembers, groupMemberNameComparator);
2583 return pndMembers;
2584 }
2585
2586 protected List<GroupDocumentQualifier> loadGroupQualifiers(IdentityManagementGroupDocument IdentityManagementGroupDocument,
2587 Map<String, String> attributes){
2588 List<GroupDocumentQualifier> pndGroupQualifiers = new ArrayList<GroupDocumentQualifier>();
2589 GroupDocumentQualifier pndGroupQualifier = new GroupDocumentQualifier();
2590 List<KimAttributeField> origAttributes = IdentityManagementGroupDocument.getDefinitions();
2591 boolean attributePresent = false;
2592 String origAttributeId;
2593 if(origAttributes!=null){
2594
2595 for(KimAttributeField key: origAttributes) {
2596 origAttributeId = IdentityManagementGroupDocument.getKimAttributeDefnId(key);
2597 if(!attributes.isEmpty()){
2598
2599 for(GroupAttributeBo groupQualifier: KimAttributeDataBo.createFrom(GroupAttributeBo.class, attributes, IdentityManagementGroupDocument.getGroupTypeId())){
2600 if(origAttributeId!=null && ObjectUtils.isNotNull(groupQualifier.getKimAttribute()) &&
2601 StringUtils.equals(origAttributeId, groupQualifier.getKimAttribute().getId())){
2602 pndGroupQualifier = new GroupDocumentQualifier();
2603 KimCommonUtilsInternal.copyProperties(pndGroupQualifier, groupQualifier);
2604 pndGroupQualifier.setAttrDataId(groupQualifier.getId());
2605 pndGroupQualifier.setAttrVal(groupQualifier.getAttributeValue());
2606 pndGroupQualifier.setKimAttrDefnId(groupQualifier.getKimAttribute().getId());
2607 pndGroupQualifier.setKimTypId(groupQualifier.getKimType().getId());
2608 pndGroupQualifier.setGroupId(groupQualifier.getAssignedToId());
2609 pndGroupQualifiers.add(pndGroupQualifier);
2610 attributePresent = true;
2611 }
2612 }
2613 }
2614 if(!attributePresent){
2615 pndGroupQualifier = new GroupDocumentQualifier();
2616 pndGroupQualifier.setKimAttrDefnId(origAttributeId);
2617 pndGroupQualifiers.add(pndGroupQualifier);
2618 }
2619 attributePresent = false;
2620 }
2621 }
2622 return pndGroupQualifiers;
2623 }
2624
2625 /**
2626 * @see org.kuali.rice.kim.service.UiDocumentService#saveEntityPerson(IdentityManagementPersonDocument)
2627 */
2628 @SuppressWarnings("unchecked")
2629 public void saveGroup(IdentityManagementGroupDocument identityManagementGroupDocument) {
2630 GroupBo kimGroup = new GroupBo();
2631 Map<String, String> criteria = new HashMap<String, String>();
2632 String groupId = identityManagementGroupDocument.getGroupId();
2633 criteria.put("groupId", groupId);
2634 GroupBo origGroup = (GroupBo)getBusinessObjectService().findBySinglePrimaryKey(GroupBo.class, groupId);
2635 List<GroupMemberBo> origGroupMembers = new ArrayList<GroupMemberBo>();
2636 if (ObjectUtils.isNull(origGroup)) {
2637 origGroup = new GroupBo();
2638 kimGroup.setActive(true);
2639 } else {
2640 kimGroup.setVersionNumber(origGroup.getVersionNumber());
2641 //TODO: when a group is inactivated, inactivate the memberships of principals in that group
2642 //and the memberships of that group in roles
2643 kimGroup.setActive(identityManagementGroupDocument.isActive());
2644 origGroupMembers = (List<GroupMemberBo>)getBusinessObjectService().findMatching(GroupMemberBo.class, criteria);
2645 }
2646
2647 kimGroup.setId(identityManagementGroupDocument.getGroupId());
2648 KimType kimType = getKimTypeInfoService().getKimType(identityManagementGroupDocument.getGroupTypeId());
2649 if( kimType == null ) {
2650 throw new RuntimeException("Kim type not found for:"+identityManagementGroupDocument.getGroupTypeId());
2651 }
2652
2653 kimGroup.setKimTypeId(kimType.getId());
2654 kimGroup.setNamespaceCode(identityManagementGroupDocument.getGroupNamespace());
2655 kimGroup.setName(identityManagementGroupDocument.getGroupName());
2656 kimGroup.setDescription(identityManagementGroupDocument.getGroupDescription());
2657 kimGroup.setAttributeDetails(getGroupAttributeData(identityManagementGroupDocument, origGroup.getAttributeDetails()));
2658
2659 List<String> oldIds;
2660 List<String> newIds;
2661 oldIds = getGroupService().getMemberPrincipalIds(kimGroup.getId()); // for the actionList update
2662
2663
2664 List<GroupMemberBo> newGroupMembersList = getGroupMembers(identityManagementGroupDocument, origGroupMembers);
2665 kimGroup.setMembers(newGroupMembersList); // add the new, complete list to the group
2666
2667 kimGroup = (GroupBo)getBusinessObjectService().save(kimGroup);
2668
2669 newIds = kimGroup.getMemberPrincipalIds();
2670 //newIds = getGroupService().getMemberPrincipalIds(kimGroup.getGroupId()); // for the action list update
2671
2672 // Do an async update of the action list for the updated groups
2673 org.kuali.rice.kim.service.KIMServiceLocatorInternal.getGroupInternalService().updateForWorkgroupChange(kimGroup.getId(), oldIds, newIds);
2674 if(!kimGroup.isActive()){
2675 // when a group is inactivated, inactivate the memberships of principals in that group
2676 // and the memberships of that group in roles
2677 KimImplServiceLocator.getRoleInternalService().groupInactivated(identityManagementGroupDocument.getGroupId());
2678 }
2679
2680 }
2681
2682 protected List<GroupMemberBo> getGroupMembers(IdentityManagementGroupDocument identityManagementGroupDocument, List<GroupMemberBo> origGroupMembers){
2683 List<GroupMemberBo> groupMembers = new ArrayList<GroupMemberBo>();
2684 GroupMemberBo newGroupMember;
2685 if(CollectionUtils.isNotEmpty(identityManagementGroupDocument.getMembers())){
2686 for(GroupDocumentMember documentGroupMember: identityManagementGroupDocument.getMembers()){
2687 newGroupMember = new GroupMemberBo();
2688 //KimCommonUtilsInternalInternal.copyProperties(newGroupMember, documentGroupMember);
2689 //copy properties manually for now until new BO created for DocumentGroupMember
2690
2691 newGroupMember.setGroupId(identityManagementGroupDocument.getGroupId());
2692 newGroupMember.setActiveFromDateValue(documentGroupMember.getActiveFromDate());
2693 newGroupMember.setActiveToDateValue(documentGroupMember.getActiveToDate());
2694 newGroupMember.setMemberId(documentGroupMember.getMemberId());
2695 newGroupMember.setTypeCode(documentGroupMember.getMemberTypeCode());
2696 if(ObjectUtils.isNotNull(origGroupMembers)){
2697 for(GroupMemberBo origGroupMemberImpl: origGroupMembers){
2698 if(StringUtils.equals(origGroupMemberImpl.getGroupId(), newGroupMember.getGroupId()) &&
2699 StringUtils.equals(origGroupMemberImpl.getMemberId(), newGroupMember.getMemberId()) &&
2700 !origGroupMemberImpl.isActive(new Timestamp(System.currentTimeMillis()))){
2701 //TODO: verify if you want to add && newGroupMember.isActive() condition to if...
2702 newGroupMember.setMemberId(origGroupMemberImpl.getMemberId());
2703 }
2704 if(StringUtils.equals(origGroupMemberImpl.getGroupId(), newGroupMember.getGroupId()) &&
2705 StringUtils.equals(origGroupMemberImpl.getMemberId(), newGroupMember.getMemberId()) &&
2706 origGroupMemberImpl.isActive(new Timestamp(System.currentTimeMillis()))){
2707 newGroupMember.setId(origGroupMemberImpl.getId());
2708 newGroupMember.setVersionNumber(origGroupMemberImpl.getVersionNumber());
2709 }
2710 }
2711 }
2712 groupMembers.add(newGroupMember);
2713 }
2714 }
2715 return groupMembers;
2716 }
2717
2718 protected List<GroupAttributeBo> getGroupAttributeData(IdentityManagementGroupDocument identityManagementGroupDocument,
2719 List<GroupAttributeBo> origAttributes){
2720 List<GroupAttributeBo> groupAttributeDataList = new ArrayList<GroupAttributeBo>();
2721 GroupAttributeBo newGroupAttributeData;
2722 if(CollectionUtils.isNotEmpty(identityManagementGroupDocument.getQualifiers())){
2723 for(GroupDocumentQualifier groupQualifier: identityManagementGroupDocument.getQualifiers()){
2724 if(StringUtils.isNotBlank(groupQualifier.getAttrVal())){
2725 newGroupAttributeData = new GroupAttributeBo();
2726 newGroupAttributeData.setId(groupQualifier.getAttrDataId());
2727 newGroupAttributeData.setAttributeValue(groupQualifier.getAttrVal());
2728 newGroupAttributeData.setAssignedToId(groupQualifier.getGroupId());
2729 newGroupAttributeData.setKimTypeId(groupQualifier.getKimTypId());
2730 newGroupAttributeData.setKimAttributeId(groupQualifier.getKimAttrDefnId());
2731 if(ObjectUtils.isNotNull(origAttributes)){
2732 for(GroupAttributeBo origAttribute: origAttributes){
2733 if(StringUtils.equals(origAttribute.getKimAttributeId(), newGroupAttributeData.getKimAttributeId()) &&
2734 StringUtils.equals(newGroupAttributeData.getAssignedToId(), origAttribute.getAssignedToId())){
2735 newGroupAttributeData.setId(origAttribute.getId());
2736 }
2737 if(origAttribute.getId()!=null && StringUtils.equals(origAttribute.getId(), newGroupAttributeData.getId())){
2738 newGroupAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2739 }
2740 }
2741 }
2742 groupAttributeDataList.add(newGroupAttributeData);
2743 }
2744 }
2745 }
2746 return groupAttributeDataList;
2747 }
2748
2749 @SuppressWarnings("unchecked")
2750 public KimDocumentRoleMember getKimDocumentRoleMember(MemberType memberType, String memberId, String roleId){
2751 if(memberType == null || StringUtils.isEmpty(memberId) || StringUtils.isEmpty(roleId)) {
2752 return null;
2753 }
2754 KimDocumentRoleMember documentRoleMember = new KimDocumentRoleMember();
2755 documentRoleMember.setRoleId(roleId);
2756 Map<String, String> criteria = new HashMap<String, String>();
2757 criteria.put("roleId", roleId);
2758 criteria.put("mbr_id", memberId);
2759
2760 List<RoleMemberBo> matchingRoleMembers = (List<RoleMemberBo>)getBusinessObjectService().findMatching(RoleMemberBo.class, criteria);
2761 if (matchingRoleMembers==null || matchingRoleMembers.size()<1) { return null; }
2762
2763 RoleMemberBo roleMemberImpl = matchingRoleMembers.get(0);
2764 documentRoleMember.setRoleMemberId(roleMemberImpl.getId());
2765 if(MemberType.PRINCIPAL.equals(memberType)){
2766 Principal principal = getIdentityService().getPrincipal(memberId);
2767 if (principal != null) {
2768 documentRoleMember.setMemberId(principal.getPrincipalId());
2769 documentRoleMember.setMemberName(principal.getPrincipalName());
2770 documentRoleMember.setMemberTypeCode(MemberType.PRINCIPAL.getCode());
2771 }
2772 } else if(MemberType.GROUP.equals(memberType)){
2773 Group group = getGroupService().getGroup(memberId);
2774 if (group != null) {
2775 documentRoleMember.setMemberNamespaceCode(group.getNamespaceCode());
2776 documentRoleMember.setMemberId(group.getId());
2777 documentRoleMember.setMemberName(group.getName());
2778 documentRoleMember.setMemberTypeCode(MemberType.GROUP.getCode());
2779 }
2780
2781 } else if(MemberType.ROLE.equals(memberType)){
2782 Role role = getRoleService().getRole(memberId);
2783 if (role != null) {
2784 documentRoleMember.setMemberNamespaceCode(role.getNamespaceCode());
2785 documentRoleMember.setMemberId(role.getId());
2786 documentRoleMember.setMemberName(role.getName());
2787 documentRoleMember.setMemberTypeCode(MemberType.ROLE.getCode());
2788 }
2789 }
2790 return documentRoleMember;
2791 }
2792
2793 protected Set<String> getChangedRoleResponsibilityIds(
2794 IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleResponsibilityBo> origRoleResponsibilities){
2795 Set<String> lRet = new HashSet<String>();
2796 List<String> newResp = new ArrayList<String>();
2797 List<String> oldResp = new ArrayList<String>();
2798 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2799 for(KimDocumentRoleResponsibility documentRoleResponsibility: identityManagementRoleDocument.getResponsibilities()){
2800 newResp.add(documentRoleResponsibility.getResponsibilityId());
2801 }
2802 }
2803 if(ObjectUtils.isNotNull(origRoleResponsibilities)){
2804 for(RoleResponsibilityBo roleRespBo: origRoleResponsibilities){
2805 oldResp.add(roleRespBo.getResponsibilityId());
2806 }
2807 }
2808 lRet.addAll(newResp);
2809 lRet.addAll(oldResp);
2810
2811 return lRet;
2812 }
2813
2814 public KimTypeInfoService getKimTypeInfoService() {
2815 if ( kimTypeInfoService == null ) {
2816 kimTypeInfoService = KimApiServiceLocator.getKimTypeInfoService();
2817 }
2818 return kimTypeInfoService;
2819 }
2820
2821 public List<KimDocumentRoleMember> getRoleMembers(Map<String,String> fieldValues) {
2822 fieldValues.remove(KRADConstants.BACK_LOCATION);
2823 fieldValues.remove(KRADConstants.DOC_FORM_KEY);
2824 fieldValues.remove(KRADConstants.DOC_NUM);
2825 List<KimDocumentRoleMember> matchingRoleMembers = new ArrayList<KimDocumentRoleMember>();
2826 //Remove since they are KNS fieldValues and not BO
2827 fieldValues.remove(KRADConstants.BACK_LOCATION);
2828 fieldValues.remove(KRADConstants.DOC_FORM_KEY);
2829 fieldValues.remove(KRADConstants.DOC_NUM);
2830
2831 List<RoleMember> matchingRoleMembersTemp = getRoleService().findRoleMembers(toQuery(fieldValues)).getResults();
2832 KimDocumentRoleMember matchingRoleMember;
2833 BusinessObject roleMemberObject;
2834 RoleMemberBo roleMemberBo;
2835 if(CollectionUtils.isNotEmpty(matchingRoleMembersTemp)){
2836 for(RoleMember roleMember: matchingRoleMembersTemp){
2837 roleMemberBo = getRoleMember(roleMember.getId());
2838 roleMemberObject = getMember(roleMemberBo.getType(), roleMemberBo.getMemberId());
2839 matchingRoleMember = new KimDocumentRoleMember();
2840 KimCommonUtilsInternal.copyProperties(matchingRoleMember, roleMemberBo);
2841 matchingRoleMember.setMemberName(getMemberName(roleMemberBo.getType(), roleMemberObject));
2842 matchingRoleMember.setMemberNamespaceCode(getMemberNamespaceCode(roleMemberBo.getType(), roleMemberObject));
2843 matchingRoleMember.setQualifiers(getQualifiers(roleMemberBo.getAttributeDetails()));
2844 matchingRoleMembers.add(matchingRoleMember);
2845 }
2846 }
2847 return matchingRoleMembers;
2848 }
2849
2850 private QueryByCriteria toQuery(Map<String,?> fieldValues) {
2851 Set<Predicate> preds = new HashSet<Predicate>();
2852 for (String key : fieldValues.keySet()) {
2853 preds.add(equal(key, fieldValues.get(key)));
2854 }
2855 Predicate[] predicates = new Predicate[0];
2856 predicates = preds.toArray(predicates);
2857 return QueryByCriteria.Builder.fromPredicates(predicates);
2858 }
2859
2860 private List<KimDocumentRoleQualifier> getQualifiers(List<RoleMemberAttributeDataBo> attributes){
2861 if (attributes==null) {return null;}
2862 List<KimDocumentRoleQualifier> qualifiers = new ArrayList<KimDocumentRoleQualifier>();
2863 KimDocumentRoleQualifier qualifier;
2864 if(ObjectUtils.isNotNull(attributes)){
2865 for(RoleMemberAttributeDataBo attribute: attributes){
2866 qualifier = new KimDocumentRoleQualifier();
2867 qualifier.setAttrDataId(attribute.getId());
2868 qualifier.setAttrVal(attribute.getAttributeValue());
2869 qualifier.setRoleMemberId(attribute.getAssignedToId());
2870 qualifier.setKimTypId(attribute.getKimTypeId());
2871 qualifier.setKimAttrDefnId(attribute.getKimAttributeId());
2872 qualifier.setKimAttribute(attribute.getKimAttribute());
2873 qualifiers.add(qualifier);
2874 }
2875 }
2876 return qualifiers;
2877 }
2878
2879 public ResponsibilityInternalService getResponsibilityInternalService() {
2880 if ( responsibilityInternalService == null ) {
2881 responsibilityInternalService = KimImplServiceLocator.getResponsibilityInternalService();
2882 }
2883 return responsibilityInternalService;
2884 }
2885
2886 public PermissionService getPermissionService() {
2887 if ( permissionService == null ) {
2888 permissionService = KimApiServiceLocator.getPermissionService();
2889 }
2890 return permissionService;
2891 }
2892
2893 public ParameterService getParameterService() {
2894 if ( parameterService == null ) {
2895 parameterService = CoreFrameworkServiceLocator.getParameterService();
2896 }
2897 return parameterService;
2898 }
2899
2900 public void setParameterService(ParameterService parameterService) {
2901 this.parameterService = parameterService;
2902 }
2903 }