1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kim.impl.identity;
17
18 import org.apache.commons.beanutils.PropertyUtils;
19 import org.apache.commons.lang.StringUtils;
20 import org.apache.log4j.Logger;
21 import org.kuali.rice.core.api.CoreApiServiceLocator;
22 import org.kuali.rice.core.api.criteria.CountFlag;
23 import org.kuali.rice.core.api.criteria.Predicate;
24 import org.kuali.rice.core.api.criteria.PredicateUtils;
25 import org.kuali.rice.core.api.criteria.QueryByCriteria;
26 import org.kuali.rice.kim.api.identity.IdentityService;
27 import org.kuali.rice.kim.api.identity.Person;
28 import org.kuali.rice.kim.api.identity.PersonService;
29 import org.kuali.rice.kim.api.identity.entity.EntityDefault;
30 import org.kuali.rice.kim.api.identity.entity.EntityDefaultQueryResults;
31 import org.kuali.rice.kim.api.identity.external.EntityExternalIdentifierType;
32 import org.kuali.rice.kim.api.identity.principal.Principal;
33 import org.kuali.rice.kim.api.identity.type.EntityTypeContactInfoDefault;
34 import org.kuali.rice.kim.api.role.RoleService;
35 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
36 import org.kuali.rice.kim.impl.KIMPropertyConstants;
37 import org.kuali.rice.kns.service.BusinessObjectMetaDataService;
38 import org.kuali.rice.kns.service.KNSServiceLocator;
39 import org.kuali.rice.kns.service.MaintenanceDocumentDictionaryService;
40 import org.kuali.rice.krad.bo.BusinessObject;
41 import org.kuali.rice.krad.bo.DataObjectRelationship;
42 import org.kuali.rice.krad.lookup.CollectionIncomplete;
43 import org.kuali.rice.krad.util.KRADConstants;
44 import org.kuali.rice.krad.util.KRADPropertyConstants;
45 import org.kuali.rice.krad.util.ObjectUtils;
46
47 import java.security.GeneralSecurityException;
48 import java.util.ArrayList;
49 import java.util.Collection;
50 import java.util.Collections;
51 import java.util.HashMap;
52 import java.util.HashSet;
53 import java.util.Iterator;
54 import java.util.List;
55 import java.util.Map;
56 import java.util.Set;
57
58
59
60
61
62
63
64 public class PersonServiceImpl implements PersonService {
65
66 private static Logger LOG = Logger.getLogger( PersonServiceImpl.class );
67 protected static final String ENTITY_EXT_ID_PROPERTY_PREFIX = "externalIdentifiers.";
68 protected static final String ENTITY_AFFILIATION_PROPERTY_PREFIX = "affiliations.";
69 protected static final String ENTITY_TYPE_PROPERTY_PREFIX = "entityTypeContactInfos.";
70 protected static final String ENTITY_EMAIL_PROPERTY_PREFIX = "entityTypeContactInfos.emailAddresses.";
71 protected static final String ENTITY_PHONE_PROPERTY_PREFIX = "entityTypeContactInfos.phoneNumbers.";
72 protected static final String ENTITY_ADDRESS_PROPERTY_PREFIX = "entityTypeContactInfos.addresses.";
73 protected static final String ENTITY_NAME_PROPERTY_PREFIX = "names.";
74 protected static final String PRINCIPAL_PROPERTY_PREFIX = "principals.";
75 protected static final String ENTITY_EMPLOYEE_ID_PROPERTY_PREFIX = "employmentInformation.";
76
77 protected static final String EXTENSION = "extension";
78
79 private IdentityService identityService;
80 private RoleService roleService;
81 private BusinessObjectMetaDataService businessObjectMetaDataService;
82 private MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService;
83
84 protected List<String> personEntityTypeCodes = new ArrayList<String>( 4 );
85
86 private String personEntityTypeLookupCriteria = null;
87
88 protected Map<String,String> baseLookupCriteria = new HashMap<String,String>();
89 protected Map<String,String> criteriaConversion = new HashMap<String,String>();
90 protected ArrayList<String> personCachePropertyNames = new ArrayList<String>();
91 {
92
93
94 baseLookupCriteria.put( KIMPropertyConstants.Person.ACTIVE, "Y" );
95 baseLookupCriteria.put( ENTITY_TYPE_PROPERTY_PREFIX + KRADPropertyConstants.ACTIVE, "Y" );
96
97
98 criteriaConversion.put( KIMPropertyConstants.Person.ENTITY_ID, KIMPropertyConstants.Entity.ID);
99 criteriaConversion.put( KIMPropertyConstants.Person.ACTIVE, PRINCIPAL_PROPERTY_PREFIX + KRADPropertyConstants.ACTIVE );
100 criteriaConversion.put( KIMPropertyConstants.Person.PRINCIPAL_ID, PRINCIPAL_PROPERTY_PREFIX + KIMPropertyConstants.Person.PRINCIPAL_ID );
101 criteriaConversion.put( KIMPropertyConstants.Person.PRINCIPAL_NAME, PRINCIPAL_PROPERTY_PREFIX + KIMPropertyConstants.Person.PRINCIPAL_NAME );
102 criteriaConversion.put( KIMPropertyConstants.Person.FIRST_NAME, "names.firstName" );
103 criteriaConversion.put( KIMPropertyConstants.Person.LAST_NAME, "names.lastName" );
104 criteriaConversion.put( KIMPropertyConstants.Person.MIDDLE_NAME, "names.middleName" );
105 criteriaConversion.put( KIMPropertyConstants.Person.EMAIL_ADDRESS, "entityTypeContactInfos.emailAddresses.emailAddress" );
106 criteriaConversion.put( KIMPropertyConstants.Person.PHONE_NUMBER, "entityTypeContactInfos.phoneNumbers.phoneNumber" );
107 criteriaConversion.put( KIMPropertyConstants.Person.ADDRESS_LINE_1, "entityTypeContactInfos.addresses.line1" );
108 criteriaConversion.put( KIMPropertyConstants.Person.ADDRESS_LINE_2, "entityTypeContactInfos.addresses.line2" );
109 criteriaConversion.put( KIMPropertyConstants.Person.ADDRESS_LINE_3, "entityTypeContactInfos.addresses.line3" );
110 criteriaConversion.put( KIMPropertyConstants.Person.CITY, "entityTypeContactInfos.addresses.city" );
111 criteriaConversion.put( KIMPropertyConstants.Person.STATE_CODE, "entityTypeContactInfos.addresses.stateProvinceCode" );
112 criteriaConversion.put( KIMPropertyConstants.Person.POSTAL_CODE, "entityTypeContactInfos.addresses.postalCode" );
113 criteriaConversion.put( KIMPropertyConstants.Person.COUNTRY_CODE, "entityTypeContactInfos.addresses.countryCode" );
114 criteriaConversion.put( KIMPropertyConstants.Person.CAMPUS_CODE, "affiliations.campusCode" );
115 criteriaConversion.put( KIMPropertyConstants.Person.AFFILIATION_TYPE_CODE, "affiliations.affiliationTypeCode" );
116 criteriaConversion.put( KIMPropertyConstants.Person.EXTERNAL_IDENTIFIER_TYPE_CODE, "externalIdentifiers.externalIdentifierTypeCode" );
117 criteriaConversion.put( KIMPropertyConstants.Person.EXTERNAL_ID, "externalIdentifiers.externalId" );
118 criteriaConversion.put( KIMPropertyConstants.Person.EMPLOYEE_TYPE_CODE, "employmentInformation.employeeTypeCode" );
119 criteriaConversion.put( KIMPropertyConstants.Person.EMPLOYEE_STATUS_CODE, "employmentInformation.employeeStatusCode" );
120 criteriaConversion.put( KIMPropertyConstants.Person.EMPLOYEE_ID, "employmentInformation.employeeId" );
121 criteriaConversion.put( KIMPropertyConstants.Person.BASE_SALARY_AMOUNT, "employmentInformation.baseSalaryAmount" );
122 criteriaConversion.put( KIMPropertyConstants.Person.PRIMARY_DEPARTMENT_CODE, "employmentInformation.primaryDepartmentCode" );
123
124 personCachePropertyNames.add( KIMPropertyConstants.Person.PRINCIPAL_ID );
125 personCachePropertyNames.add( KIMPropertyConstants.Person.PRINCIPAL_NAME );
126 personCachePropertyNames.add( KIMPropertyConstants.Person.ENTITY_ID );
127 personCachePropertyNames.add( KIMPropertyConstants.Person.FIRST_NAME );
128 personCachePropertyNames.add( KIMPropertyConstants.Person.LAST_NAME );
129 personCachePropertyNames.add( KIMPropertyConstants.Person.MIDDLE_NAME );
130 personCachePropertyNames.add( KIMPropertyConstants.Person.CAMPUS_CODE );
131 personCachePropertyNames.add( KIMPropertyConstants.Person.EMPLOYEE_ID );
132 personCachePropertyNames.add( KIMPropertyConstants.Person.PRIMARY_DEPARTMENT_CODE );
133 }
134
135
136
137
138
139 public Person getPerson(String principalId) {
140 if ( StringUtils.isBlank(principalId) ) {
141 return null;
142 }
143
144
145 final Principal principal = getIdentityService().getPrincipal( principalId );
146
147 if ( principal != null ) {
148 final EntityDefault entity = getIdentityService().getEntityDefault(principal.getEntityId());
149
150
151 if (entity != null ) {
152 return convertEntityToPerson( entity, principal );
153 }
154 }
155 return null;
156 }
157
158 protected PersonImpl convertEntityToPerson( EntityDefault entity, Principal principal ) {
159 try {
160
161 for ( String entityTypeCode : personEntityTypeCodes ) {
162 EntityTypeContactInfoDefault entType = entity.getEntityType( entityTypeCode );
163
164 if ( entType == null ) {
165 continue;
166 }
167
168
169 return new PersonImpl( principal, entity, entityTypeCode );
170 }
171 return null;
172 } catch ( Exception ex ) {
173
174 if ( ex instanceof RuntimeException ) {
175 throw (RuntimeException)ex;
176 }
177 throw new RuntimeException( "Problem building person object", ex );
178 }
179 }
180
181
182
183
184
185 public Person getPersonByPrincipalName(String principalName) {
186 if ( StringUtils.isBlank(principalName) ) {
187 return null;
188 }
189
190
191 final Principal principal = getIdentityService().getPrincipalByPrincipalName( principalName );
192
193 if ( principal != null ) {
194 final EntityDefault entity = getIdentityService().getEntityDefault(principal.getEntityId());
195
196
197 if ( entity != null ) {
198 return convertEntityToPerson( entity, principal );
199 }
200 }
201 return null;
202 }
203
204 public Person getPersonByEmployeeId(String employeeId) {
205 if ( StringUtils.isBlank( employeeId ) ) {
206 return null;
207 }
208
209 final List<Person> people = findPeople( Collections.singletonMap(KIMPropertyConstants.Person.EMPLOYEE_ID, employeeId) );
210 if ( !people.isEmpty() ) {
211 return people.get(0);
212
213 }
214
215
216 EntityDefault entity = getIdentityService().getEntityDefaultByEmployeeId(employeeId);
217 if (entity != null) {
218 if ( !entity.getPrincipals().isEmpty() ) {
219 Principal principal = getIdentityService().getPrincipal(entity.getPrincipals().get(0).getPrincipalId());
220 if (principal != null) {
221 return convertEntityToPerson( entity, principal );
222 }
223 }
224 }
225
226 return null;
227 }
228
229
230
231
232 public List<Person> findPeople(Map<String, String> criteria) {
233 return findPeople(criteria, true);
234 }
235
236
237
238
239 public List<Person> findPeople(Map<String, String> criteria, boolean unbounded) {
240 List<Person> people = null;
241
242 if ( criteria == null ) {
243 criteria = Collections.emptyMap();
244 }
245
246 criteria = new HashMap<String, String>( criteria );
247
248
249 String roleName = criteria.get( "lookupRoleName" );
250 String namespaceCode = criteria.get( "lookupRoleNamespaceCode" );
251 criteria.remove("lookupRoleName");
252 criteria.remove("lookupRoleNamespaceCode");
253 if ( StringUtils.isNotBlank(namespaceCode) && StringUtils.isNotBlank(roleName) ) {
254 Integer searchResultsLimit = org.kuali.rice.kns.lookup.LookupUtils.getSearchResultsLimit(PersonImpl.class);
255 int searchResultsLimitInt = Integer.MAX_VALUE;
256 if (searchResultsLimit != null) {
257 searchResultsLimitInt = searchResultsLimit.intValue();
258 }
259 if ( LOG.isDebugEnabled() ) {
260 LOG.debug("Performing Person search including role filter: " + namespaceCode + "/" + roleName );
261 }
262 if ( criteria.size() == 1 && criteria.containsKey(KIMPropertyConstants.Person.ACTIVE) ) {
263 if ( LOG.isDebugEnabled() ) {
264 LOG.debug( "Only active criteria specified, running role search first" );
265 }
266
267 Collection<String> principalIds = getRoleService().getRoleMemberPrincipalIds(namespaceCode, roleName, Collections.<String, String>emptyMap());
268 StringBuffer sb = new StringBuffer(principalIds.size()*15);
269 Iterator<String> pi = principalIds.iterator();
270 while ( pi.hasNext() ) {
271 sb.append( pi.next() );
272 if ( pi.hasNext() ) sb.append( '|' );
273 }
274
275 criteria.put( KIMPropertyConstants.Person.PRINCIPAL_ID, sb.toString() );
276 people = findPeopleInternal(criteria, false);
277 } else if ( !criteria.isEmpty() ) {
278 if ( LOG.isDebugEnabled() ) {
279 LOG.debug( "Person criteria also specified, running that search first" );
280 }
281
282 people = findPeopleInternal(criteria, true);
283
284
285 List<String> principalIds = peopleToPrincipalIds( people );
286
287 principalIds = getRoleService().getPrincipalIdSubListWithRole(principalIds, namespaceCode, roleName, Collections.<String, String>emptyMap());
288
289 if ( !unbounded && principalIds.size() > searchResultsLimitInt ) {
290 int actualResultSize = principalIds.size();
291
292 principalIds = new ArrayList<String>(principalIds).subList(0, searchResultsLimitInt);
293 people = getPeople(principalIds);
294 people = new CollectionIncomplete<Person>( people.subList(0, searchResultsLimitInt), new Long(actualResultSize) );
295 } else {
296 people = getPeople(principalIds);
297 }
298 } else {
299 if ( LOG.isDebugEnabled() ) {
300 LOG.debug( "No Person criteria specified - only using role service." );
301 }
302
303 Collection<String> principalIds = getRoleService().getRoleMemberPrincipalIds(namespaceCode, roleName, Collections.<String, String>emptyMap());
304 if ( !unbounded && principalIds.size() > searchResultsLimitInt ) {
305 int actualResultSize = principalIds.size();
306
307 principalIds = new ArrayList<String>(principalIds).subList(0, searchResultsLimitInt);
308 people = getPeople(principalIds);
309 people = new CollectionIncomplete<Person>( people.subList(0, searchResultsLimitInt), new Long(actualResultSize) );
310 } else {
311 people = getPeople(principalIds);
312 }
313 }
314 } else {
315 if ( LOG.isDebugEnabled() ) {
316 LOG.debug( "No Role criteria specified, running person lookup as normal." );
317 }
318 people = findPeopleInternal(criteria, unbounded);
319 }
320
321
322
323
324
325 Set<String> peopleNoDupsSet = new HashSet<String>();
326 List<Person> peopleNoDupsList = new ArrayList<Person>();
327
328 for (Iterator<Person> iter = people.iterator(); iter.hasNext(); ) {
329 Person person = iter.next();
330 if (peopleNoDupsSet.add(person.getEntityId() + person.getPrincipalId() + person.getPrincipalName())) {
331 peopleNoDupsList.add(person);
332 }
333 }
334
335 people.clear();
336 people.addAll(peopleNoDupsList);
337
338 return people;
339 }
340
341 @SuppressWarnings("unchecked")
342 protected List<Person> findPeopleInternal(Map<String,String> criteria, boolean unbounded ) {
343
344
345
346 Map<String,String> entityCriteria = convertPersonPropertiesToEntityProperties( criteria );
347
348 Predicate predicate = PredicateUtils.convertMapToPredicate(entityCriteria);
349
350 QueryByCriteria.Builder queryBuilder = QueryByCriteria.Builder.create();
351 queryBuilder.setPredicates(predicate);
352
353 if (!unbounded) {
354 Integer searchResultsLimit = org.kuali.rice.kns.lookup.LookupUtils.getSearchResultsLimit(PersonImpl.class);
355 if (searchResultsLimit != null && searchResultsLimit >= 0) {
356 queryBuilder.setMaxResults(searchResultsLimit);
357 queryBuilder.setCountFlag(CountFlag.INCLUDE);
358 }
359 }
360
361 List<Person> people = new ArrayList<Person>();
362
363 EntityDefaultQueryResults qr = getIdentityService().findEntityDefaults( queryBuilder.build() );
364
365 if (qr.getResults().size() > 0) {
366
367 for ( EntityDefault e : qr.getResults() ) {
368
369 for ( Principal p : e.getPrincipals() ) {
370 people.add( convertEntityToPerson( e, p ) );
371 }
372 }
373 } else if (!qr.isMoreResultsAvailable() && entityCriteria.containsKey("principals.principalId")) {
374 if (!(entityCriteria.containsKey(KIMPropertyConstants.Person.ACTIVE)) || (criteria.get(KIMPropertyConstants.Person.ACTIVE).equals("N"))) {
375 String principalId = entityCriteria.get("principals.principalId");
376 try {
377 EntityDefault entityDefault = getIdentityService().getEntityDefaultByPrincipalId(principalId);
378 for ( Principal p : entityDefault.getPrincipals() ) {
379 if (!p.isActive()){
380 people.add( convertEntityToPerson(entityDefault, p ) );
381 }
382 }
383 } catch ( Exception e ) {
384 LOG.info( "A principal Id of " + principalId + " dose not exist in the system");
385 }
386 }
387 } else if (!qr.isMoreResultsAvailable() && entityCriteria.containsKey("principals.principalName")) {
388 if (!(entityCriteria.containsKey(KIMPropertyConstants.Person.ACTIVE)) || (criteria.get(KIMPropertyConstants.Person.ACTIVE).equals("N"))) {
389 String principalNm = entityCriteria.get("principals.principalName");
390 try {
391 EntityDefault entityDefault = getIdentityService().getEntityDefaultByPrincipalName(principalNm);
392 for ( Principal p : entityDefault.getPrincipals() ) {
393 if (!p.isActive()){
394 people.add( convertEntityToPerson(entityDefault, p ) );
395 }
396 }
397 } catch ( Exception e ) {
398 LOG.info( "A principal name of " + principalNm + " dose not exist in the system");
399 }
400 }
401 }
402 return people;
403 }
404
405 public Map<String,String> convertPersonPropertiesToEntityProperties( Map<String,String> criteria ) {
406 if ( LOG.isDebugEnabled() ) {
407 LOG.debug( "convertPersonPropertiesToEntityProperties: " + criteria );
408 }
409 boolean nameCriteria = false;
410 boolean addressCriteria = false;
411 boolean externalIdentifierCriteria = false;
412 boolean affiliationCriteria = false;
413 boolean affiliationDefaultOnlyCriteria = false;
414 boolean phoneCriteria = false;
415 boolean emailCriteria = false;
416 boolean employeeIdCriteria = false;
417
418 HashMap<String,String> newCriteria = new HashMap<String,String>();
419 newCriteria.putAll( baseLookupCriteria );
420
421 newCriteria.put( "entityTypeContactInfos.entityTypeCode", personEntityTypeLookupCriteria );
422
423 if ( criteria != null ) {
424 for ( String key : criteria.keySet() ) {
425
426 if(key.equals(KIMPropertyConstants.Person.ACTIVE)) {
427 newCriteria.put(criteriaConversion.get(KIMPropertyConstants.Person.ACTIVE), criteria.get(KIMPropertyConstants.Person.ACTIVE));
428 } else {
429
430 if (!(criteria.containsKey(KIMPropertyConstants.Person.ACTIVE))) {
431 newCriteria.remove( KIMPropertyConstants.Person.ACTIVE );
432 }
433 }
434
435
436 if ( StringUtils.isEmpty( criteria.get(key) ) ) {
437 continue;
438 }
439
440
441 if ( key.equals( KIMPropertyConstants.Person.EXTERNAL_ID ) && StringUtils.isNotBlank(criteria.get(key)) ) {
442
443 if ( criteria.containsKey( KIMPropertyConstants.Person.EXTERNAL_IDENTIFIER_TYPE_CODE ) ) {
444 String extIdTypeCode = criteria.get(KIMPropertyConstants.Person.EXTERNAL_IDENTIFIER_TYPE_CODE);
445 if ( StringUtils.isNotBlank(extIdTypeCode) ) {
446
447 EntityExternalIdentifierType extIdType = getIdentityService().getExternalIdentifierType(extIdTypeCode);
448
449 if ( extIdType != null && extIdType.isEncryptionRequired() ) {
450 try {
451 criteria.put(key,
452 CoreApiServiceLocator.getEncryptionService().encrypt(criteria.get(key))
453 );
454 } catch (GeneralSecurityException ex) {
455 LOG.error("Unable to encrypt value for external ID search of type " + extIdTypeCode, ex );
456 }
457 }
458 }
459 }
460 }
461
462
463 String entityProperty = criteriaConversion.get( key );
464 if ( entityProperty != null ) {
465 newCriteria.put( entityProperty, criteria.get( key ) );
466 } else {
467 entityProperty = key;
468
469 newCriteria.put( key, criteria.get( key ) );
470 }
471
472 if ( isNameEntityCriteria( entityProperty ) ) {
473 nameCriteria = true;
474 }
475 if ( isExternalIdentifierEntityCriteria( entityProperty ) ) {
476 externalIdentifierCriteria = true;
477 }
478 if ( isAffiliationEntityCriteria( entityProperty ) ) {
479 affiliationCriteria = true;
480 }
481 if ( isAddressEntityCriteria( entityProperty ) ) {
482 addressCriteria = true;
483 }
484 if ( isPhoneEntityCriteria( entityProperty ) ) {
485 phoneCriteria = true;
486 }
487 if ( isEmailEntityCriteria( entityProperty ) ) {
488 emailCriteria = true;
489 }
490 if ( isEmployeeIdEntityCriteria( entityProperty ) ) {
491 employeeIdCriteria = true;
492 }
493
494
495 if ( key.equals( "campusCode" ) ) {
496 affiliationDefaultOnlyCriteria = true;
497 }
498 }
499
500 if ( nameCriteria ) {
501 newCriteria.put( ENTITY_NAME_PROPERTY_PREFIX + "active", "Y" );
502 newCriteria.put( ENTITY_NAME_PROPERTY_PREFIX + "defaultValue", "Y" );
503
504 }
505 if ( addressCriteria ) {
506 newCriteria.put( ENTITY_ADDRESS_PROPERTY_PREFIX + "active", "Y" );
507 newCriteria.put( ENTITY_ADDRESS_PROPERTY_PREFIX + "defaultValue", "Y" );
508 }
509 if ( phoneCriteria ) {
510 newCriteria.put( ENTITY_PHONE_PROPERTY_PREFIX + "active", "Y" );
511 newCriteria.put( ENTITY_PHONE_PROPERTY_PREFIX + "defaultValue", "Y" );
512 }
513 if ( emailCriteria ) {
514 newCriteria.put( ENTITY_EMAIL_PROPERTY_PREFIX + "active", "Y" );
515 newCriteria.put( ENTITY_EMAIL_PROPERTY_PREFIX + "defaultValue", "Y" );
516 }
517 if ( employeeIdCriteria ) {
518 newCriteria.put( ENTITY_EMPLOYEE_ID_PROPERTY_PREFIX + "active", "Y" );
519 newCriteria.put( ENTITY_EMPLOYEE_ID_PROPERTY_PREFIX + "primary", "Y" );
520 }
521 if ( affiliationCriteria ) {
522 newCriteria.put( ENTITY_AFFILIATION_PROPERTY_PREFIX + "active", "Y" );
523 }
524 if ( affiliationDefaultOnlyCriteria ) {
525 newCriteria.put( ENTITY_AFFILIATION_PROPERTY_PREFIX + "defaultValue", "Y" );
526 }
527 }
528
529 if ( LOG.isDebugEnabled() ) {
530 LOG.debug( "Converted: " + newCriteria );
531 }
532 return newCriteria;
533 }
534
535 protected boolean isNameEntityCriteria( String propertyName ) {
536 return propertyName.startsWith( ENTITY_NAME_PROPERTY_PREFIX );
537 }
538 protected boolean isAddressEntityCriteria( String propertyName ) {
539 return propertyName.startsWith( ENTITY_ADDRESS_PROPERTY_PREFIX );
540 }
541 protected boolean isPhoneEntityCriteria( String propertyName ) {
542 return propertyName.startsWith( ENTITY_PHONE_PROPERTY_PREFIX );
543 }
544 protected boolean isEmailEntityCriteria( String propertyName ) {
545 return propertyName.startsWith( ENTITY_EMAIL_PROPERTY_PREFIX );
546 }
547 protected boolean isEmployeeIdEntityCriteria( String propertyName ) {
548 return propertyName.startsWith( ENTITY_EMPLOYEE_ID_PROPERTY_PREFIX );
549 }
550 protected boolean isAffiliationEntityCriteria( String propertyName ) {
551 return propertyName.startsWith( ENTITY_AFFILIATION_PROPERTY_PREFIX );
552 }
553 protected boolean isExternalIdentifierEntityCriteria( String propertyName ) {
554 return propertyName.startsWith( ENTITY_EXT_ID_PROPERTY_PREFIX );
555 }
556
557
558
559
560
561
562 public List<String> getPersonEntityTypeCodes() {
563 return this.personEntityTypeCodes;
564 }
565
566 public void setPersonEntityTypeCodes(List<String> personEntityTypeCodes) {
567 this.personEntityTypeCodes = personEntityTypeCodes;
568 personEntityTypeLookupCriteria = null;
569 for ( String entityTypeCode : personEntityTypeCodes ) {
570 if ( personEntityTypeLookupCriteria == null ) {
571 personEntityTypeLookupCriteria = entityTypeCode;
572 } else {
573 personEntityTypeLookupCriteria = personEntityTypeLookupCriteria + "|" + entityTypeCode;
574 }
575 }
576 }
577
578
579 protected List<Person> getPeople( Collection<String> principalIds ) {
580 List<Person> people = new ArrayList<Person>( principalIds.size() );
581 for ( String principalId : principalIds ) {
582 people.add( getPerson(principalId) );
583 }
584 return people;
585 }
586
587 protected List<String> peopleToPrincipalIds( List<Person> people ) {
588 List<String> principalIds = new ArrayList<String>();
589
590 for ( Person person : people ) {
591 principalIds.add( person.getPrincipalId() );
592 }
593
594 return principalIds;
595 }
596
597
598
599
600 public List<Person> getPersonByExternalIdentifier(String externalIdentifierTypeCode, String externalId) {
601 if (StringUtils.isBlank( externalIdentifierTypeCode ) || StringUtils.isBlank( externalId ) ) {
602 return null;
603 }
604 Map<String,String> criteria = new HashMap<String,String>( 2 );
605 criteria.put( KIMPropertyConstants.Person.EXTERNAL_IDENTIFIER_TYPE_CODE, externalIdentifierTypeCode );
606 criteria.put( KIMPropertyConstants.Person.EXTERNAL_ID, externalId );
607 return findPeople( criteria );
608 }
609
610
611
612
613 public Person updatePersonIfNecessary(String sourcePrincipalId, Person currentPerson ) {
614 if (currentPerson == null
615 || !StringUtils.equals(sourcePrincipalId, currentPerson.getPrincipalId() )
616 || currentPerson.getEntityId() == null ) {
617 Person person = getPerson( sourcePrincipalId );
618
619
620 if ( person == null ) {
621 if ( currentPerson != null && currentPerson.getEntityId() == null ) {
622 return currentPerson;
623 }
624 }
625
626 if ( person == null && currentPerson == null ) {
627 try {
628 return new PersonImpl();
629 } catch ( Exception ex ) {
630 LOG.error( "unable to instantiate an object of type: " + getPersonImplementationClass() + " - returning null", ex );
631 return null;
632 }
633 }
634 return person;
635 }
636
637 return currentPerson;
638 }
639
640
641
642
643
644 private Map<String,String> getNonPersonSearchCriteria( BusinessObject bo, Map<String,String> fieldValues) {
645 Map<String,String> nonUniversalUserSearchCriteria = new HashMap<String,String>();
646 for ( String propertyName : fieldValues.keySet() ) {
647 if (!isPersonProperty(bo, propertyName)) {
648 nonUniversalUserSearchCriteria.put(propertyName, fieldValues.get(propertyName));
649 }
650 }
651 return nonUniversalUserSearchCriteria;
652 }
653
654
655 private boolean isPersonProperty(BusinessObject bo, String propertyName) {
656 try {
657 if ( ObjectUtils.isNestedAttribute( propertyName )
658 && !StringUtils.contains(propertyName, "add.") ) {
659 Class<?> type = PropertyUtils.getPropertyType(bo, ObjectUtils.getNestedAttributePrefix( propertyName ));
660
661 if ( type != null ) {
662 return Person.class.isAssignableFrom(type);
663 }
664 LOG.warn( "Unable to determine type of nested property: " + bo.getClass().getName() + " / " + propertyName );
665 }
666 } catch (Exception ex) {
667 if ( LOG.isDebugEnabled() ) {
668 LOG.debug("Unable to determine if property on " + bo.getClass().getName() + " to a person object: " + propertyName, ex );
669 }
670 }
671 return false;
672 }
673
674
675
676
677 @SuppressWarnings("unchecked")
678 public Map<String,String> resolvePrincipalNamesToPrincipalIds(BusinessObject businessObject, Map<String,String> fieldValues) {
679 if ( fieldValues == null ) {
680 return null;
681 }
682 if ( businessObject == null ) {
683 return fieldValues;
684 }
685 StringBuffer resolvedPrincipalIdPropertyName = new StringBuffer();
686
687
688 Map<String,String> processedFieldValues = getNonPersonSearchCriteria(businessObject, fieldValues);
689 for ( String propertyName : fieldValues.keySet() ) {
690 if ( !StringUtils.isBlank(fieldValues.get(propertyName))
691 && isPersonProperty(businessObject, propertyName)
692 ) {
693
694 String personPropertyName = ObjectUtils.getNestedAttributePrimitive( propertyName );
695
696 if ( StringUtils.equals( KIMPropertyConstants.Person.PRINCIPAL_NAME, personPropertyName) ) {
697 Class targetBusinessObjectClass = null;
698 BusinessObject targetBusinessObject = null;
699 resolvedPrincipalIdPropertyName.setLength( 0 );
700
701
702 String personReferenceObjectPropertyName = ObjectUtils.getNestedAttributePrefix( propertyName );
703
704
705 if ( ObjectUtils.isNestedAttribute( personReferenceObjectPropertyName ) ) {
706 String targetBusinessObjectPropertyName = ObjectUtils.getNestedAttributePrefix( personReferenceObjectPropertyName );
707 targetBusinessObject = (BusinessObject)ObjectUtils.getPropertyValue( businessObject, targetBusinessObjectPropertyName );
708 if (targetBusinessObject != null) {
709 targetBusinessObjectClass = targetBusinessObject.getClass();
710 resolvedPrincipalIdPropertyName.append(targetBusinessObjectPropertyName).append(".");
711 } else {
712 LOG.error("Could not find target property '"+propertyName+"' in class "+businessObject.getClass().getName()+". Property value was null.");
713 }
714 } else {
715 targetBusinessObjectClass = businessObject.getClass();
716 targetBusinessObject = businessObject;
717 }
718
719 if (targetBusinessObjectClass != null) {
720
721
722
723 String propName = ObjectUtils.getNestedAttributePrimitive( personReferenceObjectPropertyName );
724 DataObjectRelationship rel = getBusinessObjectMetaDataService().getBusinessObjectRelationship( targetBusinessObject, propName );
725 if ( rel != null ) {
726 String sourcePrimitivePropertyName = rel.getParentAttributeForChildAttribute(KIMPropertyConstants.Person.PRINCIPAL_ID);
727 resolvedPrincipalIdPropertyName.append(sourcePrimitivePropertyName);
728
729 String principalName = fieldValues.get( propertyName );
730 Principal principal = getIdentityService().getPrincipalByPrincipalName( principalName );
731 if (principal != null ) {
732 processedFieldValues.put(resolvedPrincipalIdPropertyName.toString(), principal.getPrincipalId());
733 } else {
734 processedFieldValues.put(resolvedPrincipalIdPropertyName.toString(), null);
735 try {
736
737
738
739
740 ObjectUtils.setObjectProperty(targetBusinessObject, resolvedPrincipalIdPropertyName.toString(), null );
741 ObjectUtils.setObjectProperty(targetBusinessObject, propName, null );
742 ObjectUtils.setObjectProperty(targetBusinessObject, propName + ".principalName", principalName );
743 } catch ( Exception ex ) {
744 LOG.error( "Unable to blank out the person object after finding that the person with the given principalName does not exist.", ex );
745 }
746 }
747 } else {
748 LOG.error( "Missing relationship for " + propName + " on " + targetBusinessObjectClass.getName() );
749 }
750 } else {
751 processedFieldValues.put(resolvedPrincipalIdPropertyName.toString(), null);
752 }
753 }
754
755
756
757 } else if (propertyName.endsWith("." + KIMPropertyConstants.Person.PRINCIPAL_NAME)){
758
759 String principalName = fieldValues.get(propertyName);
760 if ( StringUtils.isNotEmpty( principalName ) ) {
761 String containerPropertyName = propertyName;
762 if (containerPropertyName.startsWith(KRADConstants.MAINTENANCE_ADD_PREFIX)) {
763 containerPropertyName = StringUtils.substringAfter( propertyName, KRADConstants.MAINTENANCE_ADD_PREFIX );
764 }
765
766
767
768 if ( ObjectUtils.isNestedAttribute( containerPropertyName ) ) {
769
770 String collectionName = StringUtils.substringBefore( containerPropertyName, "." );
771
772
773
774 Class<? extends BusinessObject> collectionBusinessObjectClass = getMaintenanceDocumentDictionaryService()
775 .getCollectionBusinessObjectClass(
776 getMaintenanceDocumentDictionaryService()
777 .getDocumentTypeName(businessObject.getClass()), collectionName);
778 if (collectionBusinessObjectClass != null) {
779
780
781 List<DataObjectRelationship> relationships =
782 getBusinessObjectMetaDataService().getBusinessObjectRelationships( collectionBusinessObjectClass );
783
784
785 for ( DataObjectRelationship rel : relationships ) {
786 String parentAttribute = rel.getParentAttributeForChildAttribute( KIMPropertyConstants.Person.PRINCIPAL_ID );
787 if ( parentAttribute == null ) {
788 continue;
789 }
790
791 processedFieldValues.remove( propertyName );
792 String fieldPrefix = StringUtils.substringBeforeLast( StringUtils.substringBeforeLast( propertyName, "." + KIMPropertyConstants.Person.PRINCIPAL_NAME ), "." );
793 String relatedPrincipalIdPropertyName = fieldPrefix + "." + parentAttribute;
794
795 if(EXTENSION.equals(StringUtils.substringAfterLast(fieldPrefix, ".")) && EXTENSION.equals(StringUtils.substringBefore(parentAttribute, ".")))
796 {
797 relatedPrincipalIdPropertyName = fieldPrefix + "." + StringUtils.substringAfter(parentAttribute, ".");
798 }
799 String currRelatedPersonPrincipalId = processedFieldValues.get(relatedPrincipalIdPropertyName);
800 if ( StringUtils.isBlank( currRelatedPersonPrincipalId ) ) {
801 Principal principal = getIdentityService().getPrincipalByPrincipalName( principalName );
802 if ( principal != null ) {
803 processedFieldValues.put(relatedPrincipalIdPropertyName, principal.getPrincipalId());
804 } else {
805 processedFieldValues.put(relatedPrincipalIdPropertyName, null);
806 }
807 }
808 }
809 } else {
810 if ( LOG.isDebugEnabled() ) {
811 LOG.debug( "Unable to determine class for collection referenced as part of property: " + containerPropertyName + " on " + businessObject.getClass().getName() );
812 }
813 }
814 } else {
815 if ( LOG.isDebugEnabled() ) {
816 LOG.debug( "Non-nested property ending with 'principalName': " + containerPropertyName + " on " + businessObject.getClass().getName() );
817 }
818 }
819 }
820 }
821 }
822 return processedFieldValues;
823 }
824
825
826
827 protected IdentityService getIdentityService() {
828 if ( identityService == null ) {
829 identityService = KimApiServiceLocator.getIdentityService();
830 }
831 return identityService;
832 }
833
834 protected RoleService getRoleService() {
835 if ( roleService == null ) {
836 roleService = KimApiServiceLocator.getRoleService();
837 }
838 return roleService;
839 }
840
841
842 public Class<? extends Person> getPersonImplementationClass() {
843 return PersonImpl.class;
844 }
845
846 protected BusinessObjectMetaDataService getBusinessObjectMetaDataService() {
847 if ( businessObjectMetaDataService == null ) {
848 businessObjectMetaDataService = KNSServiceLocator.getBusinessObjectMetaDataService();
849 }
850 return businessObjectMetaDataService;
851 }
852
853 protected MaintenanceDocumentDictionaryService getMaintenanceDocumentDictionaryService() {
854 if ( maintenanceDocumentDictionaryService == null ) {
855 maintenanceDocumentDictionaryService = KNSServiceLocator.getMaintenanceDocumentDictionaryService();
856 }
857 return maintenanceDocumentDictionaryService;
858 }
859 }