1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kim.service.impl;
17
18 import org.apache.commons.collections.CollectionUtils;
19 import org.apache.commons.lang.StringUtils;
20 import org.apache.log4j.Logger;
21 import org.joda.time.DateTime;
22 import org.kuali.rice.core.api.config.property.ConfigContext;
23 import org.kuali.rice.core.api.criteria.Predicate;
24 import org.kuali.rice.core.api.criteria.QueryByCriteria;
25 import org.kuali.rice.core.api.membership.MemberType;
26 import org.kuali.rice.core.api.parameter.Parameter;
27 import org.kuali.rice.core.api.uif.RemotableCheckboxGroup;
28 import org.kuali.rice.core.framework.parameter.ParameterService;
29 import org.kuali.rice.core.framework.services.CoreFrameworkServiceLocator;
30 import org.kuali.rice.kim.api.KimConstants;
31 import org.kuali.rice.kim.api.KimConstants.KimGroupMemberTypes;
32 import org.kuali.rice.kim.api.group.Group;
33 import org.kuali.rice.kim.api.group.GroupMember;
34 import org.kuali.rice.kim.api.group.GroupService;
35 import org.kuali.rice.kim.api.identity.IdentityService;
36 import org.kuali.rice.kim.api.identity.Person;
37 import org.kuali.rice.kim.api.identity.address.EntityAddress;
38 import org.kuali.rice.kim.api.identity.address.EntityAddressContract;
39 import org.kuali.rice.kim.api.identity.affiliation.EntityAffiliation;
40 import org.kuali.rice.kim.api.identity.email.EntityEmail;
41 import org.kuali.rice.kim.api.identity.email.EntityEmailContract;
42 import org.kuali.rice.kim.api.identity.employment.EntityEmployment;
43 import org.kuali.rice.kim.api.identity.entity.Entity;
44 import org.kuali.rice.kim.api.identity.name.EntityName;
45 import org.kuali.rice.kim.api.identity.phone.EntityPhone;
46 import org.kuali.rice.kim.api.identity.phone.EntityPhoneContract;
47 import org.kuali.rice.kim.api.identity.principal.Principal;
48 import org.kuali.rice.kim.api.identity.privacy.EntityPrivacyPreferences;
49 import org.kuali.rice.kim.api.identity.type.EntityTypeContactInfo;
50 import org.kuali.rice.kim.api.permission.PermissionService;
51 import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
52 import org.kuali.rice.kim.api.role.Role;
53 import org.kuali.rice.kim.api.role.RoleMember;
54 import org.kuali.rice.kim.api.role.RoleService;
55 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
56 import org.kuali.rice.kim.api.type.KimAttributeField;
57 import org.kuali.rice.kim.api.type.KimType;
58 import org.kuali.rice.kim.api.type.KimTypeAttribute;
59 import org.kuali.rice.kim.api.type.KimTypeInfoService;
60 import org.kuali.rice.kim.bo.ui.GroupDocumentMember;
61 import org.kuali.rice.kim.bo.ui.GroupDocumentQualifier;
62 import org.kuali.rice.kim.bo.ui.KimDocumentRoleMember;
63 import org.kuali.rice.kim.bo.ui.KimDocumentRolePermission;
64 import org.kuali.rice.kim.bo.ui.KimDocumentRoleQualifier;
65 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibility;
66 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibilityAction;
67 import org.kuali.rice.kim.bo.ui.PersonDocumentAddress;
68 import org.kuali.rice.kim.bo.ui.PersonDocumentAffiliation;
69 import org.kuali.rice.kim.bo.ui.PersonDocumentEmail;
70 import org.kuali.rice.kim.bo.ui.PersonDocumentEmploymentInfo;
71 import org.kuali.rice.kim.bo.ui.PersonDocumentGroup;
72 import org.kuali.rice.kim.bo.ui.PersonDocumentName;
73 import org.kuali.rice.kim.bo.ui.PersonDocumentPhone;
74 import org.kuali.rice.kim.bo.ui.PersonDocumentPrivacy;
75 import org.kuali.rice.kim.bo.ui.PersonDocumentRole;
76 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegation;
77 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMember;
78 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMemberQualifier;
79 import org.kuali.rice.kim.document.IdentityManagementGroupDocument;
80 import org.kuali.rice.kim.document.IdentityManagementPersonDocument;
81 import org.kuali.rice.kim.document.IdentityManagementRoleDocument;
82 import org.kuali.rice.kim.framework.services.KimFrameworkServiceLocator;
83 import org.kuali.rice.kim.framework.type.KimTypeService;
84 import org.kuali.rice.kim.impl.KIMPropertyConstants;
85 import org.kuali.rice.kim.impl.common.attribute.KimAttributeDataBo;
86 import org.kuali.rice.kim.impl.common.delegate.DelegateTypeBo;
87 import org.kuali.rice.kim.impl.common.delegate.DelegateMemberAttributeDataBo;
88 import org.kuali.rice.kim.impl.common.delegate.DelegateMemberBo;
89 import org.kuali.rice.kim.impl.group.GroupAttributeBo;
90 import org.kuali.rice.kim.impl.group.GroupBo;
91 import org.kuali.rice.kim.impl.group.GroupMemberBo;
92 import org.kuali.rice.kim.impl.identity.address.EntityAddressBo;
93 import org.kuali.rice.kim.impl.identity.address.EntityAddressTypeBo;
94 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationBo;
95 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationTypeBo;
96 import org.kuali.rice.kim.impl.identity.email.EntityEmailBo;
97 import org.kuali.rice.kim.impl.identity.email.EntityEmailTypeBo;
98 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentBo;
99 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
150
151
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
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
183
184
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
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
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
249
250 bos.addAll(groupPrincipals);
251 bos.addAll(rolePrincipals);
252 bos.addAll(roleRspActions);
253 bos.addAll(personDelegations);
254
255 getBusinessObjectService().save(bos);
256
257 if (!blankRoleMemberAttrs.isEmpty()) {
258 getBusinessObjectService().delete(blankRoleMemberAttrs);
259 }
260 if ( inactivatingPrincipal ) {
261
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
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
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.getMemberType(), roleMember.getMemberId()));
414 pndMember.setRoleMemberNamespaceCode(getMemberNamespaceCode(roleMember.getMemberType(), 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.getAttributes()));
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
465
466
467
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
480
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
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
541 role.setNewRolePrncpl(new KimDocumentRoleMember());
542 if(role.getDefinitions()!=null){
543 for (KimAttributeField key : role.getDefinitions()) {
544 KimDocumentRoleQualifier qualifier = new KimDocumentRoleQualifier();
545
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
562
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
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.memberTypeCode", 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("memberTypeCode", 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.getMemberType()) &&
675 StringUtils.equals(rolePrincipal.getMemberId(), principalId)) {
676 KimDocumentRoleMember docRolePrncpl = new KimDocumentRoleMember();
677 docRolePrncpl.setMemberId(rolePrincipal.getMemberId());
678 docRolePrncpl.setRoleMemberId(rolePrincipal.getRoleMemberId());
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
693
694
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
729
730
731
732
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
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
824 docAffiliations.add(docAffiliation);
825 docAffiliation.setEdit(true);
826
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
845
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
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
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
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
1042
1043
1044
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
1065
1066
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
1077
1078
1079
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
1136 docPhone.setEntityTypeCode(phone.getEntityTypeCode());
1137
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
1197 docEmail.setEntityTypeCode(email.getEntityTypeCode());
1198 if (email.getEmailType() != null) {
1199 docEmail.setEmailTypeCode(email.getEmailType().getCode());
1200 }
1201
1202
1203
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
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
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
1306
1307
1308
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
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.setMemberType(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
1358 roleMemberImpl.setMemberId(identityManagementPersonDocument.getPrincipalId());
1359 roleMemberImpl.setMemberType(MemberType.PRINCIPAL);
1360 roleMemberImpl.setRoleMemberId(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.getRoleMemberId()!=null && StringUtils.equals(origMember.getRoleMemberId(), 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
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
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
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
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
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.getRoleMemberId());
1654 pndMember.setRoleId(member.getRoleId());
1655 pndMember.setMemberId(member.getMemberId());
1656 pndMember.setMemberNamespaceCode(getMemberNamespaceCode(member.getMemberType(), member.getMemberId()));
1657 pndMember.setMemberName(getMemberName(member.getMemberType(), member.getMemberId()));
1658 pndMember.setMemberFullName(getMemberFullName(member.getMemberType(), member.getMemberId()));
1659 pndMember.setMemberTypeCode(member.getMemberType().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
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) {
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
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
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.getMemberType(), roleMember.getMemberId()));
1956 pndMember.setRoleMemberNamespaceCode(getMemberNamespaceCode(roleMember.getMemberType(), 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.getAttributes()));
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.ROLE_MEMBER_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
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
2055 bos.addAll(getRolePermissions(identityManagementRoleDocument, origRolePermissions));
2056 bos.addAll(getRoleResponsibilities(identityManagementRoleDocument, origRoleResponsibilities));
2057 bos.addAll(getRoleResponsibilitiesActions(identityManagementRoleDocument));
2058 String initiatorPrincipalId = getInitiatorPrincipalId(identityManagementRoleDocument);
2059 if(canAssignToRole(identityManagementRoleDocument, initiatorPrincipalId)){
2060 List<RoleMemberBo> newRoleMembersList = getRoleMembers(identityManagementRoleDocument, origRoleMembers);
2061 roleBo.setMembers(newRoleMembersList);
2062 bos.addAll(getRoleMemberResponsibilityActions(newRoleMembersList));
2063
2064 bos.addAll(getRoleDelegations(identityManagementRoleDocument, origRoleDelegations));
2065 }
2066 bos.add(roleBo);
2067 getBusinessObjectService().save(bos);
2068 KimImplServiceLocator.getResponsibilityInternalService().updateActionRequestsForResponsibilityChange(getChangedRoleResponsibilityIds(identityManagementRoleDocument, origRoleResponsibilities));
2069 if(!roleBo.isActive()){
2070
2071
2072 KimImplServiceLocator.getRoleInternalService().roleInactivated(identityManagementRoleDocument.getRoleId());
2073 }
2074 }
2075
2076 protected List<RolePermissionBo> getRolePermissions(
2077 IdentityManagementRoleDocument identityManagementRoleDocument, List<RolePermissionBo> origRolePermissions){
2078 List<RolePermissionBo> rolePermissions = new ArrayList<RolePermissionBo>();
2079 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getPermissions())){
2080 for(KimDocumentRolePermission documentRolePermission: identityManagementRoleDocument.getPermissions()){
2081 RolePermissionBo newRolePermission = new RolePermissionBo();
2082 newRolePermission.setId(documentRolePermission.getRolePermissionId());
2083 newRolePermission.setRoleId(identityManagementRoleDocument.getRoleId());
2084 newRolePermission.setPermissionId(documentRolePermission.getPermissionId());
2085 newRolePermission.setActive( documentRolePermission.isActive() );
2086
2087 newRolePermission.setActive(documentRolePermission.isActive());
2088 if (ObjectUtils.isNotNull(origRolePermissions)) {
2089 for (RolePermissionBo origPermissionImpl : origRolePermissions) {
2090 if (!StringUtils.equals(origPermissionImpl.getRoleId(), newRolePermission.getRoleId())
2091 && StringUtils.equals(origPermissionImpl.getPermissionId(), newRolePermission.getPermissionId())
2092 && origPermissionImpl.isActive()
2093 && newRolePermission.isActive()) {
2094 newRolePermission.setId(origPermissionImpl.getId());
2095 }
2096 if(origPermissionImpl.getId()!=null && StringUtils.equals(origPermissionImpl.getId(), newRolePermission.getId())){
2097 newRolePermission.setVersionNumber(origPermissionImpl.getVersionNumber());
2098 newRolePermission.setObjectId(origPermissionImpl.getObjectId());
2099 }
2100 }
2101 }
2102 rolePermissions.add(newRolePermission);
2103 }
2104 }
2105 return rolePermissions;
2106 }
2107
2108 protected List<RoleResponsibilityBo> getRoleResponsibilities(
2109 IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleResponsibilityBo> origRoleResponsibilities){
2110 List<RoleResponsibilityBo> roleResponsibilities = new ArrayList<RoleResponsibilityBo>();
2111 RoleResponsibilityBo newRoleResponsibility;
2112 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2113 for(KimDocumentRoleResponsibility documentRoleResponsibility: identityManagementRoleDocument.getResponsibilities()){
2114 newRoleResponsibility = new RoleResponsibilityBo();
2115 KimCommonUtilsInternal.copyProperties(newRoleResponsibility, documentRoleResponsibility);
2116 newRoleResponsibility.setActive(documentRoleResponsibility.isActive());
2117 newRoleResponsibility.setRoleId(identityManagementRoleDocument.getRoleId());
2118 if(ObjectUtils.isNotNull(origRoleResponsibilities)){
2119 for(RoleResponsibilityBo origResponsibilityImpl: origRoleResponsibilities){
2120 if(!StringUtils.equals(origResponsibilityImpl.getRoleId(), newRoleResponsibility.getRoleId()) &&
2121 StringUtils.equals(origResponsibilityImpl.getResponsibilityId(), newRoleResponsibility.getResponsibilityId()) &&
2122 !origResponsibilityImpl.isActive() && newRoleResponsibility.isActive()){
2123 newRoleResponsibility.setRoleResponsibilityId(origResponsibilityImpl.getRoleResponsibilityId());
2124 }
2125 if(origResponsibilityImpl.getRoleResponsibilityId()!=null && StringUtils.equals(origResponsibilityImpl.getRoleResponsibilityId(), newRoleResponsibility.getRoleResponsibilityId())) {
2126 newRoleResponsibility.setVersionNumber(origResponsibilityImpl.getVersionNumber());
2127 newRoleResponsibility.setObjectId(origResponsibilityImpl.getObjectId());
2128 }
2129 }
2130 }
2131 roleResponsibilities.add(newRoleResponsibility);
2132 }
2133 }
2134 return roleResponsibilities;
2135 }
2136
2137
2138 protected List <RoleResponsibilityActionBo> getRoleResponsibilitiesActions(
2139 IdentityManagementRoleDocument identityManagementRoleDocument){
2140 List <RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2141 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2142
2143 for(KimDocumentRoleResponsibility roleResponsibility : identityManagementRoleDocument.getResponsibilities()){
2144
2145 if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResponsibility.getResponsibilityId())){
2146 List<KimDocumentRoleResponsibilityAction> documentRoleResponsibilityActions = roleResponsibility.getRoleRspActions();
2147 if( ObjectUtils.isNotNull(documentRoleResponsibilityActions)
2148 && !documentRoleResponsibilityActions.isEmpty()
2149 && StringUtils.isNotBlank(documentRoleResponsibilityActions.get(0).getRoleResponsibilityActionId() ) ) {
2150 RoleResponsibilityActionBo roleRspAction = new RoleResponsibilityActionBo();
2151 roleRspAction.setId(documentRoleResponsibilityActions.get(0).getRoleResponsibilityActionId());
2152 roleRspAction.setActionPolicyCode(documentRoleResponsibilityActions.get(0).getActionPolicyCode());
2153 roleRspAction.setActionTypeCode(documentRoleResponsibilityActions.get(0).getActionTypeCode());
2154 roleRspAction.setPriorityNumber(documentRoleResponsibilityActions.get(0).getPriorityNumber());
2155 roleRspAction.setForceAction(documentRoleResponsibilityActions.get(0).isForceAction());
2156 roleRspAction.setRoleMemberId("*");
2157 roleRspAction.setRoleResponsibilityId(documentRoleResponsibilityActions.get(0).getRoleResponsibilityId());
2158 updateResponsibilityActionVersionNumber(roleRspAction, getRoleResponsibilityActionImpls(roleResponsibility.getRoleResponsibilityId()));
2159 roleRspActions.add(roleRspAction);
2160 }
2161 }
2162 }
2163 }
2164 return roleRspActions;
2165 }
2166
2167
2168
2169 protected void updateResponsibilityActionVersionNumber(RoleResponsibilityActionBo newRoleRspAction,
2170 List<RoleResponsibilityActionBo> origRoleRespActionImpls){
2171 if(ObjectUtils.isNotNull(origRoleRespActionImpls)){
2172 for(RoleResponsibilityActionBo origRoleResponsibilityActionImpl: origRoleRespActionImpls){
2173 if(origRoleResponsibilityActionImpl.getId()!=null && StringUtils.equals(origRoleResponsibilityActionImpl.getId(),
2174 newRoleRspAction.getId())) {
2175 newRoleRspAction.setVersionNumber(origRoleResponsibilityActionImpl.getVersionNumber());
2176 break;
2177 }
2178 }
2179 }
2180 }
2181
2182 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(List<RoleMemberBo> newRoleMembersList){
2183 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2184 if(ObjectUtils.isNotNull(newRoleMembersList)){
2185 for(RoleMemberBo roleMember: newRoleMembersList){
2186 roleRspActions.addAll(roleMember.getRoleRspActions());
2187 }
2188 }
2189 return roleRspActions;
2190 }
2191
2192 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(IdentityManagementRoleDocument identityManagementRoleDocument){
2193 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2194 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getMembers())){
2195 for(KimDocumentRoleMember roleMember: identityManagementRoleDocument.getMembers()){
2196 for(KimDocumentRoleResponsibilityAction roleRspAction : roleMember.getRoleRspActions()){
2197 RoleResponsibilityActionBo entRoleRspAction = new RoleResponsibilityActionBo();
2198 entRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
2199 entRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
2200 entRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
2201 entRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
2202 entRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
2203 entRoleRspAction.setForceAction(roleRspAction.isForceAction());
2204 entRoleRspAction.setRoleResponsibilityId(roleRspAction.getRoleResponsibilityId());
2205 List<RoleResponsibilityActionBo> actions = getRoleRspActions(roleMember.getRoleMemberId());
2206 if(ObjectUtils.isNotNull(actions)){
2207 for(RoleResponsibilityActionBo orgRspAction : actions) {
2208 if (orgRspAction.getId()!=null && StringUtils.equals(orgRspAction.getId(), roleRspAction.getRoleResponsibilityActionId())) {
2209 entRoleRspAction.setVersionNumber(orgRspAction.getVersionNumber());
2210 }
2211 }
2212 }
2213 roleRspActions.add(entRoleRspAction);
2214 }
2215 }
2216 }
2217 return roleRspActions;
2218 }
2219
2220 protected List<RoleMemberBo> getRoleMembers(IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleMemberBo> origRoleMembers){
2221 List<RoleMemberBo> roleMembers = new ArrayList<RoleMemberBo>();
2222 RoleMemberBo newRoleMember;
2223 RoleMemberBo origRoleMemberImplTemp;
2224 List<RoleMemberAttributeDataBo> origAttributes;
2225 boolean activatingInactive = false;
2226 String newRoleMemberIdAssigned = "";
2227
2228 identityManagementRoleDocument.setKimType(KimApiServiceLocator.getKimTypeInfoService().getKimType(identityManagementRoleDocument.getRoleTypeId()));
2229 KimTypeService kimTypeService = KimFrameworkServiceLocator.getKimTypeService(identityManagementRoleDocument.getKimType());
2230
2231 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getMembers())){
2232 for(KimDocumentRoleMember documentRoleMember: identityManagementRoleDocument.getMembers()){
2233 origRoleMemberImplTemp = null;
2234
2235 newRoleMember = new RoleMemberBo();
2236 KimCommonUtilsInternal.copyProperties(newRoleMember, documentRoleMember);
2237 newRoleMember.setRoleId(identityManagementRoleDocument.getRoleId());
2238 if(ObjectUtils.isNotNull(origRoleMembers)){
2239 for(RoleMemberBo origRoleMemberImpl: origRoleMembers){
2240 if((origRoleMemberImpl.getRoleId()!=null && StringUtils.equals(origRoleMemberImpl.getRoleId(), newRoleMember.getRoleId())) &&
2241 (origRoleMemberImpl.getMemberId()!=null && StringUtils.equals(origRoleMemberImpl.getMemberId(), newRoleMember.getMemberId())) &&
2242 (origRoleMemberImpl.getMemberType()!=null && org.apache.commons.lang.ObjectUtils.equals(origRoleMemberImpl.getMemberType(), newRoleMember.getMemberType())) &&
2243 !origRoleMemberImpl.isActive(new Timestamp(System.currentTimeMillis())) &&
2244 !kimTypeService.validateAttributesAgainstExisting(identityManagementRoleDocument.getKimType().getId(),
2245 documentRoleMember.getQualifierAsMap(), origRoleMemberImpl.getAttributes()).isEmpty()) {
2246
2247
2248
2249 newRoleMemberIdAssigned = newRoleMember.getRoleMemberId();
2250 newRoleMember.setRoleMemberId(origRoleMemberImpl.getRoleMemberId());
2251 activatingInactive = true;
2252 }
2253 if(origRoleMemberImpl.getRoleMemberId()!=null && StringUtils.equals(origRoleMemberImpl.getRoleMemberId(), newRoleMember.getRoleMemberId())){
2254 newRoleMember.setVersionNumber(origRoleMemberImpl.getVersionNumber());
2255 origRoleMemberImplTemp = origRoleMemberImpl;
2256 }
2257 }
2258 }
2259 origAttributes = (origRoleMemberImplTemp==null || origRoleMemberImplTemp.getAttributes()==null)?
2260 new ArrayList<RoleMemberAttributeDataBo>():origRoleMemberImplTemp.getAttributeDetails();
2261 newRoleMember.setActiveFromDateValue(documentRoleMember.getActiveFromDate());
2262 newRoleMember.setActiveToDateValue(documentRoleMember.getActiveToDate());
2263 newRoleMember.setAttributeDetails(getRoleMemberAttributeData(documentRoleMember.getQualifiers(), origAttributes, activatingInactive, newRoleMemberIdAssigned));
2264 newRoleMember.setRoleRspActions(getRoleMemberResponsibilityActions(documentRoleMember, origRoleMemberImplTemp, activatingInactive, newRoleMemberIdAssigned));
2265 roleMembers.add(newRoleMember);
2266 activatingInactive = false;
2267 }
2268 }
2269 return roleMembers;
2270 }
2271
2272 protected List<RoleResponsibilityActionBo> getRoleMemberResponsibilityActions(
2273 KimDocumentRoleMember documentRoleMember, RoleMemberBo origRoleMemberImplTemp, boolean activatingInactive, String newRoleMemberIdAssigned){
2274 List<RoleResponsibilityActionBo> roleRspActions = new ArrayList<RoleResponsibilityActionBo>();
2275 List<RoleResponsibilityActionBo> origActions = new ArrayList<RoleResponsibilityActionBo>();
2276 if(origRoleMemberImplTemp!=null) {
2277 origActions = getRoleRspActions(origRoleMemberImplTemp.getRoleMemberId());
2278 }
2279 if(CollectionUtils.isNotEmpty(documentRoleMember.getRoleRspActions())){
2280 for(KimDocumentRoleResponsibilityAction roleRspAction : documentRoleMember.getRoleRspActions()){
2281 RoleResponsibilityActionBo newRoleRspAction = new RoleResponsibilityActionBo();
2282 newRoleRspAction.setId(roleRspAction.getRoleResponsibilityActionId());
2283 newRoleRspAction.setActionPolicyCode(roleRspAction.getActionPolicyCode());
2284 newRoleRspAction.setActionTypeCode(roleRspAction.getActionTypeCode());
2285 newRoleRspAction.setPriorityNumber(roleRspAction.getPriorityNumber());
2286 newRoleRspAction.setRoleMemberId(roleRspAction.getRoleMemberId());
2287 newRoleRspAction.setForceAction(roleRspAction.isForceAction());
2288 newRoleRspAction.setRoleResponsibilityId("*");
2289 if(ObjectUtils.isNotNull(origActions)){
2290 for(RoleResponsibilityActionBo origRspAction: origActions) {
2291 if(activatingInactive && StringUtils.equals(origRspAction.getRoleResponsibilityId(), newRoleRspAction.getRoleResponsibilityId()) &&
2292 StringUtils.equals(newRoleRspAction.getRoleMemberId(), newRoleMemberIdAssigned)){
2293 newRoleRspAction.setRoleMemberId(origRspAction.getRoleMemberId());
2294 newRoleRspAction.setId(origRspAction.getId());
2295 }
2296 if (origRspAction.getId()!=null && StringUtils.equals(origRspAction.getId(), newRoleRspAction.getId())) {
2297 newRoleRspAction.setVersionNumber(origRspAction.getVersionNumber());
2298 }
2299 }
2300 }
2301 roleRspActions.add(newRoleRspAction);
2302 }
2303 }
2304 return roleRspActions;
2305 }
2306
2307 protected List<RoleMemberAttributeDataBo> getRoleMemberAttributeData(List<KimDocumentRoleQualifier> qualifiers,
2308 List<RoleMemberAttributeDataBo> origAttributes, boolean activatingInactive, String newRoleMemberIdAssigned){
2309 List<RoleMemberAttributeDataBo> roleMemberAttributeDataList = new ArrayList<RoleMemberAttributeDataBo>();
2310 RoleMemberAttributeDataBo newRoleMemberAttributeData;
2311 if(CollectionUtils.isNotEmpty(qualifiers)){
2312 for(KimDocumentRoleQualifier memberRoleQualifier: qualifiers){
2313 if(StringUtils.isNotBlank(memberRoleQualifier.getAttrVal())){
2314 newRoleMemberAttributeData = new RoleMemberAttributeDataBo();
2315 newRoleMemberAttributeData.setId(memberRoleQualifier.getAttrDataId());
2316 newRoleMemberAttributeData.setAttributeValue(memberRoleQualifier.getAttrVal());
2317 newRoleMemberAttributeData.setAssignedToId(memberRoleQualifier.getRoleMemberId());
2318 newRoleMemberAttributeData.setKimTypeId(memberRoleQualifier.getKimTypId());
2319 newRoleMemberAttributeData.setKimAttributeId(memberRoleQualifier.getKimAttrDefnId());
2320
2321 updateAttrValIfNecessary(newRoleMemberAttributeData);
2322
2323 if(ObjectUtils.isNotNull(origAttributes)){
2324 for(RoleMemberAttributeDataBo origAttribute: origAttributes){
2325 if(activatingInactive && StringUtils.equals(origAttribute.getKimAttributeId(), newRoleMemberAttributeData.getKimAttributeId()) &&
2326 StringUtils.equals(newRoleMemberAttributeData.getAssignedToId(), newRoleMemberIdAssigned)){
2327 newRoleMemberAttributeData.setAssignedToId(origAttribute.getAssignedToId());
2328 newRoleMemberAttributeData.setId(origAttribute.getId());
2329 }
2330 if(origAttribute.getId()!=null && StringUtils.equals(origAttribute.getId(), newRoleMemberAttributeData.getId())){
2331 newRoleMemberAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2332 }
2333 }
2334 }
2335 roleMemberAttributeDataList.add(newRoleMemberAttributeData);
2336 }
2337 }
2338 }
2339 return roleMemberAttributeDataList;
2340 }
2341
2342
2343
2344
2345
2346
2347
2348 protected void updateAttrValIfNecessary(RoleMemberAttributeDataBo roleMemberAttributeData) {
2349 if (doCheckboxLogic(roleMemberAttributeData.getKimTypeId(), roleMemberAttributeData.getKimAttributeId())) {
2350 convertCheckboxAttributeData(roleMemberAttributeData);
2351 }
2352 }
2353
2354 protected void formatAttrValIfNecessary(KimDocumentRoleQualifier roleQualifier) {
2355 if (doCheckboxLogic(roleQualifier.getKimTypId(), roleQualifier.getKimAttrDefnId())) {
2356 formatCheckboxAttributeData(roleQualifier);
2357 }
2358 }
2359
2360 private boolean doCheckboxLogic(String kimTypeId, String attrId) {
2361 final KimAttributeField attributeDefinition = getAttributeDefinition(kimTypeId, attrId);
2362 return attributeDefinition != null && attributeDefinition.getAttributeField().getControl() != null && attributeDefinition.getAttributeField().getControl() instanceof RemotableCheckboxGroup;
2363 }
2364
2365 protected void formatCheckboxAttributeData(KimDocumentRoleQualifier roleQualifier) {
2366 if (roleQualifier.getAttrVal().equals(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE)) {
2367 roleQualifier.setAttrVal(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE_DISPLAY);
2368 } else if (roleQualifier.getAttrVal().equals(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE)) {
2369 roleQualifier.setAttrVal(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE_DISPLAY);
2370 }
2371 }
2372
2373
2374
2375
2376
2377
2378 protected KimAttributeField getAttributeDefinition(String kimTypId, String attrDefnId) {
2379 final KimType type = getKimTypeInfoService().getKimType(kimTypId);
2380 if (type != null) {
2381 final KimTypeService typeService = (KimTypeService) KimImplServiceLocator.getBean(type.getServiceName());
2382 if (typeService != null) {
2383 final KimTypeAttribute attributeInfo = type.getAttributeDefinitionById(attrDefnId);
2384 if (attributeInfo != null) {
2385 final List<KimAttributeField> attributeMap = typeService.getAttributeDefinitions(type.getId());
2386 if (attributeMap != null) {
2387 return DataDictionaryTypeServiceHelper.findAttributeField(
2388 attributeInfo.getKimAttribute().getAttributeName(), attributeMap);
2389 }
2390 }
2391 }
2392 }
2393 return null;
2394 }
2395
2396
2397
2398
2399
2400
2401 protected void convertCheckboxAttributeData(RoleMemberAttributeDataBo roleMemberAttributeData) {
2402 if (roleMemberAttributeData.getAttributeValue().equalsIgnoreCase(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE_DISPLAY)) {
2403 roleMemberAttributeData.setAttributeValue(KimConstants.KIM_ATTRIBUTE_BOOLEAN_TRUE_STR_VALUE);
2404 } else if (roleMemberAttributeData.getAttributeValue().equalsIgnoreCase(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE_DISPLAY)) {
2405 roleMemberAttributeData.setAttributeValue(KimConstants.KIM_ATTRIBUTE_BOOLEAN_FALSE_STR_VALUE);
2406 }
2407 }
2408
2409 protected List<DelegateTypeBo> getRoleDelegations(IdentityManagementRoleDocument identityManagementRoleDocument, List<DelegateTypeBo> origDelegations){
2410 List<DelegateTypeBo> kimDelegations = new ArrayList<DelegateTypeBo>();
2411 DelegateTypeBo newKimDelegation;
2412 DelegateTypeBo origDelegationImplTemp = null;
2413 List<DelegateMemberBo> origMembers;
2414 boolean activatingInactive = false;
2415 String newDelegationIdAssigned = "";
2416 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getDelegations())){
2417 for(RoleDocumentDelegation roleDocumentDelegation: identityManagementRoleDocument.getDelegations()){
2418 newKimDelegation = new DelegateTypeBo();
2419 KimCommonUtilsInternal.copyProperties(newKimDelegation, roleDocumentDelegation);
2420 newKimDelegation.setRoleId(identityManagementRoleDocument.getRoleId());
2421 if(ObjectUtils.isNotNull(origDelegations)){
2422 for(DelegateTypeBo origDelegationImpl: origDelegations){
2423 if(StringUtils.equals(origDelegationImpl.getRoleId(), newKimDelegation.getRoleId()) &&
2424 StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId())){
2425
2426 newDelegationIdAssigned = newKimDelegation.getDelegationId();
2427 newKimDelegation.setDelegationId(origDelegationImpl.getDelegationId());
2428 activatingInactive = true;
2429 }
2430 if(origDelegationImpl.getDelegationId()!=null && StringUtils.equals(origDelegationImpl.getDelegationId(), newKimDelegation.getDelegationId())){
2431 newKimDelegation.setVersionNumber(origDelegationImpl.getVersionNumber());
2432 origDelegationImplTemp = origDelegationImpl;
2433 }
2434 }
2435 }
2436 origMembers = (origDelegationImplTemp == null || origDelegationImplTemp.getMembers()==null)?
2437 new ArrayList<DelegateMemberBo>():origDelegationImplTemp.getMembers();
2438 newKimDelegation.setMembers(getDelegationMembers(roleDocumentDelegation.getMembers(), origMembers, activatingInactive, newDelegationIdAssigned));
2439 kimDelegations.add(newKimDelegation);
2440 activatingInactive = false;
2441 }
2442 }
2443 return kimDelegations;
2444 }
2445
2446 protected List<DelegateMemberBo> getDelegationMembers(List<RoleDocumentDelegationMember> delegationMembers,
2447 List<DelegateMemberBo> origDelegationMembers, boolean activatingInactive, String newDelegationIdAssigned){
2448 List<DelegateMemberBo> delegationsMembersList = new ArrayList<DelegateMemberBo>();
2449 DelegateMemberBo newDelegationMemberImpl;
2450 DelegateMemberBo origDelegationMemberImplTemp = null;
2451 List<DelegateMemberAttributeDataBo> origAttributes;
2452 String delegationMemberId = "";
2453 if(CollectionUtils.isNotEmpty(delegationMembers)){
2454 for(RoleDocumentDelegationMember delegationMember: delegationMembers){
2455 newDelegationMemberImpl = new DelegateMemberBo();
2456 KimCommonUtilsInternal.copyProperties(newDelegationMemberImpl, delegationMember);
2457 newDelegationMemberImpl.setType(MemberType.fromCode(delegationMember.getMemberTypeCode()));
2458 if(ObjectUtils.isNotNull(origDelegationMembers)){
2459 for(DelegateMemberBo origDelegationMember: origDelegationMembers){
2460 if(activatingInactive && StringUtils.equals(origDelegationMember.getMemberId(), newDelegationMemberImpl.getMemberId()) &&
2461 StringUtils.equals(newDelegationMemberImpl.getDelegationId(), newDelegationIdAssigned) &&
2462 !origDelegationMember.isActive(new Timestamp(System.currentTimeMillis()))){
2463 newDelegationMemberImpl.setDelegationId(origDelegationMember.getDelegationId());
2464 delegationMemberId = newDelegationMemberImpl.getDelegationMemberId();
2465 newDelegationMemberImpl.setDelegationMemberId(origDelegationMember.getDelegationMemberId());
2466 }
2467 if(origDelegationMember.getDelegationMemberId()!=null && StringUtils.equals(origDelegationMember.getDelegationMemberId(), newDelegationMemberImpl.getDelegationMemberId())){
2468 newDelegationMemberImpl.setVersionNumber(origDelegationMember.getVersionNumber());
2469 origDelegationMemberImplTemp = origDelegationMember;
2470 }
2471 }
2472 }
2473 origAttributes = (origDelegationMemberImplTemp==null || origDelegationMemberImplTemp.getAttributes()==null)?
2474 new ArrayList<DelegateMemberAttributeDataBo>():origDelegationMemberImplTemp.getAttributes();
2475 newDelegationMemberImpl.setAttributes(getDelegationMemberAttributeData(delegationMember.getQualifiers(), origAttributes, activatingInactive, delegationMemberId));
2476 newDelegationMemberImpl.setActiveFromDateValue(delegationMember.getActiveFromDate());
2477 newDelegationMemberImpl.setActiveToDateValue(delegationMember.getActiveToDate());
2478 delegationsMembersList.add(newDelegationMemberImpl);
2479 }
2480 }
2481 return delegationsMembersList;
2482 }
2483
2484
2485 protected List<DelegateMemberAttributeDataBo> getDelegationMemberAttributeData(
2486 List<RoleDocumentDelegationMemberQualifier> qualifiers, List<DelegateMemberAttributeDataBo> origAttributes,
2487 boolean activatingInactive, String delegationMemberId){
2488 List<DelegateMemberAttributeDataBo> delegationMemberAttributeDataList = new ArrayList<DelegateMemberAttributeDataBo>();
2489 DelegateMemberAttributeDataBo newDelegationMemberAttributeData;
2490 if(CollectionUtils.isNotEmpty(qualifiers)){
2491 for(RoleDocumentDelegationMemberQualifier memberRoleQualifier: qualifiers){
2492 if(StringUtils.isNotBlank(memberRoleQualifier.getAttrVal())){
2493 newDelegationMemberAttributeData = new DelegateMemberAttributeDataBo();
2494 newDelegationMemberAttributeData.setId(memberRoleQualifier.getAttrDataId());
2495 newDelegationMemberAttributeData.setAttributeValue(memberRoleQualifier.getAttrVal());
2496 newDelegationMemberAttributeData.setAssignedToId(memberRoleQualifier.getDelegationMemberId());
2497 newDelegationMemberAttributeData.setKimTypeId(memberRoleQualifier.getKimTypId());
2498 newDelegationMemberAttributeData.setKimAttributeId(memberRoleQualifier.getKimAttrDefnId());
2499 if(ObjectUtils.isNotNull(origAttributes)){
2500 for(DelegateMemberAttributeDataBo origAttribute: origAttributes){
2501 if(activatingInactive && StringUtils.equals(origAttribute.getKimAttributeId(), newDelegationMemberAttributeData.getKimAttributeId()) &&
2502 StringUtils.equals(newDelegationMemberAttributeData.getAssignedToId(), delegationMemberId)){
2503 newDelegationMemberAttributeData.setAssignedToId(origAttribute.getAssignedToId());
2504 newDelegationMemberAttributeData.setId(origAttribute.getId());
2505 }
2506 if(StringUtils.equals(origAttribute.getId(), newDelegationMemberAttributeData.getId())){
2507 newDelegationMemberAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2508 }
2509 }
2510 }
2511 delegationMemberAttributeDataList.add(newDelegationMemberAttributeData);
2512 }
2513 }
2514 }
2515 return delegationMemberAttributeDataList;
2516 }
2517
2518
2519 public void loadGroupDoc(IdentityManagementGroupDocument identityManagementGroupDocument, Group groupInfo){
2520
2521
2522
2523
2524
2525 identityManagementGroupDocument.setGroupId(groupInfo.getId());
2526 KimType kimType = KimApiServiceLocator.getKimTypeInfoService().getKimType(groupInfo.getKimTypeId());
2527 identityManagementGroupDocument.setKimType(kimType);
2528 identityManagementGroupDocument.setGroupTypeName(kimType.getName());
2529 identityManagementGroupDocument.setGroupTypeId(kimType.getId());
2530 identityManagementGroupDocument.setGroupName(groupInfo.getName());
2531 identityManagementGroupDocument.setGroupDescription(groupInfo.getDescription());
2532 identityManagementGroupDocument.setActive(groupInfo.isActive());
2533 identityManagementGroupDocument.setGroupNamespace(groupInfo.getNamespaceCode());
2534
2535 List<GroupMember> members = new ArrayList(KimApiServiceLocator.getGroupService().getMembersOfGroup(groupInfo.getId()));
2536 identityManagementGroupDocument.setMembers(loadGroupMembers(identityManagementGroupDocument, members));
2537
2538
2539
2540 identityManagementGroupDocument.setQualifiers(loadGroupQualifiers(identityManagementGroupDocument, groupInfo.getAttributes()));
2541 identityManagementGroupDocument.setEditing(true);
2542 }
2543
2544 protected static class GroupMemberNameComparator implements Comparator<GroupDocumentMember> {
2545
2546
2547
2548 public int compare(GroupDocumentMember m1, GroupDocumentMember m2) {
2549 return m1.getMemberName().compareToIgnoreCase(m2.getMemberName());
2550 }
2551 }
2552
2553 protected GroupMemberNameComparator groupMemberNameComparator = new GroupMemberNameComparator();
2554
2555 protected List<GroupDocumentMember> loadGroupMembers(
2556 IdentityManagementGroupDocument identityManagementGroupDocument, List<GroupMember> members){
2557 List<GroupDocumentMember> pndMembers = new ArrayList<GroupDocumentMember>();
2558 GroupDocumentMember pndMember = new GroupDocumentMember();
2559 if(ObjectUtils.isNotNull(members)){
2560 for(GroupMember member: members){
2561 pndMember = new GroupDocumentMember();
2562
2563 pndMember.setActiveFromDate(member.getActiveFromDate() == null ? null : new Timestamp(member.getActiveFromDate().getMillis()));
2564 pndMember.setActiveToDate(member.getActiveToDate() == null ? null : new Timestamp(member.getActiveToDate().getMillis()));
2565
2566 if(pndMember.isActive()){
2567 pndMember.setGroupMemberId(member.getMemberId());
2568 pndMember.setGroupId(member.getGroupId());
2569 pndMember.setMemberId(member.getMemberId());
2570 pndMember.setMemberName(getMemberName(member.getType(), member.getMemberId()));
2571 pndMember.setMemberFullName(getMemberFullName(member.getType(), member.getMemberId()));
2572 pndMember.setMemberTypeCode(member.getType().getCode());
2573 pndMember.setEdit(true);
2574 pndMembers.add(pndMember);
2575 }
2576 }
2577 }
2578 Collections.sort(pndMembers, groupMemberNameComparator);
2579 return pndMembers;
2580 }
2581
2582 protected List<GroupDocumentQualifier> loadGroupQualifiers(IdentityManagementGroupDocument IdentityManagementGroupDocument,
2583 Map<String, String> attributes){
2584 List<GroupDocumentQualifier> pndGroupQualifiers = new ArrayList<GroupDocumentQualifier>();
2585 GroupDocumentQualifier pndGroupQualifier = new GroupDocumentQualifier();
2586 List<KimAttributeField> origAttributes = IdentityManagementGroupDocument.getDefinitions();
2587 boolean attributePresent = false;
2588 String origAttributeId;
2589 if(origAttributes!=null){
2590
2591 for(KimAttributeField key: origAttributes) {
2592 origAttributeId = IdentityManagementGroupDocument.getKimAttributeDefnId(key);
2593 if(!attributes.isEmpty()){
2594
2595 for(GroupAttributeBo groupQualifier: KimAttributeDataBo.createFrom(GroupAttributeBo.class, attributes, IdentityManagementGroupDocument.getGroupTypeId())){
2596 if(origAttributeId!=null && ObjectUtils.isNotNull(groupQualifier.getKimAttribute()) &&
2597 StringUtils.equals(origAttributeId, groupQualifier.getKimAttribute().getId())){
2598 pndGroupQualifier = new GroupDocumentQualifier();
2599 KimCommonUtilsInternal.copyProperties(pndGroupQualifier, groupQualifier);
2600 pndGroupQualifier.setAttrDataId(groupQualifier.getId());
2601 pndGroupQualifier.setAttrVal(groupQualifier.getAttributeValue());
2602 pndGroupQualifier.setKimAttrDefnId(groupQualifier.getKimAttribute().getId());
2603 pndGroupQualifier.setKimTypId(groupQualifier.getKimType().getId());
2604 pndGroupQualifier.setGroupId(groupQualifier.getAssignedToId());
2605 pndGroupQualifiers.add(pndGroupQualifier);
2606 attributePresent = true;
2607 }
2608 }
2609 }
2610 if(!attributePresent){
2611 pndGroupQualifier = new GroupDocumentQualifier();
2612 pndGroupQualifier.setKimAttrDefnId(origAttributeId);
2613 pndGroupQualifiers.add(pndGroupQualifier);
2614 }
2615 attributePresent = false;
2616 }
2617 }
2618 return pndGroupQualifiers;
2619 }
2620
2621
2622
2623
2624 @SuppressWarnings("unchecked")
2625 public void saveGroup(IdentityManagementGroupDocument identityManagementGroupDocument) {
2626 GroupBo kimGroup = new GroupBo();
2627 Map<String, String> criteria = new HashMap<String, String>();
2628 String groupId = identityManagementGroupDocument.getGroupId();
2629 criteria.put("groupId", groupId);
2630 GroupBo origGroup = (GroupBo)getBusinessObjectService().findBySinglePrimaryKey(GroupBo.class, groupId);
2631 List<GroupMemberBo> origGroupMembers = new ArrayList<GroupMemberBo>();
2632 if (ObjectUtils.isNull(origGroup)) {
2633 origGroup = new GroupBo();
2634 kimGroup.setActive(true);
2635 } else {
2636 kimGroup.setVersionNumber(origGroup.getVersionNumber());
2637
2638
2639 kimGroup.setActive(identityManagementGroupDocument.isActive());
2640 origGroupMembers = (List<GroupMemberBo>)getBusinessObjectService().findMatching(GroupMemberBo.class, criteria);
2641 }
2642
2643 kimGroup.setId(identityManagementGroupDocument.getGroupId());
2644 KimType kimType = getKimTypeInfoService().getKimType(identityManagementGroupDocument.getGroupTypeId());
2645 if( kimType == null ) {
2646 throw new RuntimeException("Kim type not found for:"+identityManagementGroupDocument.getGroupTypeId());
2647 }
2648
2649 kimGroup.setKimTypeId(kimType.getId());
2650 kimGroup.setNamespaceCode(identityManagementGroupDocument.getGroupNamespace());
2651 kimGroup.setName(identityManagementGroupDocument.getGroupName());
2652 kimGroup.setDescription(identityManagementGroupDocument.getGroupDescription());
2653 kimGroup.setAttributeDetails(getGroupAttributeData(identityManagementGroupDocument, origGroup.getAttributeDetails()));
2654
2655 List<String> oldIds;
2656 List<String> newIds;
2657 oldIds = getGroupService().getMemberPrincipalIds(kimGroup.getId());
2658
2659
2660 List<GroupMemberBo> newGroupMembersList = getGroupMembers(identityManagementGroupDocument, origGroupMembers);
2661 kimGroup.setMembers(newGroupMembersList);
2662
2663 kimGroup = (GroupBo)getBusinessObjectService().save(kimGroup);
2664
2665 newIds = kimGroup.getMemberPrincipalIds();
2666
2667
2668
2669 org.kuali.rice.kim.service.KIMServiceLocatorInternal.getGroupInternalService().updateForWorkgroupChange(kimGroup.getId(), oldIds, newIds);
2670 if(!kimGroup.isActive()){
2671
2672
2673 KimImplServiceLocator.getRoleInternalService().groupInactivated(identityManagementGroupDocument.getGroupId());
2674 }
2675
2676 }
2677
2678 protected List<GroupMemberBo> getGroupMembers(IdentityManagementGroupDocument identityManagementGroupDocument, List<GroupMemberBo> origGroupMembers){
2679 List<GroupMemberBo> groupMembers = new ArrayList<GroupMemberBo>();
2680 GroupMemberBo newGroupMember;
2681 if(CollectionUtils.isNotEmpty(identityManagementGroupDocument.getMembers())){
2682 for(GroupDocumentMember documentGroupMember: identityManagementGroupDocument.getMembers()){
2683 newGroupMember = new GroupMemberBo();
2684
2685
2686
2687 newGroupMember.setGroupId(identityManagementGroupDocument.getGroupId());
2688 newGroupMember.setActiveFromDateValue(documentGroupMember.getActiveFromDate());
2689 newGroupMember.setActiveToDateValue(documentGroupMember.getActiveToDate());
2690 newGroupMember.setMemberId(documentGroupMember.getMemberId());
2691 newGroupMember.setTypeCode(documentGroupMember.getMemberTypeCode());
2692 if(ObjectUtils.isNotNull(origGroupMembers)){
2693 for(GroupMemberBo origGroupMemberImpl: origGroupMembers){
2694 if(StringUtils.equals(origGroupMemberImpl.getGroupId(), newGroupMember.getGroupId()) &&
2695 StringUtils.equals(origGroupMemberImpl.getMemberId(), newGroupMember.getMemberId()) &&
2696 !origGroupMemberImpl.isActive(new Timestamp(System.currentTimeMillis()))){
2697
2698 newGroupMember.setMemberId(origGroupMemberImpl.getMemberId());
2699 }
2700 if(StringUtils.equals(origGroupMemberImpl.getGroupId(), newGroupMember.getGroupId()) &&
2701 StringUtils.equals(origGroupMemberImpl.getMemberId(), newGroupMember.getMemberId()) &&
2702 origGroupMemberImpl.isActive(new Timestamp(System.currentTimeMillis()))){
2703 newGroupMember.setId(origGroupMemberImpl.getId());
2704 newGroupMember.setVersionNumber(origGroupMemberImpl.getVersionNumber());
2705 }
2706 }
2707 }
2708 groupMembers.add(newGroupMember);
2709 }
2710 }
2711 return groupMembers;
2712 }
2713
2714 protected List<GroupAttributeBo> getGroupAttributeData(IdentityManagementGroupDocument identityManagementGroupDocument,
2715 List<GroupAttributeBo> origAttributes){
2716 List<GroupAttributeBo> groupAttributeDataList = new ArrayList<GroupAttributeBo>();
2717 GroupAttributeBo newGroupAttributeData;
2718 if(CollectionUtils.isNotEmpty(identityManagementGroupDocument.getQualifiers())){
2719 for(GroupDocumentQualifier groupQualifier: identityManagementGroupDocument.getQualifiers()){
2720 if(StringUtils.isNotBlank(groupQualifier.getAttrVal())){
2721 newGroupAttributeData = new GroupAttributeBo();
2722 newGroupAttributeData.setId(groupQualifier.getAttrDataId());
2723 newGroupAttributeData.setAttributeValue(groupQualifier.getAttrVal());
2724 newGroupAttributeData.setAssignedToId(groupQualifier.getGroupId());
2725 newGroupAttributeData.setKimTypeId(groupQualifier.getKimTypId());
2726 newGroupAttributeData.setKimAttributeId(groupQualifier.getKimAttrDefnId());
2727 if(ObjectUtils.isNotNull(origAttributes)){
2728 for(GroupAttributeBo origAttribute: origAttributes){
2729 if(StringUtils.equals(origAttribute.getKimAttributeId(), newGroupAttributeData.getKimAttributeId()) &&
2730 StringUtils.equals(newGroupAttributeData.getAssignedToId(), origAttribute.getAssignedToId())){
2731 newGroupAttributeData.setId(origAttribute.getId());
2732 }
2733 if(origAttribute.getId()!=null && StringUtils.equals(origAttribute.getId(), newGroupAttributeData.getId())){
2734 newGroupAttributeData.setVersionNumber(origAttribute.getVersionNumber());
2735 }
2736 }
2737 }
2738 groupAttributeDataList.add(newGroupAttributeData);
2739 }
2740 }
2741 }
2742 return groupAttributeDataList;
2743 }
2744
2745 @SuppressWarnings("unchecked")
2746 public KimDocumentRoleMember getKimDocumentRoleMember(MemberType memberType, String memberId, String roleId){
2747 if(memberType == null || StringUtils.isEmpty(memberId) || StringUtils.isEmpty(roleId)) {
2748 return null;
2749 }
2750 KimDocumentRoleMember documentRoleMember = new KimDocumentRoleMember();
2751 documentRoleMember.setRoleId(roleId);
2752 Map<String, String> criteria = new HashMap<String, String>();
2753 criteria.put("roleId", roleId);
2754 criteria.put("mbr_id", memberId);
2755
2756 List<RoleMemberBo> matchingRoleMembers = (List<RoleMemberBo>)getBusinessObjectService().findMatching(RoleMemberBo.class, criteria);
2757 if (matchingRoleMembers==null || matchingRoleMembers.size()<1) { return null; }
2758
2759 RoleMemberBo roleMemberImpl = matchingRoleMembers.get(0);
2760 documentRoleMember.setRoleMemberId(roleMemberImpl.getRoleMemberId());
2761 if(MemberType.PRINCIPAL.equals(memberType)){
2762 Principal principal = getIdentityService().getPrincipal(memberId);
2763 if (principal != null) {
2764 documentRoleMember.setMemberId(principal.getPrincipalId());
2765 documentRoleMember.setMemberName(principal.getPrincipalName());
2766 documentRoleMember.setMemberTypeCode(MemberType.PRINCIPAL.getCode());
2767 }
2768 } else if(MemberType.GROUP.equals(memberType)){
2769 Group group = getGroupService().getGroup(memberId);
2770 if (group != null) {
2771 documentRoleMember.setMemberNamespaceCode(group.getNamespaceCode());
2772 documentRoleMember.setMemberId(group.getId());
2773 documentRoleMember.setMemberName(group.getName());
2774 documentRoleMember.setMemberTypeCode(MemberType.GROUP.getCode());
2775 }
2776
2777 } else if(MemberType.ROLE.equals(memberType)){
2778 Role role = getRoleService().getRole(memberId);
2779 if (role != null) {
2780 documentRoleMember.setMemberNamespaceCode(role.getNamespaceCode());
2781 documentRoleMember.setMemberId(role.getId());
2782 documentRoleMember.setMemberName(role.getName());
2783 documentRoleMember.setMemberTypeCode(MemberType.ROLE.getCode());
2784 }
2785 }
2786 return documentRoleMember;
2787 }
2788
2789 protected Set<String> getChangedRoleResponsibilityIds(
2790 IdentityManagementRoleDocument identityManagementRoleDocument, List<RoleResponsibilityBo> origRoleResponsibilities){
2791 Set<String> lRet = new HashSet<String>();
2792 List<String> newResp = new ArrayList<String>();
2793 List<String> oldResp = new ArrayList<String>();
2794 if(CollectionUtils.isNotEmpty(identityManagementRoleDocument.getResponsibilities())){
2795 for(KimDocumentRoleResponsibility documentRoleResponsibility: identityManagementRoleDocument.getResponsibilities()){
2796 newResp.add(documentRoleResponsibility.getResponsibilityId());
2797 }
2798 }
2799 if(ObjectUtils.isNotNull(origRoleResponsibilities)){
2800 for(RoleResponsibilityBo roleRespBo: origRoleResponsibilities){
2801 oldResp.add(roleRespBo.getResponsibilityId());
2802 }
2803 }
2804 lRet.addAll(newResp);
2805 lRet.addAll(oldResp);
2806
2807 return lRet;
2808 }
2809
2810 public KimTypeInfoService getKimTypeInfoService() {
2811 if ( kimTypeInfoService == null ) {
2812 kimTypeInfoService = KimApiServiceLocator.getKimTypeInfoService();
2813 }
2814 return kimTypeInfoService;
2815 }
2816
2817 public List<KimDocumentRoleMember> getRoleMembers(Map<String,String> fieldValues) {
2818 List<KimDocumentRoleMember> matchingRoleMembers = new ArrayList<KimDocumentRoleMember>();
2819 List<RoleMember> matchingRoleMembersTemp = getRoleService().findRoleMembers(toQuery(fieldValues)).getResults();
2820 KimDocumentRoleMember matchingRoleMember;
2821 BusinessObject roleMemberObject;
2822 RoleMemberBo roleMemberBo;
2823 if(CollectionUtils.isNotEmpty(matchingRoleMembersTemp)){
2824 for(RoleMember roleMember: matchingRoleMembersTemp){
2825 roleMemberBo = getRoleMember(roleMember.getRoleMemberId());
2826 roleMemberObject = getMember(roleMemberBo.getMemberType(), roleMemberBo.getMemberId());
2827 matchingRoleMember = new KimDocumentRoleMember();
2828 KimCommonUtilsInternal.copyProperties(matchingRoleMember, roleMemberBo);
2829 matchingRoleMember.setMemberName(getMemberName(roleMemberBo.getMemberType(), roleMemberObject));
2830 matchingRoleMember.setMemberNamespaceCode(getMemberNamespaceCode(roleMemberBo.getMemberType(), roleMemberObject));
2831 matchingRoleMember.setQualifiers(getQualifiers(roleMemberBo.getAttributeDetails()));
2832 matchingRoleMembers.add(matchingRoleMember);
2833 }
2834 }
2835 return matchingRoleMembers;
2836 }
2837
2838 private QueryByCriteria toQuery(Map<String,?> fieldValues) {
2839 Set<Predicate> preds = new HashSet<Predicate>();
2840 for (String key : fieldValues.keySet()) {
2841 preds.add(equal(key, fieldValues.get(key)));
2842 }
2843 Predicate[] predicates = new Predicate[0];
2844 predicates = preds.toArray(predicates);
2845 return QueryByCriteria.Builder.fromPredicates(predicates);
2846 }
2847
2848 private List<KimDocumentRoleQualifier> getQualifiers(List<RoleMemberAttributeDataBo> attributes){
2849 if (attributes==null) {return null;}
2850 List<KimDocumentRoleQualifier> qualifiers = new ArrayList<KimDocumentRoleQualifier>();
2851 KimDocumentRoleQualifier qualifier;
2852 if(ObjectUtils.isNotNull(attributes)){
2853 for(RoleMemberAttributeDataBo attribute: attributes){
2854 qualifier = new KimDocumentRoleQualifier();
2855 qualifier.setAttrDataId(attribute.getId());
2856 qualifier.setAttrVal(attribute.getAttributeValue());
2857 qualifier.setRoleMemberId(attribute.getAssignedToId());
2858 qualifier.setKimTypId(attribute.getKimTypeId());
2859 qualifier.setKimAttrDefnId(attribute.getKimAttributeId());
2860 qualifier.setKimAttribute(attribute.getKimAttribute());
2861 qualifiers.add(qualifier);
2862 }
2863 }
2864 return qualifiers;
2865 }
2866
2867 public ResponsibilityInternalService getResponsibilityInternalService() {
2868 if ( responsibilityInternalService == null ) {
2869 responsibilityInternalService = KimImplServiceLocator.getResponsibilityInternalService();
2870 }
2871 return responsibilityInternalService;
2872 }
2873
2874 public PermissionService getPermissionService() {
2875 if ( permissionService == null ) {
2876 permissionService = KimApiServiceLocator.getPermissionService();
2877 }
2878 return permissionService;
2879 }
2880
2881 public ParameterService getParameterService() {
2882 if ( parameterService == null ) {
2883 parameterService = CoreFrameworkServiceLocator.getParameterService();
2884 }
2885 return parameterService;
2886 }
2887
2888 public void setParameterService(ParameterService parameterService) {
2889 this.parameterService = parameterService;
2890 }
2891 }