public ServiceExecutionResult<Person> addPerson(
final ReconciliationCriteria reconciliationCriteria)
throws ReconciliationException, IllegalArgumentException, SorPersonAlreadyExistsException {
Assert.notNull(reconciliationCriteria, "reconciliationCriteria cannot be null");
logger.info("addPerson start");
if (reconciliationCriteria.getSorPerson().getSorId() != null
&& this.findBySorIdentifierAndSource(
reconciliationCriteria.getSorPerson().getSourceSor(),
reconciliationCriteria.getSorPerson().getSorId())
!= null) {
// throw new IllegalStateException("CANNOT ADD SAME SOR RECORD.");
throw new SorPersonAlreadyExistsException(
this.findBySorIdentifierAndSource(
reconciliationCriteria.getSorPerson().getSourceSor(),
reconciliationCriteria.getSorPerson().getSorId()));
}
final Set validationErrors = this.validator.validate(reconciliationCriteria);
if (!validationErrors.isEmpty()) {
Iterator iter = validationErrors.iterator();
while (iter.hasNext()) {
logger.info("validation errors: " + iter.next());
}
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<Person>(validationErrors);
}
final ReconciliationResult result = this.reconciler.reconcile(reconciliationCriteria);
switch (result.getReconciliationType()) {
case NONE:
return new GeneralServiceExecutionResult<Person>(
saveSorPersonAndConvertToCalculatedPerson(reconciliationCriteria));
case EXACT:
return new GeneralServiceExecutionResult<Person>(
addNewSorPersonAndLinkWithMatchedCalculatedPerson(reconciliationCriteria, result));
}
this.criteriaCache.put(reconciliationCriteria, result);
logger.info("addPerson start");
throw new ReconciliationException(result);
}
public ServiceExecutionResult<Person> validateAndSavePersonAndRole(
final ReconciliationCriteria reconciliationCriteria) {
logger.info(" validateAndSavePersonAndRole start");
SorPerson sorPerson = reconciliationCriteria.getSorPerson();
if (sorPerson == null || sorPerson.getRoles() == null)
throw new IllegalArgumentException("Sor Person not found in provided criteria.");
SorRole sorRole = reconciliationCriteria.getSorPerson().getRoles().get(0);
if (sorRole == null)
throw new IllegalArgumentException("Sor Role not found for provided criteria.");
setRoleIdAndSource(sorRole, sorPerson.getSourceSor());
final Set validationErrors = this.validator.validate(sorRole);
if (!validationErrors.isEmpty()) {
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<Person>(validationErrors);
}
Long personId = sorPerson.getPersonId();
if (personId == null) {
logger.info("calling saveSorPersonAndConvertToCalculatedPerson");
// add new Sor Person and roles, create calculated person
return new GeneralServiceExecutionResult<Person>(
saveSorPersonAndConvertToCalculatedPerson(reconciliationCriteria));
} else { // Add new Sor Person and role and link to the existing person
Person thisPerson = this.personRepository.findByInternalId(personId);
try {
logger.info("calling addSorPersonAndLink");
Person savedPerson = this.addSorPersonAndLink(reconciliationCriteria, thisPerson);
return new GeneralServiceExecutionResult<Person>(savedPerson);
} catch (SorPersonAlreadyExistsException sorE) {
throw new IllegalArgumentException(
"If a sor Person of the same source already exists, should call the other method to add the role only");
}
}
}
protected Person addSorPersonAndLink(
final ReconciliationCriteria reconciliationCriteria, final Person person)
throws SorPersonAlreadyExistsException {
final SorPerson sorPerson = reconciliationCriteria.getSorPerson();
final SorPerson registrySorPerson =
this.findByPersonIdAndSorIdentifier(person.getId(), sorPerson.getSourceSor());
if (registrySorPerson != null) {
// throw new IllegalStateException("Oops! An error occurred. A person already exists from this
// SoR linked to this ID!");
throw new SorPersonAlreadyExistsException(registrySorPerson);
}
if (!StringUtils.hasText(sorPerson.getSorId())) {
sorPerson.setSorId(this.identifierGenerator.generateNextString());
}
// Iterate over any sorRoles setting sorid and source id
for (final SorRole sorRole : sorPerson.getRoles()) {
setRoleIdAndSource(sorRole, sorPerson.getSourceSor());
}
sorPerson.setPersonId(person.getId());
final SorPerson savedSorPerson = this.personRepository.saveSorPerson(sorPerson);
// Create calculated roles.
for (final SorRole newSorRole : savedSorPerson.getRoles()) {
// let sor role elector decide if this new role can be converted to calculated one
sorRoleElector.addSorRole(newSorRole, person);
}
// loop through all identifiers to see if addition of this new sor person will have a new
// identifier created at calculated level
for (final IdentifierAssigner ia : this.identifierAssigners) {
ia.addIdentifierTo(sorPerson, person);
}
Person p = recalculatePersonBiodemInfo(person, savedSorPerson, RecalculationType.UPDATE, false);
return this.personRepository.savePerson(p);
}
/**
* Current workflow for converting an SorPerson into the actual Person.
*
* @param reconciliationCriteria the original search criteria.
* @return the newly saved Person.
*/
protected Person saveSorPersonAndConvertToCalculatedPerson(
final ReconciliationCriteria reconciliationCriteria) {
if (!StringUtils.hasText(reconciliationCriteria.getSorPerson().getSorId())) {
reconciliationCriteria.getSorPerson().setSorId(this.identifierGenerator.generateNextString());
}
logger.info("Executing new code!!!!!!");
// Iterate over any sorRoles setting sorid and source id
for (final SorRole sorRole : reconciliationCriteria.getSorPerson().getRoles()) {
setRoleIdAndSource(sorRole, reconciliationCriteria.getSorPerson().getSourceSor());
}
logger.info(
"Creating sorPerson: person_id: " + reconciliationCriteria.getSorPerson().getPersonId());
// Save Sor Person
final SorPerson sorPerson =
this.personRepository.saveSorPerson(reconciliationCriteria.getSorPerson());
Person savedPerson =
recalculatePersonBiodemInfo(
this.personObjectFactory.getObject(), sorPerson, RecalculationType.ADD, false);
savedPerson = this.personRepository.savePerson(savedPerson);
for (final IdentifierAssigner ia : this.identifierAssigners) {
ia.addIdentifierTo(sorPerson, savedPerson);
}
idCardGenerator.addIDCard(savedPerson);
// Create calculated roles.
for (final SorRole newSorRole : sorPerson.getRoles()) {
// let sor role elector decide if this new role can be converted to calculated one
sorRoleElector.addSorRole(newSorRole, savedPerson);
}
final Person newPerson = this.personRepository.savePerson(savedPerson);
logger.info("Verifying Number of calculated Roles: " + newPerson.getRoles().size());
// Now connect the SorPerson to the actual person
sorPerson.setPersonId(newPerson.getId());
this.personRepository.saveSorPerson(sorPerson);
logger.info("Created sorPerson: person_id: " + sorPerson.getPersonId());
return newPerson;
}