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 java.util.ArrayList;
19 import java.util.Collections;
20 import java.util.HashMap;
21 import java.util.List;
22 import java.util.Map;
23
24 import javax.jws.WebParam;
25
26 import org.apache.commons.lang.StringUtils;
27 import org.kuali.rice.core.api.criteria.QueryByCriteria;
28 import org.kuali.rice.core.api.criteria.QueryResults;
29 import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
30 import org.kuali.rice.core.api.exception.RiceIllegalStateException;
31 import org.kuali.rice.kim.api.identity.CodedAttribute;
32 import org.kuali.rice.kim.api.identity.IdentityService;
33 import org.kuali.rice.kim.api.identity.address.EntityAddress;
34 import org.kuali.rice.kim.api.identity.affiliation.EntityAffiliation;
35 import org.kuali.rice.kim.api.identity.affiliation.EntityAffiliationType;
36 import org.kuali.rice.kim.api.identity.citizenship.EntityCitizenship;
37 import org.kuali.rice.kim.api.identity.email.EntityEmail;
38 import org.kuali.rice.kim.api.identity.employment.EntityEmployment;
39 import org.kuali.rice.kim.api.identity.entity.Entity;
40 import org.kuali.rice.kim.api.identity.entity.EntityDefault;
41 import org.kuali.rice.kim.api.identity.entity.EntityDefaultQueryResults;
42 import org.kuali.rice.kim.api.identity.entity.EntityQueryResults;
43 import org.kuali.rice.kim.api.identity.external.EntityExternalIdentifier;
44 import org.kuali.rice.kim.api.identity.external.EntityExternalIdentifierType;
45 import org.kuali.rice.kim.api.identity.name.EntityName;
46 import org.kuali.rice.kim.api.identity.name.EntityNameQueryResults;
47 import org.kuali.rice.kim.api.identity.personal.EntityBioDemographics;
48 import org.kuali.rice.kim.api.identity.personal.EntityEthnicity;
49 import org.kuali.rice.kim.api.identity.phone.EntityPhone;
50 import org.kuali.rice.kim.api.identity.principal.EntityNamePrincipalName;
51 import org.kuali.rice.kim.api.identity.principal.Principal;
52 import org.kuali.rice.kim.api.identity.principal.PrincipalQueryResults;
53 import org.kuali.rice.kim.api.identity.privacy.EntityPrivacyPreferences;
54 import org.kuali.rice.kim.api.identity.residency.EntityResidency;
55 import org.kuali.rice.kim.api.identity.type.EntityTypeContactInfo;
56 import org.kuali.rice.kim.api.identity.visa.EntityVisa;
57 import org.kuali.rice.kim.impl.KIMPropertyConstants;
58 import org.kuali.rice.kim.impl.identity.address.EntityAddressBo;
59 import org.kuali.rice.kim.impl.identity.address.EntityAddressTypeBo;
60 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationBo;
61 import org.kuali.rice.kim.impl.identity.affiliation.EntityAffiliationTypeBo;
62 import org.kuali.rice.kim.impl.identity.citizenship.EntityCitizenshipBo;
63 import org.kuali.rice.kim.impl.identity.citizenship.EntityCitizenshipStatusBo;
64 import org.kuali.rice.kim.impl.identity.email.EntityEmailBo;
65 import org.kuali.rice.kim.impl.identity.email.EntityEmailTypeBo;
66 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentBo;
67 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentStatusBo;
68 import org.kuali.rice.kim.impl.identity.employment.EntityEmploymentTypeBo;
69 import org.kuali.rice.kim.impl.identity.entity.EntityBo;
70 import org.kuali.rice.kim.impl.identity.external.EntityExternalIdentifierBo;
71 import org.kuali.rice.kim.impl.identity.external.EntityExternalIdentifierTypeBo;
72 import org.kuali.rice.kim.impl.identity.name.EntityNameBo;
73 import org.kuali.rice.kim.impl.identity.name.EntityNameTypeBo;
74 import org.kuali.rice.kim.impl.identity.personal.EntityBioDemographicsBo;
75 import org.kuali.rice.kim.impl.identity.personal.EntityEthnicityBo;
76 import org.kuali.rice.kim.impl.identity.phone.EntityPhoneBo;
77 import org.kuali.rice.kim.impl.identity.phone.EntityPhoneTypeBo;
78 import org.kuali.rice.kim.impl.identity.principal.PrincipalBo;
79 import org.kuali.rice.kim.impl.identity.privacy.EntityPrivacyPreferencesBo;
80 import org.kuali.rice.kim.impl.identity.residency.EntityResidencyBo;
81 import org.kuali.rice.kim.impl.identity.type.EntityTypeContactInfoBo;
82 import org.kuali.rice.kim.impl.identity.visa.EntityVisaBo;
83 import org.kuali.rice.kim.impl.services.KimImplServiceLocator;
84 import org.kuali.rice.krad.data.DataObjectService;
85
86
87
88
89
90
91
92
93 public class IdentityServiceImpl implements IdentityService {
94
95 protected static final String UNAVAILABLE = "Unavailable";
96
97 protected DataObjectService dataObjectService;
98
99 @Override
100 public Entity getEntity(String entityId) throws RiceIllegalArgumentException {
101 incomingParamCheck(entityId, "entityId");
102
103 EntityBo entity = getEntityBo( entityId );
104 if ( entity == null ) {
105 return null;
106 }
107 return EntityBo.to( entity );
108 }
109
110 @Override
111 public Entity getEntityByPrincipalId(String principalId) throws RiceIllegalArgumentException {
112 incomingParamCheck(principalId, "principalId");
113
114 EntityBo entity = getEntityBoByPrincipalId(principalId);
115 if ( entity == null ) {
116 return null;
117 }
118 return EntityBo.to(entity);
119 }
120
121 @Override
122 public Entity getEntityByPrincipalName(String principalName) throws RiceIllegalArgumentException{
123 incomingParamCheck(principalName, "principalName");
124
125 EntityBo entity = getEntityBoByPrincipalName(principalName);
126 if ( entity == null ) {
127 return null;
128 }
129 return EntityBo.to(entity);
130 }
131
132 @Override
133 public Entity getEntityByEmployeeId(String employeeId) throws RiceIllegalArgumentException{
134 incomingParamCheck(employeeId, "employeeId");
135
136 EntityBo entity = getEntityBoByEmployeeId(employeeId);
137 if ( entity == null ) {
138 return null;
139 }
140 return EntityBo.to(entity);
141 }
142
143 @Override
144 public EntityDefault getEntityDefault(String entityId) throws RiceIllegalArgumentException {
145 incomingParamCheck(entityId, "entityId");
146
147 EntityBo entity = getEntityBo( entityId );
148 if ( entity == null ) {
149 return null;
150 }
151 return EntityBo.toDefault( entity );
152 }
153
154 @Override
155 public EntityDefault getEntityDefaultByPrincipalId(String principalId) throws RiceIllegalArgumentException {
156 incomingParamCheck(principalId, "principalId");
157
158 EntityBo entity = getEntityBoByPrincipalId(principalId);
159 if ( entity == null ) {
160 return null;
161 }
162 return EntityBo.toDefault(entity);
163 }
164
165 @Override
166 public EntityDefault getEntityDefaultByPrincipalName(String principalName) throws RiceIllegalArgumentException {
167 incomingParamCheck(principalName, "principalName");
168
169 EntityBo entity = getEntityBoByPrincipalName(principalName);
170 if ( entity == null ) {
171 return null;
172 }
173 return EntityBo.toDefault(entity);
174 }
175
176 @Override
177 public EntityDefault getEntityDefaultByEmployeeId(String employeeId) throws RiceIllegalArgumentException {
178 incomingParamCheck(employeeId, "employeeId");
179
180 EntityBo entity = getEntityBoByEmployeeId(employeeId);
181 if ( entity == null ) {
182 return null;
183 }
184 return EntityBo.toDefault(entity);
185 }
186
187 @Override
188 public Principal getPrincipalByPrincipalNameAndPassword(String principalName, String password) throws RiceIllegalArgumentException {
189 incomingParamCheck(principalName, "principalName");
190 incomingParamCheck(password, "password");
191
192 Map<String,Object> criteria = new HashMap<String,Object>(3);
193 criteria.put(KIMPropertyConstants.Principal.PRINCIPAL_NAME, principalName);
194 criteria.put(KIMPropertyConstants.Principal.PASSWORD, password);
195 criteria.put(KIMPropertyConstants.Principal.ACTIVE, Boolean.TRUE);
196 QueryResults<PrincipalBo> principals = dataObjectService.findMatching(PrincipalBo.class, QueryByCriteria.Builder.andAttributes(criteria).build());
197
198 if (!principals.getResults().isEmpty()) {
199 return PrincipalBo.to(principals.getResults().get(0));
200 }
201 return null;
202 }
203
204 @Override
205 public Principal addPrincipalToEntity(Principal principal) throws RiceIllegalArgumentException, RiceIllegalStateException {
206 incomingParamCheck(principal, "principal");
207
208 if (StringUtils.isEmpty(principal.getEntityId()) || StringUtils.isBlank(principal.getEntityId())
209 || StringUtils.isEmpty(principal.getPrincipalName()) || StringUtils.isBlank(principal.getPrincipalName())) {
210 throw new RiceIllegalStateException("Principal's entityId and PrincipalName must be populated before creation");
211 } else {
212 if (getPrincipalByPrincipalName(principal.getPrincipalName()) != null) {
213 throw new RiceIllegalStateException("the Principal to create already exists: " + principal);
214 }
215 }
216 PrincipalBo bo = PrincipalBo.from(principal);
217 return PrincipalBo.to(dataObjectService.save(bo));
218 }
219
220 @Override
221 public Principal updatePrincipal(Principal principal) throws RiceIllegalArgumentException, RiceIllegalStateException {
222 incomingParamCheck(principal, "principal");
223 PrincipalBo originalPrincipal = null;
224 if (StringUtils.isEmpty(principal.getEntityId()) || StringUtils.isBlank(principal.getEntityId())
225 || StringUtils.isEmpty(principal.getPrincipalName()) || StringUtils.isBlank(principal.getPrincipalName())) {
226 throw new RiceIllegalStateException("Principal's entityId and PrincipalName must be populated before update");
227 } else {
228 originalPrincipal = getPrincipalBoByPrincipalName(principal.getPrincipalName());
229 if (StringUtils.isEmpty(principal.getPrincipalId()) || originalPrincipal == null) {
230 throw new RiceIllegalStateException("the Principal to update does not exist: " + principal);
231 }
232 }
233
234 PrincipalBo bo = PrincipalBo.from(principal);
235
236 bo.setPassword(originalPrincipal.getPassword());
237 PrincipalBo updatedPrincipal = dataObjectService.save(bo);
238 if (originalPrincipal.isActive()
239 && !updatedPrincipal.isActive()) {
240 KimImplServiceLocator.getRoleInternalService().principalInactivated(updatedPrincipal.getPrincipalId());
241 }
242 return PrincipalBo.to(updatedPrincipal);
243 }
244
245 @Override
246 public Principal inactivatePrincipal(String principalId) throws RiceIllegalArgumentException, RiceIllegalStateException {
247 incomingParamCheck(principalId, "principalId");
248
249 Principal principal = getPrincipal(principalId);
250 if (principal == null) {
251 throw new RiceIllegalStateException("Principal with principalId: " + principalId + " does not exist");
252 }
253 PrincipalBo bo = PrincipalBo.from(principal);
254 bo.setActive(false);
255 return PrincipalBo.to(dataObjectService.save(bo));
256 }
257
258 @Override
259 public Principal inactivatePrincipalByName(String principalName) throws RiceIllegalArgumentException, RiceIllegalStateException {
260 incomingParamCheck(principalName, "principalName");
261
262 Principal principal = getPrincipalByPrincipalName(principalName);
263 if (principal == null) {
264 throw new RiceIllegalStateException("Principal with principalName: " + principalName + " does not exist");
265 }
266 PrincipalBo bo = PrincipalBo.from(principal);
267 bo.setActive(false);
268 return PrincipalBo.to(dataObjectService.save(bo));
269 }
270
271 @Override
272 public EntityTypeContactInfo addEntityTypeContactInfoToEntity(EntityTypeContactInfo entityTypeData) throws RiceIllegalArgumentException, RiceIllegalStateException {
273 incomingParamCheck(entityTypeData, "entityTypeData");
274
275 if (StringUtils.isEmpty(entityTypeData.getEntityId()) || StringUtils.isBlank(entityTypeData.getEntityId())
276 || StringUtils.isEmpty(entityTypeData.getEntityTypeCode()) || StringUtils.isBlank(entityTypeData.getEntityTypeCode())) {
277 throw new RiceIllegalStateException("EntityTypeData's entityId and entityTypeCode must be populated before creation");
278 } else {
279 if (getEntityTypeDataBo(entityTypeData.getEntityId(), entityTypeData.getEntityTypeCode()) != null) {
280 throw new RiceIllegalStateException("the entityTypeData to create already exists: " + entityTypeData);
281 }
282 }
283 EntityTypeContactInfoBo bo = EntityTypeContactInfoBo.from(entityTypeData);
284 return EntityTypeContactInfoBo.to(dataObjectService.save(bo));
285 }
286
287 protected EntityTypeContactInfoBo getEntityTypeDataBo(String entityId, String entityTypeCode) {
288 Map<String,Object> criteria = new HashMap<String,Object>(3);
289 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
290 criteria.put(KIMPropertyConstants.Entity.ENTITY_TYPE_CODE, entityTypeCode);
291 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
292 List<EntityTypeContactInfoBo> results = dataObjectService.findMatching(EntityTypeContactInfoBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
293 if ( results.isEmpty() ) {
294 return null;
295 }
296 return results.get(0);
297 }
298
299 @Override
300 public EntityTypeContactInfo updateEntityTypeContactInfo(EntityTypeContactInfo entityTypeContactInfo) throws RiceIllegalArgumentException, RiceIllegalStateException {
301 incomingParamCheck(entityTypeContactInfo, "entityTypeContactInfo");
302
303 if (StringUtils.isBlank(entityTypeContactInfo.getEntityId()) || StringUtils.isEmpty(entityTypeContactInfo.getEntityId())
304 || StringUtils.isBlank(entityTypeContactInfo.getEntityTypeCode()) || StringUtils.isEmpty(entityTypeContactInfo.getEntityTypeCode())) {
305 throw new RiceIllegalStateException("EntityTypeData's entityId and entityTypeCode must be populated before update");
306 } else {
307 if (getEntityTypeDataBo(entityTypeContactInfo.getEntityId(), entityTypeContactInfo.getEntityTypeCode()) == null) {
308 throw new RiceIllegalStateException("the entityTypeData to update does not exist: " + entityTypeContactInfo);
309 }
310 }
311 EntityTypeContactInfoBo bo = EntityTypeContactInfoBo.from(entityTypeContactInfo);
312 return EntityTypeContactInfoBo.to(dataObjectService.save(bo));
313 }
314
315 @Override
316 public EntityTypeContactInfo inactivateEntityTypeContactInfo(String entityId, String entityTypeCode) throws RiceIllegalArgumentException, RiceIllegalStateException {
317 incomingParamCheck(entityId, "entityId");
318 incomingParamCheck(entityTypeCode, "entityTypeCode");
319
320 EntityTypeContactInfoBo bo = getEntityTypeDataBo(entityId, entityTypeCode);
321 if (bo == null) {
322 throw new RiceIllegalStateException("EntityTypeData with entityId: " + entityId + " entityTypeCode: " + entityTypeCode + " does not exist");
323 }
324 bo.setActive(false);
325 return EntityTypeContactInfoBo.to(dataObjectService.save(bo));
326 }
327
328 protected EntityAddressBo getEntityAddressBo(String entityId, String entityTypeCode, String addressTypeCode) {
329 Map<String,Object> criteria = new HashMap<String,Object>(4);
330 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
331 criteria.put(KIMPropertyConstants.Entity.ENTITY_TYPE_CODE, entityTypeCode);
332 criteria.put("addressTypeCode", addressTypeCode);
333 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
334 List<EntityAddressBo> results = dataObjectService.findMatching(EntityAddressBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
335 if ( results.isEmpty() ) {
336 return null;
337 }
338 return results.get(0);
339 }
340
341 protected EntityAddressBo getEntityAddressBo(String addressId) {
342 return dataObjectService.find(EntityAddressBo.class, addressId);
343 }
344
345 @Override
346 public EntityAddress addAddressToEntity(EntityAddress address) throws RiceIllegalArgumentException, RiceIllegalStateException {
347 incomingParamCheck(address, "address");
348
349 if (StringUtils.isEmpty(address.getEntityId()) || StringUtils.isBlank(address.getEntityId())
350 || StringUtils.isEmpty(address.getEntityTypeCode()) || StringUtils.isBlank(address.getEntityTypeCode())) {
351 throw new RiceIllegalStateException("Address's entityId and entityTypeCode must be populated before creation");
352 } else {
353 if (address.getAddressType() == null) {
354 throw new RiceIllegalStateException("Address's type must be populated before creation");
355 }
356 if (getEntityAddressBo(address.getEntityId(), address.getEntityTypeCode(), address.getAddressType().getCode()) != null) {
357 throw new RiceIllegalStateException("the address to create already exists: " + address);
358 }
359 }
360 EntityAddressBo bo = EntityAddressBo.from(address);
361 return EntityAddressBo.to(dataObjectService.save(bo));
362 }
363
364 @Override
365 public EntityAddress updateAddress(EntityAddress address) throws RiceIllegalArgumentException, RiceIllegalStateException {
366 incomingParamCheck(address, "address");
367
368 if (StringUtils.isEmpty(address.getEntityId()) || StringUtils.isBlank(address.getEntityId())
369 || StringUtils.isEmpty(address.getEntityTypeCode()) || StringUtils.isBlank(address.getEntityTypeCode())) {
370 throw new RiceIllegalStateException("Address's entityId and entityTypeCode must be populated before creation");
371 } else {
372 if (address.getAddressType() == null) {
373 throw new RiceIllegalStateException("Address's type must be populated before creation");
374 }
375 if (StringUtils.isEmpty(address.getId())
376 || getEntityAddressBo(address.getEntityId(), address.getEntityTypeCode(), address.getAddressType().getCode()) == null) {
377 throw new RiceIllegalStateException("the address to update does not exists: " + address);
378 }
379 }
380 EntityAddressBo bo = EntityAddressBo.from(address);
381 return EntityAddressBo.to(dataObjectService.save(bo));
382 }
383
384 @Override
385 public EntityAddress inactivateAddress(String addressId) throws RiceIllegalArgumentException, RiceIllegalStateException {
386 incomingParamCheck(addressId, "addressId");
387
388 EntityAddressBo bo = getEntityAddressBo(addressId);
389 if (bo == null) {
390 throw new RiceIllegalStateException("Address with addressId: " + addressId + " does not exist");
391 }
392 bo.setActive(false);
393 return EntityAddressBo.to(dataObjectService.save(bo));
394 }
395
396 protected EntityEmailBo getEntityEmailBo(String entityId, String entityTypeCode, String emailTypeCode) {
397 Map<String,Object> criteria = new HashMap<String,Object>(4);
398 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
399 criteria.put(KIMPropertyConstants.Entity.ENTITY_TYPE_CODE, entityTypeCode);
400 criteria.put("emailTypeCode", emailTypeCode);
401 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
402 List<EntityEmailBo> results = dataObjectService.findMatching(EntityEmailBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
403 if ( results.isEmpty() ) {
404 return null;
405 }
406 return results.get(0);
407 }
408
409 protected EntityEmailBo getEntityEmailBo(String emailId) {
410 return dataObjectService.find(EntityEmailBo.class, emailId);
411 }
412 @Override
413 public EntityEmail addEmailToEntity(EntityEmail email) throws RiceIllegalArgumentException, RiceIllegalStateException {
414 incomingParamCheck(email, "email");
415
416 if (StringUtils.isEmpty(email.getEntityId()) || StringUtils.isBlank(email.getEntityId())
417 || StringUtils.isEmpty(email.getEntityTypeCode()) || StringUtils.isBlank(email.getEntityTypeCode())) {
418 throw new RiceIllegalStateException("Email's entityId and entityTypeCode must be populated before creation");
419 } else {
420 if (email.getEmailType() == null) {
421 throw new RiceIllegalStateException("Email's type must be populated before creation");
422 }
423 if (getEntityEmailBo(email.getEntityId(), email.getEntityTypeCode(), email.getEmailType().getCode()) != null) {
424 throw new RiceIllegalStateException("the email to create already exists: " + email);
425 }
426 }
427 EntityEmailBo bo = EntityEmailBo.from(email);
428 return EntityEmailBo.to(dataObjectService.save(bo));
429 }
430
431 @Override
432 public EntityEmail updateEmail(EntityEmail email) throws RiceIllegalArgumentException, RiceIllegalStateException {
433 incomingParamCheck(email, "email");
434
435 if (StringUtils.isEmpty(email.getEntityId()) || StringUtils.isBlank(email.getEntityId())
436 || StringUtils.isEmpty(email.getEntityTypeCode()) || StringUtils.isBlank(email.getEntityTypeCode())) {
437 throw new RiceIllegalStateException("Email's entityId and entityTypeCode must be populated before creation");
438 } else {
439 if (email.getEmailType() == null) {
440 throw new RiceIllegalStateException("Email's type must be populated before creation");
441 }
442 if (StringUtils.isEmpty(email.getId())
443 || getEntityEmailBo(email.getEntityId(), email.getEntityTypeCode(), email.getEmailType().getCode()) == null) {
444 throw new RiceIllegalStateException("the email to update does not exists: " + email);
445 }
446 }
447 EntityEmailBo bo = EntityEmailBo.from(email);
448 return EntityEmailBo.to(dataObjectService.save(bo));
449 }
450
451 @Override
452 public EntityEmail inactivateEmail(String emailId) throws RiceIllegalArgumentException, RiceIllegalStateException {
453 incomingParamCheck(emailId, "emailId");
454
455 EntityEmailBo bo = getEntityEmailBo(emailId);
456 if (bo == null) {
457 throw new RiceIllegalStateException("Email with emailId: " + emailId + " does not exist");
458 }
459 bo.setActive(false);
460 return EntityEmailBo.to(dataObjectService.save(bo));
461 }
462
463 protected EntityPhoneBo getEntityPhoneBo(String entityId, String entityTypeCode, String phoneTypeCode) {
464 Map<String,Object> criteria = new HashMap<String,Object>(4);
465 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
466 criteria.put(KIMPropertyConstants.Entity.ENTITY_TYPE_CODE, entityTypeCode);
467 criteria.put("phoneTypeCode", phoneTypeCode);
468 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
469 List<EntityPhoneBo> results = dataObjectService.findMatching(EntityPhoneBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
470 if ( results.isEmpty() ) {
471 return null;
472 }
473 return results.get(0);
474 }
475
476 protected EntityPhoneBo getEntityPhoneBo(String phoneId) {
477 return dataObjectService.find(EntityPhoneBo.class, phoneId);
478 }
479
480 @Override
481 public EntityPhone addPhoneToEntity(EntityPhone phone) throws RiceIllegalArgumentException, RiceIllegalStateException {
482 incomingParamCheck(phone, "phone");
483
484 if (StringUtils.isEmpty(phone.getEntityId()) || StringUtils.isBlank(phone.getEntityId())
485 || StringUtils.isEmpty(phone.getEntityTypeCode()) || StringUtils.isBlank(phone.getEntityTypeCode())) {
486 throw new RiceIllegalStateException("Phone's entityId and entityTypeCode must be populated before creation");
487 } else {
488 if (phone.getPhoneType() == null) {
489 throw new RiceIllegalStateException("Phone's type must be populated before creation");
490 }
491 if (getEntityPhoneBo(phone.getEntityId(), phone.getEntityTypeCode(), phone.getPhoneType().getCode()) != null) {
492 throw new RiceIllegalStateException("the phone to create already exists: " + phone);
493 }
494 }
495 EntityPhoneBo bo = EntityPhoneBo.from(phone);
496 return EntityPhoneBo.to(dataObjectService.save(bo));
497 }
498
499 @Override
500 public EntityPhone updatePhone(EntityPhone phone) throws RiceIllegalArgumentException, RiceIllegalStateException {
501 incomingParamCheck(phone, "phone");
502
503 if (StringUtils.isEmpty(phone.getEntityId()) || StringUtils.isBlank(phone.getEntityId())
504 || StringUtils.isEmpty(phone.getEntityTypeCode()) || StringUtils.isBlank(phone.getEntityTypeCode())) {
505 throw new RiceIllegalStateException("Phone's entityId and entityTypeCode must be populated before creation");
506 } else {
507 if (phone.getPhoneType() == null) {
508 throw new RiceIllegalStateException("Phone's type must be populated before creation");
509 }
510 if (StringUtils.isEmpty(phone.getId())
511 || getEntityPhoneBo(phone.getEntityId(), phone.getEntityTypeCode(), phone.getPhoneType().getCode()) == null) {
512 throw new RiceIllegalStateException("the phone to update does not exists: " + phone);
513 }
514 }
515 EntityPhoneBo bo = EntityPhoneBo.from(phone);
516 return EntityPhoneBo.to(dataObjectService.save(bo));
517 }
518
519 @Override
520 public EntityPhone inactivatePhone(String phoneId) throws RiceIllegalArgumentException, RiceIllegalStateException {
521 incomingParamCheck(phoneId, "phoneId");
522
523 EntityPhoneBo bo = getEntityPhoneBo(phoneId);
524 if (bo == null) {
525 throw new RiceIllegalStateException("Phone with phoneId: " + phoneId + " does not exist");
526 }
527 bo.setActive(false);
528 return EntityPhoneBo.to(dataObjectService.save(bo));
529 }
530
531
532 protected EntityExternalIdentifierBo getEntityExternalIdentifierBo(String entityId, String externalIdentifierTypeCode) {
533 Map<String,Object> criteria = new HashMap<String,Object>(4);
534 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
535 criteria.put("externalIdentifierTypeCode", externalIdentifierTypeCode);
536 List<EntityExternalIdentifierBo> results = dataObjectService.findMatching(EntityExternalIdentifierBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
537 if ( results.isEmpty() ) {
538 return null;
539 }
540 return results.get(0);
541 }
542
543 @Override
544 public EntityExternalIdentifier addExternalIdentifierToEntity(EntityExternalIdentifier externalId) throws RiceIllegalArgumentException, RiceIllegalStateException {
545 incomingParamCheck(externalId, "externalId");
546
547 if (StringUtils.isEmpty(externalId.getEntityId()) || StringUtils.isBlank(externalId.getEntityId())
548 || StringUtils.isEmpty(externalId.getExternalIdentifierTypeCode()) || StringUtils.isBlank(externalId.getExternalIdentifierTypeCode())) {
549 throw new RiceIllegalStateException("EntityExternalIdentifier's entityId and entityTypeCode must be populated before creation");
550 } else {
551 if (getEntityExternalIdentifierBo(externalId.getEntityId(), externalId.getExternalIdentifierTypeCode()) != null) {
552 throw new RiceIllegalStateException("the EntityExternalIdentifier to create already exists: " + externalId);
553 }
554 }
555 EntityExternalIdentifierBo bo = EntityExternalIdentifierBo.from(externalId);
556 return EntityExternalIdentifierBo.to(dataObjectService.save(bo));
557 }
558
559 @Override
560 public EntityExternalIdentifier updateExternalIdentifier(EntityExternalIdentifier externalId) throws RiceIllegalArgumentException, RiceIllegalStateException {
561 incomingParamCheck(externalId, "externalId");
562
563 if (StringUtils.isEmpty(externalId.getEntityId()) || StringUtils.isBlank(externalId.getEntityId())
564 || StringUtils.isEmpty(externalId.getExternalIdentifierTypeCode()) || StringUtils.isBlank(externalId.getExternalIdentifierTypeCode())) {
565 throw new RiceIllegalStateException("EntityExternalIdentifier's entityId and externalIdentifierTypeCode must be populated before creation");
566 } else {
567 if (StringUtils.isEmpty(externalId.getId())
568 || getEntityExternalIdentifierBo(externalId.getEntityId(), externalId.getExternalIdentifierTypeCode()) == null) {
569 throw new RiceIllegalStateException("the external identifier to update does not exist: " + externalId);
570 }
571 }
572 EntityExternalIdentifierBo bo = EntityExternalIdentifierBo.from(externalId);
573 return EntityExternalIdentifierBo.to(dataObjectService.save(bo));
574 }
575
576
577 protected EntityAffiliationBo getEntityAffiliationBo(String id) {
578 return dataObjectService.find(EntityAffiliationBo.class, id);
579 }
580
581 @Override
582 public EntityAffiliation addAffiliationToEntity(EntityAffiliation affiliation) throws RiceIllegalArgumentException, RiceIllegalStateException {
583 incomingParamCheck(affiliation, "affiliation");
584
585 if (StringUtils.isEmpty(affiliation.getEntityId()) || StringUtils.isBlank(affiliation.getEntityId())) {
586 throw new RiceIllegalStateException("Affiliation's entityId must be populated before creation");
587 } else {
588 if (affiliation.getAffiliationType() == null) {
589 throw new RiceIllegalStateException("EntityAffiliation's type must be populated before creation");
590 }
591 if (getEntityAffiliationBo(affiliation.getId()) != null) {
592 throw new RiceIllegalStateException("the EntityAffiliation to create already exists: " + affiliation);
593 }
594 }
595 EntityAffiliationBo bo = EntityAffiliationBo.from(affiliation);
596 return EntityAffiliationBo.to(dataObjectService.save(bo));
597 }
598
599 @Override
600 public EntityAffiliation updateAffiliation(EntityAffiliation affiliation) throws RiceIllegalArgumentException, RiceIllegalStateException {
601 incomingParamCheck(affiliation, "affiliation");
602
603 if (StringUtils.isEmpty(affiliation.getEntityId()) || StringUtils.isBlank(affiliation.getEntityId())) {
604 throw new RiceIllegalStateException("Affiliation's entityId must be populated before creation");
605 } else {
606 if (affiliation.getAffiliationType() == null) {
607 throw new RiceIllegalStateException("EntityAffiliation's type must be populated before creation");
608 }
609 if (StringUtils.isEmpty(affiliation.getId())
610 || getEntityAffiliationBo(affiliation.getId()) == null) {
611 throw new RiceIllegalStateException("the EntityAffiliation to update already exists: " + affiliation);
612 }
613 }
614 EntityAffiliationBo bo = EntityAffiliationBo.from(affiliation);
615 return EntityAffiliationBo.to(dataObjectService.save(bo));
616 }
617
618 @Override
619 public EntityAffiliation inactivateAffiliation(String id) throws RiceIllegalArgumentException, RiceIllegalStateException {
620 incomingParamCheck(id, "id");
621
622 EntityAffiliationBo bo = getEntityAffiliationBo(id);
623 if (bo == null) {
624 throw new RiceIllegalStateException("EntityAffiliation with id: " + id + " does not exist");
625 }
626 bo.setActive(false);
627 return EntityAffiliationBo.to(dataObjectService.save(bo));
628 }
629
630 @Override
631 public EntityQueryResults findEntities(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
632 incomingParamCheck(queryByCriteria, "queryByCriteria");
633
634 QueryResults<EntityBo> results = dataObjectService.findMatching(EntityBo.class, queryByCriteria);
635
636 EntityQueryResults.Builder builder = EntityQueryResults.Builder.create();
637 builder.setMoreResultsAvailable(results.isMoreResultsAvailable());
638 builder.setTotalRowCount(results.getTotalRowCount());
639
640 final List<Entity.Builder> ims = new ArrayList<Entity.Builder>();
641 for (EntityBo bo : results.getResults()) {
642 ims.add(Entity.Builder.create(bo));
643 }
644
645 builder.setResults(ims);
646 return builder.build();
647 }
648
649 @Override
650 public EntityDefaultQueryResults findEntityDefaults(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
651 incomingParamCheck(queryByCriteria, "queryByCriteria");
652
653 QueryResults<EntityBo> results = dataObjectService.findMatching(EntityBo.class, queryByCriteria);
654
655 EntityDefaultQueryResults.Builder builder = EntityDefaultQueryResults.Builder.create();
656 builder.setMoreResultsAvailable(results.isMoreResultsAvailable());
657 builder.setTotalRowCount(results.getTotalRowCount());
658
659 final List<EntityDefault.Builder> ims = new ArrayList<EntityDefault.Builder>();
660 for (EntityBo bo : results.getResults()) {
661 ims.add(EntityDefault.Builder.create(bo));
662 }
663
664 builder.setResults(ims);
665 return builder.build();
666 }
667
668 protected EntityNameQueryResults findNames(QueryByCriteria queryByCriteria) {
669 incomingParamCheck(queryByCriteria, "queryByCriteria");
670
671 QueryResults<EntityNameBo> results = dataObjectService.findMatching(EntityNameBo.class, queryByCriteria);
672
673 EntityNameQueryResults.Builder builder = EntityNameQueryResults.Builder.create();
674 builder.setMoreResultsAvailable(results.isMoreResultsAvailable());
675 builder.setTotalRowCount(results.getTotalRowCount());
676
677 final List<EntityName.Builder> ims = new ArrayList<EntityName.Builder>();
678 for (EntityNameBo bo : results.getResults()) {
679 ims.add(EntityName.Builder.create(bo));
680 }
681
682 builder.setResults(ims);
683 return builder.build();
684 }
685
686 @Override
687 public EntityPrivacyPreferences getEntityPrivacyPreferences(String entityId) throws RiceIllegalArgumentException {
688 incomingParamCheck(entityId, "entityId");
689 return EntityPrivacyPreferencesBo.to(dataObjectService.find(EntityPrivacyPreferencesBo.class, entityId));
690 }
691
692 @Override
693 public Principal getPrincipal(String principalId) throws RiceIllegalArgumentException {
694 incomingParamCheck(principalId, "principalId");
695
696 PrincipalBo principal = getPrincipalBo(principalId);
697 if ( principal == null ) {
698 return null;
699 }
700 if (StringUtils.isBlank(principal.getPrincipalName())) {
701 principal.setPrincipalName(UNAVAILABLE);
702 }
703 return PrincipalBo.to(principal);
704 }
705
706 @Override
707 public List<Principal> getPrincipals (List<String> principalIds) {
708 List<Principal> ret = new ArrayList<Principal>();
709 for(String p: principalIds) {
710 Principal principalInfo = getPrincipal(p);
711
712 if (principalInfo != null) {
713 ret.add(principalInfo) ;
714 }
715 }
716 return ret;
717 }
718
719 protected PrincipalBo getPrincipalBo(String principalId) {
720 return dataObjectService.find(PrincipalBo.class, principalId);
721 }
722
723 protected EntityBo getEntityBo(String entityId) {
724 return dataObjectService.find(EntityBo.class, entityId);
725 }
726
727 @Override
728 public Principal getPrincipalByPrincipalName(String principalName) throws RiceIllegalArgumentException {
729 incomingParamCheck(principalName, "principalName");
730
731 return PrincipalBo.to(getPrincipalBoByPrincipalName(principalName));
732 }
733
734 protected PrincipalBo getPrincipalBoByPrincipalName(String principalName) throws RiceIllegalArgumentException {
735 QueryResults<PrincipalBo> principals = dataObjectService.findMatching(PrincipalBo.class,
736 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Principal.PRINCIPAL_NAME, principalName.toLowerCase()).build());
737 if (!principals.getResults().isEmpty() && principals.getResults().size() == 1) {
738 return principals.getResults().get(0);
739 }
740 return null;
741 }
742
743 @Override
744 public List<Principal> getPrincipalsByEntityId(String entityId) throws RiceIllegalArgumentException {
745 incomingParamCheck(entityId, "entityId");
746
747 List<Principal> principals = new ArrayList<Principal>();
748 Map<String,Object> criteria = new HashMap<String,Object>(1);
749 criteria.put(KIMPropertyConstants.Person.ENTITY_ID, entityId);
750 QueryResults<PrincipalBo> principalBos = dataObjectService.findMatching(PrincipalBo.class, QueryByCriteria.Builder.andAttributes(criteria).build());
751
752 if (!principalBos.getResults().isEmpty()) {
753
754 for(PrincipalBo principalBo: principalBos.getResults()) {
755 Principal principal = PrincipalBo.to(principalBo);
756 principals.add(principal);
757 }
758 return principals;
759 }
760 return null;
761 }
762
763 @Override
764 public List<Principal> getPrincipalsByEmployeeId(String employeeId) throws RiceIllegalArgumentException {
765 incomingParamCheck(employeeId, "employeeId");
766
767 List<Principal> principals = new ArrayList<Principal>();
768 Map<String,Object> criteria = new HashMap<String,Object>(1);
769 criteria.put(KIMPropertyConstants.Person.EMPLOYEE_ID, employeeId);
770 QueryResults<EntityEmploymentBo> entityEmploymentBos = dataObjectService.findMatching(EntityEmploymentBo.class, QueryByCriteria.Builder.andAttributes(criteria).build());
771
772 if (!entityEmploymentBos.getResults().isEmpty()) {
773 List<String> entityIds = new ArrayList<String>();
774 for(EntityEmploymentBo entityEmploymentBo: entityEmploymentBos.getResults()) {
775 String entityId = entityEmploymentBo.getEntityId();
776 if (StringUtils.isNotBlank(entityId) && !entityIds.contains(entityId)) {
777 entityIds.add(entityId);
778 }
779 }
780
781 for(String entityId: entityIds) {
782 List<Principal> principalsForEntity = getPrincipalsByEntityId(entityId);
783 if (principalsForEntity != null && !principalsForEntity.isEmpty()) {
784 principals.addAll(principalsForEntity);
785 }
786 }
787 if (!principals.isEmpty()) {
788 return principals;
789 }
790 }
791 return null;
792 }
793
794
795
796
797 protected EntityBo getEntityBoByPrincipalName(String principalName) {
798 if ( StringUtils.isBlank( principalName ) ) {
799 return null;
800 }
801 return getEntityByKeyValue("principals." + KIMPropertyConstants.Principal.PRINCIPAL_NAME, principalName.toLowerCase());
802 }
803
804
805
806
807 protected EntityBo getEntityBoByPrincipalId(String principalId) {
808 if ( StringUtils.isBlank( principalId ) ) {
809 return null;
810 }
811 return getEntityByKeyValue("principals." + KIMPropertyConstants.Principal.PRINCIPAL_ID, principalId);
812 }
813
814
815
816
817 protected EntityBo getEntityBoByEmployeeId(String employeeId) {
818 if ( StringUtils.isBlank( employeeId ) ) {
819 return null;
820 }
821 return getEntityByKeyValue("employmentInformation." + KIMPropertyConstants.Person.EMPLOYEE_ID, employeeId);
822 }
823
824
825
826
827 protected EntityBo getEntityByKeyValue(String key, String value) {
828 List<EntityBo> entities = dataObjectService.findMatching(EntityBo.class,
829 QueryByCriteria.Builder.forAttribute(key, value).build()).getResults();
830 if (entities.size() >= 1) {
831 return entities.get(0);
832 }
833 return null;
834 }
835
836 @Override
837 public CodedAttribute getAddressType( String code ) throws RiceIllegalArgumentException {
838 incomingParamCheck(code, "code");
839 EntityAddressTypeBo impl = dataObjectService.find(EntityAddressTypeBo.class, code);
840 if ( impl == null ) {
841 return null;
842 }
843 return EntityAddressTypeBo.to(impl);
844 }
845
846 @Override
847 public List<CodedAttribute> findAllAddressTypes() {
848 List<EntityAddressTypeBo> bos = dataObjectService.findMatching(EntityAddressTypeBo.class,
849 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
850
851 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
852 for (EntityAddressTypeBo bo : bos) {
853 codedAttributes.add(EntityAddressTypeBo.to(bo));
854 }
855 return Collections.unmodifiableList(codedAttributes);
856 }
857
858 @Override
859 public EntityAffiliationType getAffiliationType( String code ) throws RiceIllegalArgumentException {
860 incomingParamCheck(code, "code");
861
862 EntityAffiliationTypeBo impl = dataObjectService.find(EntityAffiliationTypeBo.class, code);
863 if ( impl == null ) {
864 return null;
865 }
866 return EntityAffiliationTypeBo.to(impl);
867 }
868
869 @Override
870 public List<EntityAffiliationType> findAllAffiliationTypes() {
871 List<EntityAffiliationTypeBo> bos = dataObjectService.findMatching(EntityAffiliationTypeBo.class,
872 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
873
874 List<EntityAffiliationType> codedAttributes = new ArrayList<EntityAffiliationType>();
875 for (EntityAffiliationTypeBo bo : bos) {
876 codedAttributes.add(EntityAffiliationTypeBo.to(bo));
877 }
878 return Collections.unmodifiableList(codedAttributes);
879 }
880
881 @Override
882 public CodedAttribute getCitizenshipStatus( String code ) throws RiceIllegalArgumentException {
883 incomingParamCheck(code, "code");
884 EntityCitizenshipStatusBo impl = dataObjectService.find(EntityCitizenshipStatusBo.class, code);
885 if ( impl == null ) {
886 return null;
887 }
888 return EntityCitizenshipStatusBo.to(impl);
889 }
890
891 @Override
892 public List<CodedAttribute> findAllCitizenshipStatuses() {
893 List<EntityCitizenshipStatusBo> bos = dataObjectService.findMatching(EntityCitizenshipStatusBo.class,
894 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
895
896 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
897 for (EntityCitizenshipStatusBo bo : bos) {
898 codedAttributes.add(EntityCitizenshipStatusBo.to(bo));
899 }
900 return Collections.unmodifiableList(codedAttributes);
901 }
902
903 @Override
904 public CodedAttribute getEmailType( String code ) throws RiceIllegalArgumentException {
905 incomingParamCheck(code, "code");
906 EntityEmailTypeBo impl = dataObjectService.find(EntityEmailTypeBo.class, code);
907 if ( impl == null ) {
908 return null;
909 }
910 return EntityEmailTypeBo.to(impl);
911 }
912
913 @Override
914 public List<CodedAttribute> findAllEmailTypes() {
915 List<EntityEmailTypeBo> bos = dataObjectService.findMatching(EntityEmailTypeBo.class,
916 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
917
918 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
919 for (EntityEmailTypeBo bo : bos) {
920 codedAttributes.add(EntityEmailTypeBo.to(bo));
921 }
922 return Collections.unmodifiableList(codedAttributes);
923 }
924
925 @Override
926 public PrincipalQueryResults findPrincipals(
927 @WebParam(name = "query") QueryByCriteria query) throws RiceIllegalArgumentException {
928 incomingParamCheck(query, "query");
929
930 QueryResults<PrincipalBo> results = dataObjectService.findMatching(PrincipalBo.class, query);
931
932 PrincipalQueryResults.Builder builder = PrincipalQueryResults.Builder.create();
933 builder.setMoreResultsAvailable(results.isMoreResultsAvailable());
934 builder.setTotalRowCount(results.getTotalRowCount());
935
936 final List<Principal.Builder> ims = new ArrayList<Principal.Builder>();
937 for (PrincipalBo bo : results.getResults()) {
938 ims.add(Principal.Builder.create(bo));
939 }
940
941 builder.setResults(ims);
942 return builder.build();
943 }
944
945 @Override
946 public CodedAttribute getEmploymentStatus( String code ) throws RiceIllegalArgumentException {
947 incomingParamCheck(code, "code");
948 EntityEmploymentStatusBo impl = dataObjectService.find(EntityEmploymentStatusBo.class, code);
949 if ( impl == null ) {
950 return null;
951 }
952 return EntityEmploymentStatusBo.to(impl);
953 }
954
955 @Override
956 public List<CodedAttribute> findAllEmploymentStatuses() {
957 List<EntityEmploymentStatusBo> bos = dataObjectService.findMatching(EntityEmploymentStatusBo.class,
958 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
959
960 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
961 for (EntityEmploymentStatusBo bo : bos) {
962 codedAttributes.add(EntityEmploymentStatusBo.to(bo));
963 }
964 return Collections.unmodifiableList(codedAttributes);
965 }
966
967 @Override
968 public CodedAttribute getEmploymentType( String code ) throws RiceIllegalArgumentException {
969 incomingParamCheck(code, "code");
970 EntityEmploymentTypeBo impl = dataObjectService.find(EntityEmploymentTypeBo.class, code);
971 if ( impl == null ) {
972 return null;
973 }
974 return EntityEmploymentTypeBo.to(impl);
975 }
976
977 @Override
978 public List<CodedAttribute> findAllEmploymentTypes() {
979 List<EntityEmploymentTypeBo> bos = dataObjectService.findMatching(EntityEmploymentTypeBo.class,
980 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
981
982 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
983 for (EntityEmploymentTypeBo bo : bos) {
984 codedAttributes.add(EntityEmploymentTypeBo.to(bo));
985 }
986 return Collections.unmodifiableList(codedAttributes);
987 }
988
989 @Override
990 public CodedAttribute getNameType(String code) throws RiceIllegalArgumentException {
991 incomingParamCheck(code, "code");
992 EntityNameTypeBo impl = dataObjectService.find(EntityNameTypeBo.class, code);
993 if ( impl == null ) {
994 return null;
995 }
996 return EntityNameTypeBo.to(impl);
997 }
998
999 @Override
1000 public List<CodedAttribute> findAllNameTypes() {
1001 List<EntityNameTypeBo> bos = dataObjectService.findMatching(EntityNameTypeBo.class,
1002 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
1003
1004 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
1005 for (EntityNameTypeBo bo : bos) {
1006 codedAttributes.add(EntityNameTypeBo.to(bo));
1007 }
1008 return Collections.unmodifiableList(codedAttributes);
1009 }
1010
1011 @Override
1012 public CodedAttribute getEntityType( String code ) throws RiceIllegalArgumentException {
1013 incomingParamCheck(code, "code");
1014 EntityTypeBo impl = dataObjectService.find(EntityTypeBo.class, code);
1015 if ( impl == null ) {
1016 return null;
1017 }
1018 return EntityTypeBo.to(impl);
1019 }
1020
1021 @Override
1022 public List<CodedAttribute> findAllEntityTypes() {
1023 List<EntityTypeBo> bos = dataObjectService.findMatching(EntityTypeBo.class,
1024 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
1025
1026 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
1027 for (EntityTypeBo bo : bos) {
1028 codedAttributes.add(EntityTypeBo.to(bo));
1029 }
1030 return Collections.unmodifiableList(codedAttributes);
1031 }
1032
1033 @Override
1034 public EntityExternalIdentifierType getExternalIdentifierType( String code ) throws RiceIllegalArgumentException {
1035 incomingParamCheck(code, "code");
1036
1037 EntityExternalIdentifierTypeBo impl = dataObjectService.find(EntityExternalIdentifierTypeBo.class, code);
1038 if ( impl == null ) {
1039 return null;
1040 }
1041 return EntityExternalIdentifierTypeBo.to(impl);
1042 }
1043
1044 @Override
1045 public List<EntityExternalIdentifierType> findAllExternalIdendtifierTypes() {
1046 List<EntityExternalIdentifierTypeBo> bos = dataObjectService.findMatching(EntityExternalIdentifierTypeBo.class,
1047 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
1048
1049 List<EntityExternalIdentifierType> codedAttributes = new ArrayList<EntityExternalIdentifierType>();
1050 for (EntityExternalIdentifierTypeBo bo : bos) {
1051 codedAttributes.add(EntityExternalIdentifierTypeBo.to(bo));
1052 }
1053 return Collections.unmodifiableList(codedAttributes);
1054 }
1055
1056 @Override
1057 public CodedAttribute getPhoneType( String code ) throws RiceIllegalArgumentException {
1058 incomingParamCheck(code, "code");
1059 EntityPhoneTypeBo impl = dataObjectService.find(EntityPhoneTypeBo.class, code);
1060 if ( impl == null ) {
1061 return null;
1062 }
1063 return EntityPhoneTypeBo.to(impl);
1064 }
1065
1066 @Override
1067 public List<CodedAttribute> findAllPhoneTypes() {
1068 List<EntityPhoneTypeBo> bos = dataObjectService.findMatching(EntityPhoneTypeBo.class,
1069 QueryByCriteria.Builder.forAttribute(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE).build()).getResults();
1070
1071 List<CodedAttribute> codedAttributes = new ArrayList<CodedAttribute>();
1072 for (EntityPhoneTypeBo bo : bos) {
1073 codedAttributes.add(EntityPhoneTypeBo.to(bo));
1074 }
1075 return Collections.unmodifiableList(codedAttributes);
1076 }
1077
1078 @Override
1079 public Entity createEntity(Entity entity) throws RiceIllegalArgumentException, RiceIllegalStateException {
1080 incomingParamCheck(entity, "entity");
1081
1082 if (StringUtils.isNotBlank(entity.getId()) && getEntity(entity.getId()) != null) {
1083 throw new RiceIllegalStateException("the Entity to create already exists: " + entity);
1084 }
1085
1086 EntityBo bo = EntityBo.from(entity);
1087 return EntityBo.to(dataObjectService.save(bo));
1088 }
1089
1090 @Override
1091 public Entity updateEntity(Entity entity) throws RiceIllegalArgumentException, RiceIllegalStateException {
1092 incomingParamCheck(entity, "entity");
1093 EntityBo oldBo = null;
1094 Map<String, String> passwdMap = new HashMap<String, String>();
1095 if (StringUtils.isBlank(entity.getId())) {
1096 throw new RiceIllegalStateException("the Entity does not exist: " + entity);
1097 } else {
1098 oldBo = getEntityBo(entity.getId());
1099 if (oldBo == null) {
1100 throw new RiceIllegalStateException("the Entity does not exist: " + entity);
1101 }
1102 }
1103
1104 for (PrincipalBo principalBo : oldBo.getPrincipals()) {
1105 passwdMap.put(principalBo.getPrincipalId(), principalBo.getPassword());
1106 }
1107 EntityBo bo = EntityBo.from(entity);
1108 for (PrincipalBo principal : bo.getPrincipals()) {
1109 principal.setPassword(passwdMap.get(principal.getPrincipalId()));
1110 }
1111 return EntityBo.to(dataObjectService.save(bo));
1112 }
1113
1114
1115
1116 @Override
1117 public Entity inactivateEntity(String entityId) throws RiceIllegalArgumentException, RiceIllegalStateException {
1118 incomingParamCheck(entityId, "entityId");
1119
1120 EntityBo entity = getEntityBo(entityId);
1121 if (entity == null) {
1122 throw new RiceIllegalStateException("an Entity does not exist for entityId: " + entityId);
1123 }
1124
1125 entity.setActive(false);
1126 return EntityBo.to(dataObjectService.save(entity));
1127 }
1128
1129 @Override
1130 public EntityPrivacyPreferences addPrivacyPreferencesToEntity(EntityPrivacyPreferences privacyPreferences) throws RiceIllegalArgumentException, RiceIllegalStateException {
1131 incomingParamCheck(privacyPreferences, "privacyPreferences");
1132
1133 if (StringUtils.isEmpty(privacyPreferences.getEntityId()) || StringUtils.isBlank(privacyPreferences.getEntityId())) {
1134 throw new RiceIllegalStateException("PrivacyPreferences' entityId must be populated before creation");
1135 } else {
1136 if (getEntityPrivacyPreferences(privacyPreferences.getEntityId()) != null) {
1137 throw new RiceIllegalStateException("the PrivacyPreferences to create already exists: " + privacyPreferences);
1138 }
1139 }
1140 EntityPrivacyPreferencesBo bo = EntityPrivacyPreferencesBo.from(privacyPreferences);
1141 return EntityPrivacyPreferencesBo.to(dataObjectService.save(bo));
1142 }
1143
1144 @Override
1145 public EntityPrivacyPreferences updatePrivacyPreferences(EntityPrivacyPreferences privacyPreferences) throws RiceIllegalArgumentException, RiceIllegalStateException {
1146 incomingParamCheck(privacyPreferences, "privacyPreferences");
1147
1148 if (StringUtils.isEmpty(privacyPreferences.getEntityId()) || StringUtils.isBlank(privacyPreferences.getEntityId())) {
1149 throw new RiceIllegalStateException("PrivacyPreferences' entityId must be populated before update");
1150 } else {
1151 if (getEntityPrivacyPreferences(privacyPreferences.getEntityId()) == null) {
1152 throw new RiceIllegalStateException("the PrivacyPreferences to update does not exist: " + privacyPreferences);
1153 }
1154 }
1155 EntityPrivacyPreferencesBo bo = EntityPrivacyPreferencesBo.from(privacyPreferences);
1156 return EntityPrivacyPreferencesBo.to(dataObjectService.save(bo));
1157 }
1158
1159 protected EntityCitizenshipBo getEntityCitizenshipBo(String entityId, String citizenshipStatusCode) {
1160 if (StringUtils.isEmpty(entityId) || StringUtils.isEmpty(citizenshipStatusCode)) {
1161 return null;
1162 }
1163 Map<String,Object> criteria = new HashMap<String,Object>(4);
1164 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
1165 criteria.put("statusCode", citizenshipStatusCode);
1166 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1167 List<EntityCitizenshipBo> results = dataObjectService.findMatching(EntityCitizenshipBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1168 if ( results.isEmpty() ) {
1169 return null;
1170 }
1171 return results.get(0);
1172
1173 }
1174
1175 protected EntityCitizenshipBo getEntityCitizenshipBo(String id) {
1176 if (StringUtils.isEmpty(id)) {
1177 return null;
1178 }
1179 Map<String,Object> criteria = new HashMap<String,Object>();
1180 criteria.put(KIMPropertyConstants.Entity.ID, id);
1181 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1182 List<EntityCitizenshipBo> results = dataObjectService.findMatching(EntityCitizenshipBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1183 if ( results.isEmpty() ) {
1184 return null;
1185 }
1186 return results.get(0);
1187 }
1188
1189 @Override
1190 public EntityCitizenship addCitizenshipToEntity(EntityCitizenship citizenship) throws RiceIllegalArgumentException, RiceIllegalStateException {
1191 incomingParamCheck(citizenship, "citizenship");
1192
1193 if (StringUtils.isEmpty(citizenship.getEntityId()) || StringUtils.isBlank(citizenship.getEntityId())) {
1194 throw new RiceIllegalStateException("Citizenship's entityId must be populated before creation");
1195 } else {
1196 if (citizenship.getStatus() == null) {
1197 throw new RiceIllegalStateException("Citizenship's status must be populated before creation");
1198 }
1199 if (getEntityCitizenshipBo(citizenship.getEntityId(), citizenship.getStatus().getCode()) != null) {
1200 throw new RiceIllegalStateException("the EntityCitizenship to create already exists: " + citizenship);
1201 }
1202 }
1203 EntityCitizenshipBo bo = EntityCitizenshipBo.from(citizenship);
1204 return EntityCitizenshipBo.to(dataObjectService.save(bo));
1205 }
1206
1207 @Override
1208 public EntityCitizenship updateCitizenship(EntityCitizenship citizenship) throws RiceIllegalArgumentException, RiceIllegalStateException {
1209 incomingParamCheck(citizenship, "citizenship");
1210
1211 if (StringUtils.isEmpty(citizenship.getEntityId()) || StringUtils.isBlank(citizenship.getEntityId())) {
1212 throw new RiceIllegalStateException("Email's entityId must be populated before creation");
1213 } else {
1214 if (citizenship.getStatus() == null) {
1215 throw new RiceIllegalStateException("Citizenship's status must be populated before creation");
1216 }
1217 if (getEntityCitizenshipBo(citizenship.getEntityId(), citizenship.getStatus().getCode()) == null) {
1218 throw new RiceIllegalStateException("the EntityCitizenship to update does not exist: " + citizenship);
1219 }
1220 }
1221 EntityCitizenshipBo bo = EntityCitizenshipBo.from(citizenship);
1222 return EntityCitizenshipBo.to(dataObjectService.save(bo));
1223 }
1224
1225 @Override
1226 public EntityCitizenship inactivateCitizenship(String id) throws RiceIllegalArgumentException, RiceIllegalStateException {
1227 incomingParamCheck(id, "id");
1228
1229 EntityCitizenshipBo bo = getEntityCitizenshipBo(id);
1230 if (bo == null) {
1231 throw new RiceIllegalStateException("the EntityCitizenship with id: " + id + " does not exist");
1232 }
1233 bo.setActive(false);
1234 return EntityCitizenshipBo.to(dataObjectService.save(bo));
1235 }
1236
1237 protected EntityEthnicityBo getEntityEthnicityBo(String ethnicityId) {
1238 if (StringUtils.isEmpty(ethnicityId)) {
1239 return null;
1240 }
1241 return dataObjectService.find(EntityEthnicityBo.class, ethnicityId);
1242 }
1243 @Override
1244 public EntityEthnicity addEthnicityToEntity(EntityEthnicity ethnicity) throws RiceIllegalArgumentException {
1245 incomingParamCheck(ethnicity, "ethnicity");
1246
1247 if (StringUtils.isEmpty(ethnicity.getEntityId()) || StringUtils.isBlank(ethnicity.getEntityId())) {
1248 throw new RiceIllegalStateException("Ethnicity's entityId must be populated before creation");
1249 } else {
1250 if (StringUtils.isNotEmpty(ethnicity.getId()) && getEntityEthnicityBo(ethnicity.getId()) != null) {
1251 throw new RiceIllegalStateException("the EntityEthnicity to create already exists: " + ethnicity);
1252 }
1253 }
1254 EntityEthnicityBo bo = EntityEthnicityBo.from(ethnicity);
1255 return EntityEthnicityBo.to(dataObjectService.save(bo));
1256 }
1257
1258 @Override
1259 public EntityEthnicity updateEthnicity(EntityEthnicity ethnicity) throws RiceIllegalArgumentException, RiceIllegalStateException {
1260 incomingParamCheck(ethnicity, "ethnicity");
1261
1262 if (StringUtils.isEmpty(ethnicity.getEntityId()) || StringUtils.isBlank(ethnicity.getEntityId())) {
1263 throw new RiceIllegalStateException("Ethnicity's entityId must be populated before creation");
1264 } else {
1265 if (StringUtils.isEmpty(ethnicity.getId()) || getEntityEthnicityBo(ethnicity.getId()) == null) {
1266 throw new RiceIllegalStateException("the EntityEthnicity to update does not exist: " + ethnicity);
1267 }
1268 }
1269 EntityEthnicityBo bo = EntityEthnicityBo.from(ethnicity);
1270 return EntityEthnicityBo.to(dataObjectService.save(bo));
1271 }
1272
1273 protected EntityResidencyBo getEntityResidencyBo(String residencyId) {
1274 if (StringUtils.isEmpty(residencyId)) {
1275 return null;
1276 }
1277 return dataObjectService.find(EntityResidencyBo.class, residencyId);
1278 }
1279
1280 @Override
1281 public EntityResidency addResidencyToEntity(EntityResidency residency) throws RiceIllegalArgumentException, RiceIllegalStateException {
1282 incomingParamCheck(residency, "residency");
1283
1284 if (StringUtils.isEmpty(residency.getEntityId()) || StringUtils.isBlank(residency.getEntityId())) {
1285 throw new RiceIllegalStateException("Residency's entityId must be populated before creation");
1286 } else {
1287 if (StringUtils.isNotEmpty(residency.getId()) && getEntityResidencyBo(residency.getId()) != null) {
1288 throw new RiceIllegalStateException("the EntityResidency to create already exists: " + residency);
1289 }
1290 }
1291 EntityResidencyBo bo = EntityResidencyBo.from(residency);
1292 return EntityResidencyBo.to(dataObjectService.save(bo));
1293 }
1294
1295 @Override
1296 public EntityResidency updateResidency(EntityResidency residency) throws RiceIllegalArgumentException, RiceIllegalStateException {
1297 incomingParamCheck(residency, "residency");
1298
1299 if (StringUtils.isEmpty(residency.getEntityId()) || StringUtils.isBlank(residency.getEntityId())) {
1300 throw new RiceIllegalStateException("Residency's entityId must be populated before creation");
1301 } else {
1302 if (StringUtils.isEmpty(residency.getId()) || getEntityResidencyBo(residency.getId()) == null) {
1303 throw new RiceIllegalStateException("the EntityResidency to update does not exist: " + residency);
1304 }
1305 }
1306 EntityResidencyBo bo = EntityResidencyBo.from(residency);
1307 return EntityResidencyBo.to(dataObjectService.save(bo));
1308 }
1309
1310 protected EntityVisaBo getEntityVisaBo(String visaId) {
1311 if (StringUtils.isEmpty(visaId)) {
1312 return null;
1313 }
1314 return dataObjectService.find(EntityVisaBo.class, visaId);
1315 }
1316
1317 @Override
1318 public EntityVisa addVisaToEntity(EntityVisa visa) throws RiceIllegalArgumentException, RiceIllegalStateException {
1319 incomingParamCheck(visa, "visa");
1320
1321 if (StringUtils.isEmpty(visa.getEntityId()) || StringUtils.isBlank(visa.getEntityId())) {
1322 throw new RiceIllegalStateException("Visa's entityId must be populated before creation");
1323 } else {
1324 if (StringUtils.isNotEmpty(visa.getId()) && getEntityVisaBo(visa.getId()) != null) {
1325 throw new RiceIllegalStateException("the EntityVisa to create already exists: " + visa);
1326 }
1327 }
1328 EntityVisaBo bo = EntityVisaBo.from(visa);
1329 return EntityVisaBo.to(dataObjectService.save(bo));
1330 }
1331
1332 @Override
1333 public EntityVisa updateVisa(EntityVisa visa) throws RiceIllegalArgumentException, RiceIllegalStateException {
1334 incomingParamCheck(visa, "visa");
1335
1336 if (StringUtils.isEmpty(visa.getEntityId()) || StringUtils.isBlank(visa.getEntityId())) {
1337 throw new RiceIllegalStateException("Visa's entityId must be populated before creation");
1338 } else {
1339 if (StringUtils.isEmpty(visa.getId()) || getEntityVisaBo(visa.getId()) == null) {
1340 throw new RiceIllegalStateException("the EntityVisa to update does not exist: " + visa);
1341 }
1342 }
1343 EntityVisaBo bo = EntityVisaBo.from(visa);
1344 return EntityVisaBo.to(dataObjectService.save(bo));
1345 }
1346
1347 protected EntityNameBo getEntityNameBo(String entityId, String nameTypeCode) {
1348 if (StringUtils.isEmpty(entityId) || StringUtils.isEmpty(nameTypeCode)) {
1349 return null;
1350 }
1351 Map<String,Object> criteria = new HashMap<String,Object>();
1352 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
1353 criteria.put("nameCode", nameTypeCode);
1354 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1355 List<EntityNameBo> results = dataObjectService.findMatching(EntityNameBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1356 if ( results.isEmpty() ) {
1357 return null;
1358 }
1359 return results.get(0);
1360 }
1361
1362 protected EntityNameBo getEntityNameBo(String id) {
1363 if (StringUtils.isEmpty(id)) {
1364 return null;
1365 }
1366 Map<String,Object> criteria = new HashMap<String,Object>();
1367 criteria.put(KIMPropertyConstants.Entity.ID, id);
1368 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1369 List<EntityNameBo> results = dataObjectService.findMatching(EntityNameBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1370 if ( results.isEmpty() ) {
1371 return null;
1372 }
1373 return results.get(0);
1374 }
1375
1376 @Override
1377 public EntityNamePrincipalName getDefaultNamesForPrincipalId(String principalId) {
1378 PrincipalBo principal = dataObjectService.find(PrincipalBo.class, principalId);
1379
1380 if (null != principal) {
1381 EntityNamePrincipalName.Builder nameBuilder = EntityNamePrincipalName.Builder.create();
1382 nameBuilder.setPrincipalName(principal.getPrincipalName());
1383
1384 Map<String,Object> criteria = new HashMap<String,Object>();
1385 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, principal.getEntityId());
1386 criteria.put("defaultValue", Boolean.TRUE);
1387 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1388 List<EntityNameBo> results = dataObjectService.findMatching(EntityNameBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1389 if ( results.isEmpty() ) {
1390
1391 EntityName.Builder defaultNameBuilder = EntityName.Builder.create();
1392 defaultNameBuilder.setLastName(principal.getPrincipalName().toUpperCase());
1393 nameBuilder.setDefaultName(defaultNameBuilder);
1394 } else {
1395 nameBuilder.setDefaultName( EntityName.Builder.create(results.get(0)) );
1396 }
1397 EntityNamePrincipalName entityNamePrincipalName = nameBuilder.build();
1398 return entityNamePrincipalName;
1399 }
1400 return null;
1401 }
1402
1403 @Override
1404 public EntityName addNameToEntity(EntityName name) throws RiceIllegalArgumentException, RiceIllegalStateException {
1405 incomingParamCheck(name, "name");
1406
1407 if (StringUtils.isEmpty(name.getEntityId()) || StringUtils.isBlank(name.getEntityId())) {
1408 throw new RiceIllegalStateException("Name's entityId must be populated before creation");
1409 } else {
1410 if (name.getNameType() == null) {
1411 throw new RiceIllegalStateException("EntityName's type must be populated before creation");
1412 }
1413 if (getEntityNameBo(name.getEntityId(), name.getNameType().getCode()) != null) {
1414 throw new RiceIllegalStateException("the EntityName to create already exists: " + name);
1415 }
1416 }
1417 EntityNameBo bo = EntityNameBo.from(name);
1418 return EntityNameBo.to(dataObjectService.save(bo));
1419 }
1420
1421 @Override
1422 public EntityName updateName(EntityName name) throws RiceIllegalArgumentException, RiceIllegalStateException {
1423 incomingParamCheck(name, "name");
1424
1425 if (StringUtils.isEmpty(name.getEntityId()) || StringUtils.isBlank(name.getEntityId())) {
1426 throw new RiceIllegalStateException("Name's entityId must be populated before update");
1427 } else {
1428 if (name.getNameType() == null) {
1429 throw new RiceIllegalStateException("EntityName's type must be populated before update");
1430 }
1431 if (StringUtils.isEmpty(name.getId()) || getEntityNameBo(name.getId()) == null) {
1432 throw new RiceIllegalStateException("the EntityName to update does not exist: " + name);
1433 }
1434 }
1435 EntityNameBo bo = EntityNameBo.from(name);
1436 return EntityNameBo.to(dataObjectService.save(bo));
1437 }
1438
1439 @Override
1440 public EntityName inactivateName(String id) throws RiceIllegalArgumentException, RiceIllegalStateException {
1441 incomingParamCheck(id, "id");
1442
1443 EntityNameBo bo = getEntityNameBo(id);
1444 if (bo == null) {
1445 throw new RiceIllegalStateException("the EntityName to inactivate does not exist");
1446 }
1447
1448 bo.setActive(false);
1449 return EntityNameBo.to(dataObjectService.save(bo));
1450 }
1451
1452 protected EntityEmploymentBo getEntityEmploymentBo(String entityId, String employmentTypeCode,
1453 String employmentStatusCode, String employmentAffiliationId) {
1454 if (StringUtils.isEmpty(entityId) || StringUtils.isEmpty(employmentTypeCode)
1455 || StringUtils.isEmpty(employmentStatusCode) || StringUtils.isEmpty(employmentAffiliationId)) {
1456 return null;
1457 }
1458 Map<String,Object> criteria = new HashMap<String,Object>();
1459 criteria.put(KIMPropertyConstants.Entity.ENTITY_ID, entityId);
1460 criteria.put("employeeTypeCode", employmentTypeCode);
1461 criteria.put("employeeStatusCode", employmentStatusCode);
1462 criteria.put("entityAffiliationId", employmentAffiliationId);
1463 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1464 List<EntityEmploymentBo> results = dataObjectService.findMatching(EntityEmploymentBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1465 if ( results.isEmpty() ) {
1466 return null;
1467 }
1468 return results.get(0);
1469 }
1470
1471 protected EntityEmploymentBo getEntityEmploymentBo(String id) {
1472 if (StringUtils.isEmpty(id)) {
1473 return null;
1474 }
1475 Map<String,Object> criteria = new HashMap<String,Object>();
1476 criteria.put(KIMPropertyConstants.Entity.ID, id);
1477 criteria.put(KIMPropertyConstants.Entity.ACTIVE, Boolean.TRUE);
1478 List<EntityEmploymentBo> results = dataObjectService.findMatching(EntityEmploymentBo.class, QueryByCriteria.Builder.andAttributes(criteria).build()).getResults();
1479 if ( results.isEmpty() ) {
1480 return null;
1481 }
1482 return results.get(0);
1483 }
1484 @Override
1485 public EntityEmployment addEmploymentToEntity(EntityEmployment employment) throws RiceIllegalArgumentException, RiceIllegalStateException {
1486 incomingParamCheck(employment, "employment");
1487
1488 if (StringUtils.isEmpty(employment.getEntityId()) || StringUtils.isBlank(employment.getEntityId())) {
1489 throw new RiceIllegalStateException("EntityEmployment's entityId must be populated before creation");
1490 } else {
1491 if (employment.getEmployeeType() == null
1492 || employment.getEmployeeStatus() == null
1493 || employment.getEntityAffiliation() == null) {
1494 throw new RiceIllegalStateException("EntityEmployment's status, type, and entity affiliation must be populated before creation");
1495 }
1496 if (getEntityEmploymentBo(employment.getEntityId(), employment.getEmployeeType().getCode(), employment.getEmployeeStatus().getCode(), employment.getEntityAffiliation().getId()) != null) {
1497 throw new RiceIllegalStateException("the EntityEmployment to create already exists: " + employment);
1498 }
1499 }
1500 EntityEmploymentBo bo = EntityEmploymentBo.from(employment);
1501 return EntityEmploymentBo.to(dataObjectService.save(bo));
1502 }
1503
1504 @Override
1505 public EntityEmployment updateEmployment(EntityEmployment employment) throws RiceIllegalArgumentException, RiceIllegalStateException {
1506 incomingParamCheck(employment, "employment");
1507
1508 if (StringUtils.isEmpty(employment.getEntityId()) || StringUtils.isBlank(employment.getEntityId())) {
1509 throw new RiceIllegalStateException("EntityEmployment's entityId must be populated before update");
1510 } else {
1511 if (employment.getEmployeeType() == null
1512 || employment.getEmployeeStatus() == null
1513 || employment.getEntityAffiliation() == null) {
1514 throw new RiceIllegalStateException("EntityEmployment's status, type, and entity affiliation must be populated before update");
1515 }
1516 if (getEntityEmploymentBo(employment.getEntityId(), employment.getEmployeeType().getCode(), employment.getEmployeeStatus().getCode(), employment.getEntityAffiliation().getId()) == null) {
1517 throw new RiceIllegalStateException("the EntityEmployment to udpate does not exist: " + employment);
1518 }
1519 }
1520 EntityEmploymentBo bo = EntityEmploymentBo.from(employment);
1521 return EntityEmploymentBo.to(dataObjectService.save(bo));
1522 }
1523
1524 @Override
1525 public EntityEmployment inactivateEmployment(String id) throws RiceIllegalArgumentException, RiceIllegalStateException {
1526 incomingParamCheck(id, "id");
1527
1528 EntityEmploymentBo bo = getEntityEmploymentBo(id);
1529 if (bo == null) {
1530 throw new RiceIllegalStateException("the EntityEmployment to inactivate does not exist");
1531 }
1532 bo.setActive(false);
1533 return EntityEmploymentBo.to(dataObjectService.save(bo));
1534 }
1535
1536 protected EntityBioDemographicsBo getEntityBioDemographicsBo(String entityId) {
1537 if (StringUtils.isEmpty(entityId)) {
1538 return null;
1539 }
1540 return dataObjectService.find(EntityBioDemographicsBo.class, entityId);
1541 }
1542
1543 @Override
1544 public EntityBioDemographics addBioDemographicsToEntity(EntityBioDemographics bioDemographics) throws RiceIllegalArgumentException, RiceIllegalStateException {
1545 incomingParamCheck(bioDemographics, "bioDemographics");
1546
1547 if (StringUtils.isEmpty(bioDemographics.getEntityId()) || StringUtils.isBlank(bioDemographics.getEntityId())) {
1548 throw new RiceIllegalStateException("BioDemographics' entityId must be populated before creation");
1549 } else {
1550 if (getEntityBioDemographicsBo(bioDemographics.getEntityId()) != null) {
1551 throw new RiceIllegalStateException("the EntityBioDemographics to create already exists: " + bioDemographics);
1552 }
1553 }
1554 EntityBioDemographicsBo bo = EntityBioDemographicsBo.from(bioDemographics);
1555 return EntityBioDemographicsBo.to(dataObjectService.save(bo));
1556 }
1557
1558 @Override
1559 public EntityBioDemographics updateBioDemographics(EntityBioDemographics bioDemographics) throws RiceIllegalArgumentException, RiceIllegalStateException {
1560 incomingParamCheck(bioDemographics, "bioDemographics");
1561
1562 if (getEntityBioDemographicsBo(bioDemographics.getEntityId()) == null) {
1563 throw new RiceIllegalStateException("the EntityBioDemographics to update does not exist: " + bioDemographics);
1564 }
1565 EntityBioDemographicsBo bo = EntityBioDemographicsBo.from(bioDemographics);
1566 return EntityBioDemographicsBo.to(dataObjectService.save(bo));
1567 }
1568
1569 protected void incomingParamCheck(Object object, String name) {
1570 if (object == null) {
1571 throw new RiceIllegalArgumentException(name + " was null");
1572 } else if (object instanceof String
1573 && StringUtils.isBlank((String) object)) {
1574 throw new RiceIllegalArgumentException(name + " was blank");
1575 }
1576 }
1577
1578 public void setDataObjectService(DataObjectService dataObjectService) {
1579 this.dataObjectService = dataObjectService;
1580 }
1581 }