private void requireAppropriatePatientModificationPrivilege(Patient patient) { if (patient.getPatientId() == null) { Context.requirePrivilege(PrivilegeConstants.ADD_PATIENTS); } else { Context.requirePrivilege(PrivilegeConstants.EDIT_PATIENTS); } if (patient.getVoided()) { Context.requirePrivilege(PrivilegeConstants.DELETE_PATIENTS); } }
/** * @see org.openmrs.api.CohortService#notifyPatientVoided(org.openmrs.Patient) */ @Override public void notifyPatientVoided(Patient patient) throws APIException { List<CohortMembership> memberships = Context.getCohortService() .getCohortMemberships(patient.getPatientId(), null, false); memberships.forEach(m -> { m.setVoided(patient.getVoided()); m.setDateVoided(patient.getDateVoided()); m.setVoidedBy(patient.getVoidedBy()); m.setVoidReason(patient.getVoidReason()); dao.saveCohortMembership(m); }); }
/** * @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); }
/** * @see PatientService#unvoidPatient(Patient) */ @Test public void unvoidPatient_shouldUnvoidGivenPatient() throws Exception { Patient patient = Context.getPatientService().getPatient(2); Patient voidedPatient = Context.getPatientService().voidPatient(patient, "Void for testing"); Assert.assertTrue(voidedPatient.getVoided()); Assert.assertNotNull(voidedPatient.getVoidedBy()); Assert.assertNotNull(voidedPatient.getVoidReason()); Assert.assertNotNull(voidedPatient.getDateVoided()); Patient unvoidedPatient = Context.getPatientService().unvoidPatient(voidedPatient); Assert.assertFalse(unvoidedPatient.getVoided()); Assert.assertNull(unvoidedPatient.getVoidedBy()); Assert.assertNull(unvoidedPatient.getVoidReason()); Assert.assertNull(unvoidedPatient.getDateVoided()); }
public void checkPatientIdentifiers(Patient patient) throws PatientIdentifierException { if (!patient.getVoided() && patient.getActiveIdentifiers().isEmpty()) { throw new InsufficientIdentifiersException("At least one nonvoided Patient Identifier is required");
/** * @see PatientService#unvoidPatient(Patient) */ @Test public void unvoidPatient_shouldReturnUnvoidedPatient() throws Exception { Patient patient = Context.getPatientService().getPatient(2); Patient voidedPatient = Context.getPatientService().voidPatient(patient, "Void for testing"); Assert.assertTrue(voidedPatient.getVoided()); Assert.assertNotNull(voidedPatient.getVoidedBy()); Assert.assertNotNull(voidedPatient.getVoidReason()); Assert.assertNotNull(voidedPatient.getDateVoided()); Patient unvoidedPatient = Context.getPatientService().unvoidPatient(voidedPatient); Assert.assertFalse(unvoidedPatient.getVoided()); Assert.assertNull(unvoidedPatient.getVoidedBy()); Assert.assertNull(unvoidedPatient.getVoidReason()); Assert.assertNull(unvoidedPatient.getDateVoided()); }
@Test public void mergePatients_shouldMergeAllNonPreferredPatientsInTheTheNotPreferredListToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(6); List<Patient> notPreferred = new ArrayList<>(); notPreferred.add(patientService.getPatient(7)); notPreferred.add(patientService.getPatient(8)); voidOrders(notPreferred); patientService.mergePatients(preferred, notPreferred); Assert.assertFalse(patientService.getPatient(6).getVoided()); Assert.assertTrue(patientService.getPatient(7).getVoided()); Assert.assertTrue(patientService.getPatient(8).getVoided()); }
/** * @see PatientService#voidPatient(Patient,String) */ @Test public void voidPatient_shouldReturnVoidedPatientWithGivenReason() throws Exception { Patient patient = Context.getPatientService().getPatient(2); Patient voidedPatient = Context.getPatientService().voidPatient(patient, "Void for testing"); Assert.assertTrue(voidedPatient.getVoided()); Assert.assertNotNull(voidedPatient.getVoidedBy()); Assert.assertNotNull(voidedPatient.getVoidReason()); Assert.assertNotNull(voidedPatient.getDateVoided()); Assert.assertEquals("Void for testing", voidedPatient.getVoidReason()); }
Collection<PatientIdentifier> identifiers = patient.getVoided() ? patient.getIdentifiers() : patient .getActiveIdentifiers(); for (PatientIdentifier pi : identifiers) {
assertTrue(patient.getVoided()); new PatientDataUnvoidHandler().handle(patient, patient.getVoidedBy(), patient.getDateVoided(), null);
@Override public void validate(Object obj, Errors errors) { if (obj == null || !(obj instanceof Cohort)) { throw new IllegalArgumentException("The parameter obj should not be null and must be of type" + Cohort.class); } Cohort cohort = (Cohort) obj; if (!cohort.getVoided()) { Collection<CohortMembership> members = cohort.getMemberships(); if (!CollectionUtils.isEmpty(members)) { for (CohortMembership member : members) { Patient p = Context.getPatientService().getPatient(member.getPatientId()); int dateCompare = OpenmrsUtil.compareWithNullAsLatest(member.getStartDate(), member.getEndDate()); if (p != null && p.getVoided() && !member.getVoided()) { String message = "Patient " + p.getPatientId() + " is voided, cannot add voided members to a cohort"; errors.rejectValue("memberships", "Cohort.patientAndMemberShouldBeVoided", message); } if (dateCompare == 1) { String message = "Start date is null or end date is before start date"; errors.rejectValue("memberships", "Cohort.startDateShouldNotBeNullOrBeforeEndDate", message); } } } } } }
/** * @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()); } }
@SkipBaseSetup @Test public void getPatients_shouldNotReturnVoidedPatients() throws Exception { initializeInMemoryDatabase(); executeDataSet(FIND_PATIENTS_XML); authenticate(); // verify patient is voided assertTrue(patientService.getPatient(3).getVoided()); // ask for list of patients with this name, expect none back because // patient is voided List<Patient> patients = patientService.getPatients("I am voided", null, null, false); assertEquals(patients.size(), 0); }
/** * @see PatientService#voidPatient(Patient,String) */ @Test public void voidPatient_shouldVoidGivenPatientWithGivenReason() throws Exception { Patient patient = Context.getPatientService().getPatient(2); Patient voidedPatient = Context.getPatientService().voidPatient(patient, "Void for testing"); Assert.assertTrue(voidedPatient.getVoided()); Assert.assertEquals("Void for testing", voidedPatient.getVoidReason()); }
/** * Regression test for http://dev.openmrs.org/ticket/790 * * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldIgnoreVoidedPatients() throws Exception { { // patient 999 should be voided and have a non-voided identifier of // XYZ Patient p = patientService.getPatient(999); Assert.assertNotNull(p); Assert.assertTrue(p.getVoided()); boolean found = false; for (PatientIdentifier id : p.getIdentifiers()) { if (id.getIdentifier().equals("XYZ") && id.getIdentifierType().getId() == 2) { found = true; break; } } Assert.assertTrue(found); } PatientIdentifierType pit = patientService.getPatientIdentifierType(2); PatientIdentifier patientIdentifier = new PatientIdentifier("XYZ", pit, null); Assert.assertFalse(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
/** * @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()); }
public void handle_shouldVoidTheOrdersEncountersAndObservationsAssociatedWithThePatient() { Patient patient = Context.getPatientService().getPatient(7); Assert.assertFalse(patient.getVoided());
Patient patient = Context.getPatientService().getPatient(7); patient = Context.getPatientService().voidPatient(patient, "Void Reason"); assertTrue(patient.getVoided());
@Override public void validateDefaultRepresentation() throws Exception { super.validateDefaultRepresentation(); assertPropPresent("identifiers"); assertPropPresent("person"); assertPropEquals("voided", getObject().getVoided()); }
@Override public void validateFullRepresentation() throws Exception { super.validateFullRepresentation(); assertPropPresent("identifiers"); assertPropPresent("person"); assertPropEquals("voided", getObject().getVoided()); assertPropPresent("auditInfo"); }