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; }