/** * Convenience method to remove the given identifier from this patient's list of identifiers. If * <code>patientIdentifier</code> is null, nothing is done. * * @param patientIdentifier the identifier to remove * @should remove identifier if exists */ public void removeIdentifier(PatientIdentifier patientIdentifier) { if (patientIdentifier != null) { getIdentifiers().remove(patientIdentifier); } }
/** * @see org.openmrs.api.handler.SaveHandler#handle(org.openmrs.OpenmrsObject, org.openmrs.User, * java.util.Date, java.lang.String) */ @Override public void handle(Patient patient, User creator, Date dateCreated, String other) { if (patient.getIdentifiers() != null) { for (PatientIdentifier pIdentifier : patient.getIdentifiers()) { // make sure the identifier is associated with the current patient if (pIdentifier.getPatient() == null) { pIdentifier.setPatient(patient); } } } } }
/** * Returns only the non-voided identifiers for this patient. If you want <u>all</u> identifiers, * use {@link #getIdentifiers()} * * @return list of non-voided identifiers for this patient * @see #getIdentifiers() * @should return preferred identifiers first in the list */ public List<PatientIdentifier> getActiveIdentifiers() { List<PatientIdentifier> ids = new ArrayList<>(); List<PatientIdentifier> nonPreferred = new LinkedList<>(); for (PatientIdentifier pi : getIdentifiers()) { if (!pi.getVoided()) { if (pi.getPreferred()) { ids.add(pi); } else { nonPreferred.add(pi); } } } ids.addAll(nonPreferred); return ids; }
/** * Returns only the non-voided identifiers for this patient. If you want <u>all</u> identifiers, * use {@link #getIdentifiers()} * * @return list of non-voided identifiers for this patient * @param pit PatientIdentifierType * @see #getIdentifiers() */ public List<PatientIdentifier> getPatientIdentifiers(PatientIdentifierType pit) { List<PatientIdentifier> ids = new ArrayList<>(); for (PatientIdentifier pi : getIdentifiers()) { if (!pi.getVoided() && pit.equals(pi.getIdentifierType())) { ids.add(pi); } } return ids; }
/** * Returns the first (preferred) patient identifier matching <code>identifierTypeId</code> * * @param identifierTypeId * @return preferred patient identifier */ public PatientIdentifier getPatientIdentifier(Integer identifierTypeId) { if (!getIdentifiers().isEmpty()) { for (PatientIdentifier id : getIdentifiers()) { if (id.getPreferred() && !id.getVoided() && identifierTypeId.equals(id.getIdentifierType().getPatientIdentifierTypeId())) { return id; } } for (PatientIdentifier id : getIdentifiers()) { if (!id.getVoided() && identifierTypeId.equals(id.getIdentifierType().getPatientIdentifierTypeId())) { return id; } } return null; } return null; }
/** * Returns the (preferred) patient identifier matching <code>identifierTypeName</code> Otherwise * returns that last <code>PatientIdenitifer</code> * * @param identifierTypeName * @return preferred patient identifier */ public PatientIdentifier getPatientIdentifier(String identifierTypeName) { if (!getIdentifiers().isEmpty()) { for (PatientIdentifier id : getIdentifiers()) { if (id.getPreferred() && !id.getVoided() && identifierTypeName.equals(id.getIdentifierType().getName())) { return id; } } for (PatientIdentifier id : getIdentifiers()) { if (!id.getVoided() && identifierTypeName.equals(id.getIdentifierType().getName())) { return id; } } return null; } return null; }
/** * Returns the first (preferred) patient identifier matching a * <code>PatientIdentifierType</code> Otherwise, returns the first non-voided identifier * Otherwise, null * * @param pit The PatientIdentifierType of which to return the PatientIdentifier * @return Returns a PatientIdentifier of the specified type. */ public PatientIdentifier getPatientIdentifier(PatientIdentifierType pit) { if (!getIdentifiers().isEmpty()) { for (PatientIdentifier id : getIdentifiers()) { if (id.getPreferred() && !id.getVoided() && pit.equals(id.getIdentifierType())) { return id; } } for (PatientIdentifier id : getIdentifiers()) { if (!id.getVoided() && pit.equals(id.getIdentifierType())) { return id; } } return null; } return null; }
/** * This constructor creates a new Patient object from the given {@link Patient} object. All * attributes are copied over to the new object. In effect creating a clone/duplicate. * <br> * * @param patient the person object to copy onto a new Patient * @since 2.2.0 */ public Patient(Patient patient){ super(patient); this.patientId = patient.getPatientId(); this.allergyStatus = patient.getAllergyStatus(); Set<PatientIdentifier> newIdentifiers = new TreeSet<>(); for (PatientIdentifier pid : patient.getIdentifiers()) { PatientIdentifier identifierClone = (PatientIdentifier) pid.clone(); identifierClone.setPatient(this); newIdentifiers.add(identifierClone); } this.identifiers = newIdentifiers; }
/** * Will add this PatientIdentifier if the patient doesn't contain it already * * @param patientIdentifier * @should not fail with null identifiers list * @should add identifier to current list * @should not add identifier that is in list already */ public void addIdentifier(PatientIdentifier patientIdentifier) { if (patientIdentifier != null) { patientIdentifier.setPatient(this); // make sure the set doesn't already contain an identifier with the same // identifier, identifierType for (PatientIdentifier currentId : getActiveIdentifiers()) { if (currentId.equalsContent(patientIdentifier)) { // fail silently if someone tries to add a duplicate return; } } } getIdentifiers().add(patientIdentifier); }
private void setPreferredPatientIdentifier(Patient patient) { PatientIdentifier preferredIdentifier = null; PatientIdentifier possiblePreferredId = patient.getPatientIdentifier(); if (possiblePreferredId != null && possiblePreferredId.getPreferred() && !possiblePreferredId.getVoided()) { preferredIdentifier = possiblePreferredId; } for (PatientIdentifier id : patient.getIdentifiers()) { if (preferredIdentifier == null && !id.getVoided()) { id.setPreferred(true); preferredIdentifier = id; continue; } if (!id.equals(preferredIdentifier)) { id.setPreferred(false); } } }
/** * @see org.openmrs.api.PatientService#savePatient(org.openmrs.Patient) */ @Override public Patient savePatient(Patient patient) throws APIException { requireAppropriatePatientModificationPrivilege(patient); if (!patient.getVoided() && patient.getIdentifiers().size() == 1) { patient.getPatientIdentifier().setPreferred(true); } if (!patient.getVoided()) { checkPatientIdentifiers(patient); } setPreferredPatientIdentifier(patient); setPreferredPatientName(patient); setPreferredPatientAddress(patient); return dao.savePatient(patient); }
@Test public void savePatient_shouldFailWhenPatientDoesNotHaveAnyPatientIdentifiers() throws Exception { Patient patient = new Patient(); // a sanity check first assertTrue(patient.getIdentifiers().isEmpty()); try { patientService.savePatient(patient); Assert.fail("should fail when patient does not have any patient identifiers"); } catch (Exception e) {} }
/** * @see Patient#addIdentifier(PatientIdentifier) */ @Test public void addIdentifier_shouldNotAddIdentifierThatIsInListAlready() { Patient p = new Patient(); assertNotNull(p.getIdentifiers()); PatientIdentifier pa1 = new PatientIdentifier(); pa1.setIdentifier("firsttest"); pa1.setIdentifierType(new PatientIdentifierType(1)); pa1.setDateCreated(new Date()); pa1.setVoided(false); p.addIdentifier(pa1); // adding the same identifier should not increment the size p.addIdentifier(pa1); assertTrue( "There should be 1 identifier in the patient object but there is actually : " + p.getIdentifiers().size(), p .getIdentifiers().size() == 1); }
/** * @see Patient#getIdentifiers() */ @Test public void getIdentifiers_shouldNotReturnNull() { Patient p = new Patient(); p.setIdentifiers(null); Assert.assertNotNull(p.getIdentifiers()); }
/** * @see PatientService#mergePatients(Patient, Patient) */ @Test public void mergePatients_shouldCopyNonvoidedIdentifiersToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(7); Patient notPreferred = patientService.getPatient(8); PatientIdentifier nonvoidedPI = null; PatientIdentifier voidedPI = null; for (PatientIdentifier patientIdentifier : notPreferred.getIdentifiers()) { if (patientIdentifier.getIdentifier().equals("7TU-8")) { nonvoidedPI = patientIdentifier; } if (patientIdentifier.getIdentifier().equals("ABC123")) { voidedPI = patientIdentifier; } } patientService.mergePatients(preferred, notPreferred); Assert.assertNotNull(nonvoidedPI); Assert.assertTrue(contains(new ArrayList<>(preferred.getIdentifiers()), nonvoidedPI.getIdentifier())); Assert.assertNotNull(voidedPI); Assert.assertFalse(contains(new ArrayList<>(preferred.getIdentifiers()), voidedPI.getIdentifier())); }
/** * @see PatientService#checkPatientIdentifiers(Patient) */ @Test public void checkPatientIdentifiers_shouldRemovePatientIdentifierGivenItIsBlank() throws Exception { // given Patient patient = new Patient(); PatientIdentifier blankPatientIdentifier = new PatientIdentifier(); blankPatientIdentifier.setIdentifier(""); blankPatientIdentifier.setIdentifierType(new PatientIdentifierType(21345)); blankPatientIdentifier.setIdentifierType(Context.getPatientService().getAllPatientIdentifierTypes(false).get(0)); patient.addIdentifier(blankPatientIdentifier); assertEquals(1, patient.getIdentifiers().size()); try { // when Context.getPatientService().checkPatientIdentifiers(patient); // then fail("should throw BlankIdentifierException"); } catch (BlankIdentifierException e) { assertEquals(0, patient.getIdentifiers().size()); } }
/** * @see PatientService#getPatientIdentifiers(String,List,List,List,Boolean) */ @Test public void getPatientIdentifiers_shouldReturnOnlyNonVoidedPatientsAndPatientIdentifiers() throws Exception { // sanity check. make sure there is at least one voided patient Patient patient = patientService.getPatient(999); Assert.assertTrue("This patient should be voided", patient.getVoided()); Assert.assertFalse("This test expects the patient to be voided BUT the identifier to be NONvoided", ((PatientIdentifier) (patient.getIdentifiers().toArray()[0])).getVoided()); // now fetch all identifiers List<PatientIdentifier> patientIdentifiers = patientService.getPatientIdentifiers(null, null, null, null, null); for (PatientIdentifier patientIdentifier : patientIdentifiers) { Assert.assertFalse("No voided identifiers should be returned", patientIdentifier.getVoided()); Assert.assertFalse("No identifiers of voided patients should be returned", patientIdentifier.getPatient() .getVoided()); } }
/** * @see PatientValidator#validate(Object,Errors) */ @Test public void validate_shouldFailValidationIfAPreferredPatientIdentifierIsNotChosen() { Patient pa = Context.getPatientService().getPatient(2); Assert.assertNotNull(pa.getPatientIdentifier()); //set all identifiers to be non-preferred for (PatientIdentifier id : pa.getIdentifiers()) id.setPreferred(false); Errors errors = new BindException(pa, "patient"); validator.validate(pa, errors); Assert.assertTrue(errors.hasErrors()); }
/** * @see PatientValidator#validate(Object,Errors) */ @Test public void validate_shouldFailValidationIfAPreferredPatientIdentifierIsNotChosenForVoidedPatients() { Patient pa = Context.getPatientService().getPatient(432); Assert.assertTrue(pa.getVoided());//sanity check Assert.assertNotNull(pa.getPatientIdentifier()); for (PatientIdentifier id : pa.getIdentifiers()) id.setPreferred(false); Errors errors = new BindException(pa, "patient"); validator.validate(pa, errors); Assert.assertTrue(errors.hasErrors()); }
/** * @see PatientService#voidPatient(Patient,String) */ @Test public void voidPatient_shouldVoidAllPatientIdentifiersAssociatedWithGivenPatient() throws Exception { Patient patient = Context.getPatientService().getPatient(2); Patient voidedPatient = Context.getPatientService().voidPatient(patient, "Void for testing"); for (PatientIdentifier patientIdentifier : voidedPatient.getIdentifiers()) { Assert.assertTrue(patientIdentifier.getVoided()); Assert.assertNotNull(patientIdentifier.getVoidedBy()); Assert.assertNotNull(patientIdentifier.getVoidReason()); Assert.assertNotNull(patientIdentifier.getDateVoided()); } }