use of org.openmrs.PatientIdentifier in project openmrs-core by openmrs.
the class HibernatePatientDAOTest method getPatientIdentifiers_shouldGetByIdentifierType.
@Test
public void getPatientIdentifiers_shouldGetByIdentifierType() {
List<PatientIdentifierType> identifierTypes = singletonList(new PatientIdentifierType(2));
List<PatientIdentifier> identifiers = hibernatePatientDao.getPatientIdentifiers(null, identifierTypes, emptyList(), emptyList(), null);
List<Integer> identifierIds = identifiers.stream().map(PatientIdentifier::getId).collect(Collectors.toList());
Assert.assertEquals(2, identifiers.size());
Assert.assertThat(identifierIds, hasItems(1, 3));
}
use of org.openmrs.PatientIdentifier in project openmrs-core by openmrs.
the class HL7ServiceImpl method resolvePersonFromIdentifiers.
/**
* @param identifiers CX identifier list from an identifier (either PID or NK1)
* @return The internal id number of the Patient based on one of the given identifiers, or null
* if the patient is not found
* @throws HL7Exception
*/
@Override
@Transactional(readOnly = true)
public Person resolvePersonFromIdentifiers(CX[] identifiers) throws HL7Exception {
// give up if no identifiers exist
if (identifiers.length < 1) {
throw new HL7Exception("Missing patient identifier in PID segment");
}
// Take the first uniquely matching identifier
for (CX identifier : identifiers) {
String hl7PersonId = identifier.getIDNumber().getValue();
// TODO if 1st component is blank, check 2nd and 3rd of assigning
// authority
String assigningAuthority = identifier.getAssigningAuthority().getNamespaceID().getValue();
if (StringUtils.isNotBlank(assigningAuthority)) {
// Assigning authority defined
try {
PatientIdentifierType pit = Context.getPatientService().getPatientIdentifierTypeByName(assigningAuthority);
if (pit == null) {
// there is no matching PatientIdentifierType
if (assigningAuthority.equals(HL7Constants.HL7_AUTHORITY_UUID)) {
// the identifier is a UUID
Person p = Context.getPersonService().getPersonByUuid(hl7PersonId);
if (p != null) {
return p;
}
log.warn("Can't find person for UUID '" + hl7PersonId + "'");
// skip identifiers with unknown type
continue;
} else if (assigningAuthority.equals(HL7Constants.HL7_AUTHORITY_LOCAL)) {
// the ID is internal (local)
String idType = identifier.getIdentifierTypeCode().getValue();
try {
if (idType.equals(HL7Constants.HL7_ID_PERSON)) {
Integer pid = Integer.parseInt(hl7PersonId);
// patient_id == person_id, so just look for
// the person
Person p = Context.getPersonService().getPerson(pid);
if (p != null) {
return p;
}
} else if (idType.equals(HL7Constants.HL7_ID_PATIENT)) {
Integer pid = Integer.parseInt(hl7PersonId);
// patient_id == person_id, so just look for
// the person
Patient p = Context.getPatientService().getPatient(pid);
if (p != null) {
return p;
}
}
} catch (NumberFormatException e) {
}
log.warn("Can't find Local identifier of '" + hl7PersonId + "'");
// skip identifiers with unknown type
continue;
}
log.warn("Can't find PatientIdentifierType named '" + assigningAuthority + "'");
// skip identifiers with unknown type
continue;
}
List<PatientIdentifier> matchingIds = Context.getPatientService().getPatientIdentifiers(hl7PersonId, Collections.singletonList(pit), null, null, null);
if (matchingIds == null || matchingIds.isEmpty()) {
// no matches
log.warn("NO matches found for " + hl7PersonId);
// try next identifier
continue;
} else if (matchingIds.size() == 1) {
// unique match -- we're done
return matchingIds.get(0).getPatient();
} else {
// ambiguous identifier
log.debug("Ambiguous identifier in PID. " + matchingIds.size() + " matches for identifier '" + hl7PersonId + "' of type '" + pit + "'");
// try next identifier
continue;
}
} catch (Exception e) {
log.error("Error resolving patient identifier '" + hl7PersonId + "' for assigning authority '" + assigningAuthority + "'", e);
continue;
}
} else {
try {
log.debug("CX contains ID '" + hl7PersonId + "' without assigning authority -- assuming patient.patient_id");
return Context.getPatientService().getPatient(Integer.parseInt(hl7PersonId));
} catch (NumberFormatException e) {
log.warn("Invalid patient ID '" + hl7PersonId + "'");
}
}
}
return null;
}
use of org.openmrs.PatientIdentifier in project openmrs-core by openmrs.
the class HL7ServiceImpl method createPersonFromNK1.
/**
* @see org.openmrs.hl7.HL7Service#createPersonFromNK1(ca.uhn.hl7v2.model.v25.segment.NK1)
*/
@Override
public Person createPersonFromNK1(NK1 nk1) throws HL7Exception {
// NOTE: following block (with minor modifications) stolen from
// ADTA28Handler
// TODO: generalize this for use with both PID and NK1 segments
Person person = new Person();
// UUID
CX[] identifiers = nk1.getNextOfKinAssociatedPartySIdentifiers();
String uuid = getUuidFromIdentifiers(identifiers);
if (Context.getPersonService().getPersonByUuid(uuid) != null) {
throw new HL7Exception("Non-unique UUID '" + uuid + "' for new person");
}
person.setUuid(uuid);
// Patient Identifiers
List<PatientIdentifier> goodIdentifiers = new ArrayList<>();
for (CX id : identifiers) {
String assigningAuthority = id.getAssigningAuthority().getNamespaceID().getValue();
String hl7PatientId = id.getIDNumber().getValue();
log.debug("identifier has id=" + hl7PatientId + " assigningAuthority=" + assigningAuthority);
if (assigningAuthority != null && assigningAuthority.length() > 0) {
try {
PatientIdentifierType pit = Context.getPatientService().getPatientIdentifierTypeByName(assigningAuthority);
if (pit == null) {
if (!"UUID".equals(assigningAuthority)) {
log.warn("Can't find PatientIdentifierType named '" + assigningAuthority + "'");
}
// skip identifiers with unknown type
continue;
}
PatientIdentifier pi = new PatientIdentifier();
pi.setIdentifierType(pit);
pi.setIdentifier(hl7PatientId);
// Get default location
Location location = Context.getLocationService().getDefaultLocation();
if (location == null) {
throw new HL7Exception("Cannot find default location");
}
pi.setLocation(location);
try {
PatientIdentifierValidator.validateIdentifier(pi);
goodIdentifiers.add(pi);
} catch (PatientIdentifierException ex) {
log.warn("Patient identifier in NK1 is invalid: " + pi, ex);
}
} catch (Exception e) {
log.error("Uncaught error parsing/creating patient identifier '" + hl7PatientId + "' for assigning authority '" + assigningAuthority + "'", e);
}
} else {
log.debug("NK1 contains identifier with no assigning authority");
continue;
}
}
if (!goodIdentifiers.isEmpty()) {
// If we have one identifier, set it as the preferred to make the validator happy.
if (goodIdentifiers.size() == 1) {
goodIdentifiers.get(0).setPreferred(true);
}
// cast the person as a Patient and add identifiers
person = new Patient(person);
((Patient) person).addIdentifiers(goodIdentifiers);
}
// Person names
for (XPN patientNameX : nk1.getNKName()) {
PersonName name = new PersonName();
name.setFamilyName(patientNameX.getFamilyName().getSurname().getValue());
name.setGivenName(patientNameX.getGivenName().getValue());
name.setMiddleName(patientNameX.getSecondAndFurtherGivenNamesOrInitialsThereof().getValue());
person.addName(name);
}
// Gender (checks for null, but not for 'M' or 'F')
String gender = nk1.getAdministrativeSex().getValue();
if (gender == null) {
throw new HL7Exception("Missing gender in an NK1 segment");
}
gender = gender.toUpperCase();
if (!OpenmrsConstants.GENDER().containsKey(gender)) {
throw new HL7Exception("Unrecognized gender: " + gender);
}
person.setGender(gender);
// Date of Birth
TS dateOfBirth = nk1.getDateTimeOfBirth();
if (dateOfBirth == null || dateOfBirth.getTime() == null || dateOfBirth.getTime().getValue() == null) {
throw new HL7Exception("Missing birth date in an NK1 segment");
}
person.setBirthdate(HL7Util.parseHL7Timestamp(dateOfBirth.getTime().getValue()));
// Estimated birthdate?
ID precisionTemp = dateOfBirth.getDegreeOfPrecision();
if (precisionTemp != null && precisionTemp.getValue() != null) {
String precision = precisionTemp.getValue().toUpperCase();
log.debug("The birthdate is estimated: " + precision);
if ("Y".equals(precision) || "L".equals(precision)) {
person.setBirthdateEstimated(true);
}
}
// save the new person or patient
if (person instanceof Patient) {
Context.getPatientService().savePatient((Patient) person);
} else {
Context.getPersonService().savePerson(person);
}
return person;
}
use of org.openmrs.PatientIdentifier in project openmrs-core by openmrs.
the class MigrationHelper method importRelationships.
/**
* Takes a list of Strings of the format RELATIONSHIP:<user last name>,<user first
* name>,<relationship type name>,<patient identifier type name>,<identifier> so if user hfraser
* if the cardiologist of the patient with patient_id 8039 in PIH's old emr, then:
* RELATIONSHIP:hfraser,Cardiologist,HIV-EMRV1,8039 (the "RELATIONSHIP:" is not actually
* necessary. Anything before and including the first : will be dropped If autoCreateUsers is
* true, and no user exists with the given username, one will be created. If autoAddRole is
* true, then whenever a user is auto-created, if a role exists with the same name as
* relationshipType.name, then the user will be added to that role
*/
public static int importRelationships(Collection<String> relationships, boolean autoCreateUsers, boolean autoAddRole) {
PatientService ps = Context.getPatientService();
UserService us = Context.getUserService();
PersonService personService = Context.getPersonService();
List<Relationship> relsToAdd = new ArrayList<>();
Random rand = new Random();
for (String s : relationships) {
if (s.contains(":")) {
s = s.substring(s.indexOf(":") + 1);
}
String[] ss = s.split(",");
if (ss.length < 5) {
throw new IllegalArgumentException("The line '" + s + "' is in the wrong format");
}
String userLastName = ss[0];
String userFirstName = ss[1];
String username = (userFirstName + userLastName).replaceAll(" ", "");
String relationshipType = ss[2];
String identifierType = ss[3];
String identifier = ss[4];
User user = null;
{
// first try looking for non-voided users
List<User> users = us.getUsersByName(userFirstName, userLastName, false);
if (users.size() == 1) {
user = users.get(0);
} else if (users.size() > 1) {
throw new IllegalArgumentException("Found " + users.size() + " users named '" + userLastName + ", " + userFirstName + "'");
}
}
if (user == null) {
// next try looking for voided users
List<User> users = us.getUsersByName(userFirstName, userLastName, false);
if (users.size() == 1) {
user = users.get(0);
} else if (users.size() > 1) {
throw new IllegalArgumentException("Found " + users.size() + " voided users named '" + userLastName + ", " + userFirstName + "'");
}
}
if (user == null && autoCreateUsers) {
user = new User();
user.setPerson(new Person());
PersonName pn = new PersonName(userFirstName, "", userLastName);
user.addName(pn);
user.setUsername(username);
// Generate a temporary password: 8-12 random characters
String pass;
{
int length = rand.nextInt(4) + 8;
char[] password = new char[length];
for (int x = 0; x < length; x++) {
int randDecimalAsciiVal = rand.nextInt(93) + 33;
password[x] = (char) randDecimalAsciiVal;
}
pass = new String(password);
}
if (autoAddRole) {
Role role = us.getRole(relationshipType);
if (role != null) {
user.addRole(role);
}
}
us.createUser(user, pass);
}
if (user == null) {
throw new IllegalArgumentException("Can't find user '" + userLastName + ", " + userFirstName + "'");
}
Person person = personService.getPerson(user.getUserId());
RelationshipType relationship = personService.getRelationshipTypeByName(relationshipType);
PatientIdentifierType pit = ps.getPatientIdentifierTypeByName(identifierType);
List<PatientIdentifier> found = ps.getPatientIdentifiers(identifier, Collections.singletonList(pit), null, null, null);
if (found.size() != 1) {
throw new IllegalArgumentException("Found " + found.size() + " patients with identifier '" + identifier + "' of type " + identifierType);
}
Person relative = personService.getPerson(found.get(0).getPatient().getPatientId());
Relationship rel = new Relationship();
rel.setPersonA(person);
rel.setRelationshipType(relationship);
rel.setPersonB(relative);
relsToAdd.add(rel);
}
int addedSoFar = 0;
for (Relationship rel : relsToAdd) {
personService.saveRelationship(rel);
++addedSoFar;
}
return addedSoFar;
}
use of org.openmrs.PatientIdentifier in project openmrs-core by openmrs.
the class PatientServiceTest method isIdentifierInUseByAnotherPatient_shouldReturnTrueIfInUseForALocationAndIdTypeUniquenessIsSetToLocation.
/**
* @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier)
*/
@Test
public void isIdentifierInUseByAnotherPatient_shouldReturnTrueIfInUseForALocationAndIdTypeUniquenessIsSetToLocation() throws Exception {
PatientIdentifier duplicateId = patientService.getPatientIdentifier(1);
Assert.assertNotNull(duplicateId.getLocation());
PatientIdentifierType idType = duplicateId.getIdentifierType();
idType.setUniquenessBehavior(UniquenessBehavior.LOCATION);
patientService.savePatientIdentifierType(idType);
PatientIdentifier pi = new PatientIdentifier(duplicateId.getIdentifier(), idType, duplicateId.getLocation());
Assert.assertTrue(patientService.isIdentifierInUseByAnotherPatient(pi));
}
Aggregations