/**
* Update the calculated person data. This method and updateCalculatedPersonOnDeleteOfSor need to
* be generalized to handle recalculations.
*
* @param toPerson
* @param fromPerson
* @param sorPerson Adjust calculated roles... Point prc_role to prc_person receiving role Add the
* role to the set of roles in receiving prc_person Remove role from prc person losing role
*/
protected void updateCalculatedPersonsOnMoveOfSor(
final Person toPerson, final Person fromPerson, final SorPerson sorPerson) {
Assert.notNull(toPerson, "toPerson cannot be null");
Assert.notNull(fromPerson, "fromPerson cannot be null");
logger.info("UpdateCalculated: recalculating person data for move.");
final List<Role> rolesToDelete = new ArrayList<Role>();
final List<SorRole> sorRoles = new ArrayList<SorRole>(sorPerson.getRoles());
for (final SorRole sorRole : sorRoles) {
for (final Role role : fromPerson.getRoles()) {
if (sorRole.getId().equals(role.getSorRoleId())) {
sorRoleElector.addSorRole(sorRole, toPerson);
rolesToDelete.add(role);
}
}
}
for (final Role role : rolesToDelete) {
sorRoleElector.removeCalculatedRole(
fromPerson, role, this.personRepository.getSoRRecordsForPerson(fromPerson));
fromPerson.getRoles().remove(role);
}
// TODO recalculate names for person receiving role? Anything else?
// TODO recalculate names for person losing role? Anything else?
// this.personRepository.savePerson(fromPerson);
// this.personRepository.savePerson(toPerson);
}
protected List<PersonMatch> createMatches(final List<Person> people) {
final List<PersonMatch> personMatches = new ArrayList<PersonMatch>();
for (final Person person : people) {
final PersonMatch p = new PersonMatchImpl(person, 50, new ArrayList<FieldMatch>());
personMatches.add(p);
}
return personMatches;
}
public List<ResourceHandle> members() throws IOException {
Resource[] resources = this.resourceLoader.getResources(getName());
List<ResourceHandle> files = new ArrayList<ResourceHandle>();
for (Resource resource : resources) {
if (!resource.getURL().getPath().endsWith("/") && !shouldFilter(resource)) {
files.add(new FileHandle(resource.getFilename(), resource));
}
}
return files;
}
/**
* Set the schema repository holding all known schema definition files.
*
* @param schemaRepository the schemaRepository to set
*/
public void addSchemaRepository(XsdSchemaRepository schemaRepository) {
if (schemaRepositories == null) {
schemaRepositories = new ArrayList<XsdSchemaRepository>();
}
schemaRepositories.add(schemaRepository);
}
protected Person recalculatePersonBiodemInfo(
final Person person,
final SorPerson sorPerson,
final RecalculationType recalculationType,
boolean mistake) {
final List<SorPerson> sorPersons = this.personRepository.getSoRRecordsForPerson(person);
logger.info("recalculatePersonBiodemInfo: start");
if (recalculationType == RecalculationType.ADD
|| (recalculationType == RecalculationType.DELETE && !mistake)) {
sorPersons.add(sorPerson);
}
copySorNamesToPerson(person, sorPersons);
final Date birthDate =
this.birthDateFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final String gender =
this.genderFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final SorName preferredName =
this.preferredNameFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final SorName officialName =
this.officialNameFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final EmailAddress emailAddress =
this.preferredContactEmailAddressFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final Phone phone =
this.preferredContactPhoneNumberFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final Map<String, String> attributes =
this.attributesElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final SorDisclosureSettings disclosure =
this.disclosureFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
final String ssn =
this.ssnFieldElector.elect(
sorPerson, sorPersons, recalculationType == RecalculationType.DELETE);
Identifier primarySSN = person.getPrimaryIdentifiersByType().get("SSN");
// check if the elector elcted some ssn and person does have previous ssn assigned to it
if (!org.apache.commons.lang.StringUtils.isEmpty(ssn) && primarySSN != null) {
try {
this.identifierChangeService.change(person.getPrimaryIdentifiersByType().get("SSN"), ssn);
} catch (IllegalArgumentException e) {
logger.debug(e.getStackTrace().toString());
} // all other exception should be propogated
}
person.setDateOfBirth(birthDate);
person.setGender(gender);
person.getPreferredContactEmailAddress().update(emailAddress);
person.getPreferredContactPhoneNumber().update(phone);
person.calculateDisclosureSettings(disclosure);
person.setAttributes(attributes);
String affiliation = "";
Type affiliationType = null;
if (disclosure != null) {
logger.info(
"after person.calculateDisclosureSettings, disclosure code : "
+ disclosure.getDisclosureCode());
} else {
logger.info("Disclosure is null");
}
List<SorRole> sorroles = sorPerson.getRoles();
for (SorRole role : sorroles) {
if (role != null) {
logger.info("Role = " + role.getTitle());
if (role.getAffiliationType() != null) {
logger.info("Role desc= " + role.getAffiliationType().getDescription());
affiliation = role.getAffiliationType().getDescription();
if (person.getDisclosureSettings() != null) {
logger.info("recalculating disclosure setting 1...");
// person.getDisclosureSettings().recalculate(this.strategyRepository.getDisclosureRecalculationStrategy());
person
.getDisclosureSettings()
.recalculate(
this.strategyRepository.getDisclosureRecalculationStrategy(),
affiliation,
referenceRepository);
}
}
}
}
// SSN election is happening in the ssn identifier assigner.
boolean preferred = false;
boolean official = false;
for (final Name name : person.getNames()) {
if (!preferred && name.sameAs(preferredName)) {
name.setPreferredName(true);
preferred = true;
}
if (!official && name.sameAs(officialName)) {
name.setOfficialName(true);
official = true;
}
if (official && preferred) {
break;
}
}
logger.info("recalculatePersonBiodemInfo: end");
// return this.personRepository.savePerson(person);
return person;
}
/**
* Validate message with a XML schema.
*
* @param receivedMessage
* @param validationContext
*/
protected void validateXMLSchema(
Message receivedMessage, XmlMessageValidationContext validationContext) {
if (receivedMessage.getPayload() == null
|| !StringUtils.hasText(receivedMessage.getPayload(String.class))) {
return;
}
try {
Document doc = XMLUtils.parseMessagePayload(receivedMessage.getPayload(String.class));
if (!StringUtils.hasText(doc.getFirstChild().getNamespaceURI())) {
return;
}
log.info("Starting XML schema validation ...");
XmlValidator validator = null;
XsdSchemaRepository schemaRepository = null;
if (validationContext.getSchema() != null) {
validator =
applicationContext
.getBean(validationContext.getSchema(), XsdSchema.class)
.createValidator();
} else if (validationContext.getSchemaRepository() != null) {
schemaRepository =
applicationContext.getBean(
validationContext.getSchemaRepository(), XsdSchemaRepository.class);
} else if (schemaRepositories.size() == 1) {
schemaRepository = schemaRepositories.get(0);
} else if (schemaRepositories.size() > 0) {
for (XsdSchemaRepository repository : schemaRepositories) {
if (repository.canValidate(doc)) {
schemaRepository = repository;
}
}
if (schemaRepository == null) {
throw new CitrusRuntimeException(
String.format(
"Failed to find proper schema repository in Spring bean context for validating element '%s(%s)'",
doc.getFirstChild().getLocalName(), doc.getFirstChild().getNamespaceURI()));
}
} else {
log.warn(
"Neither schema instance nor schema repository defined - skipping XML schema validation");
return;
}
if (schemaRepository != null) {
if (!schemaRepository.canValidate(doc)) {
throw new CitrusRuntimeException(
String.format(
"Unable to find proper XML schema definition for element '%s(%s)' in schema repository '%s'",
doc.getFirstChild().getLocalName(),
doc.getFirstChild().getNamespaceURI(),
schemaRepository.getName()));
}
List<Resource> schemas = new ArrayList<>();
for (XsdSchema xsdSchema : schemaRepository.getSchemas()) {
if (xsdSchema instanceof XsdSchemaCollection) {
for (Resource resource : ((XsdSchemaCollection) xsdSchema).getSchemaResources()) {
schemas.add(resource);
}
} else if (xsdSchema instanceof WsdlXsdSchema) {
for (Resource resource : ((WsdlXsdSchema) xsdSchema).getSchemaResources()) {
schemas.add(resource);
}
} else {
synchronized (transformerFactory) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
transformerFactory
.newTransformer()
.transform(xsdSchema.getSource(), new StreamResult(bos));
} catch (TransformerException e) {
throw new CitrusRuntimeException(
"Failed to read schema " + xsdSchema.getTargetNamespace(), e);
}
schemas.add(new ByteArrayResource(bos.toByteArray()));
}
}
}
validator =
XmlValidatorFactory.createValidator(
schemas.toArray(new Resource[schemas.size()]), WsdlXsdSchema.W3C_XML_SCHEMA_NS_URI);
}
SAXParseException[] results = validator.validate(new DOMSource(doc));
if (results.length == 0) {
log.info("Schema of received XML validated OK");
} else {
log.error(
"Schema validation failed for message:\n"
+ XMLUtils.prettyPrint(receivedMessage.getPayload(String.class)));
// Report all parsing errors
log.debug("Found " + results.length + " schema validation errors");
StringBuilder errors = new StringBuilder();
for (SAXParseException e : results) {
errors.append(e.toString());
errors.append("\n");
}
log.debug(errors.toString());
throw new ValidationException("Schema validation failed:", results[0]);
}
} catch (IOException e) {
throw new CitrusRuntimeException(e);
} catch (SAXException e) {
throw new CitrusRuntimeException(e);
}
}
