@Test
public void shouldSaveNewDrugOrdersInTheSequenceOfOrderingToAnEncounterWithExistingOrders()
throws ParseException {
EmrOrderServiceImpl_1_10 emrOrderService =
new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper);
EncounterTransaction.DrugOrder drugOrder3 =
new DrugOrderBuilder().withDrugUuid("drug-uuid3").build();
EncounterTransaction.DrugOrder drugOrder4 =
new DrugOrderBuilder().withDrugUuid("drug-uuid4").build();
DrugOrder existingDrugOrder1 = new DrugOrder();
DrugOrder existingDrugOrder2 = new DrugOrder();
DrugOrder mappedDrugOrder3 = new DrugOrder();
DrugOrder mappedDrugOrder4 = new DrugOrder();
Encounter encounter = new Encounter();
encounter.addOrder(existingDrugOrder1);
encounter.addOrder(existingDrugOrder2);
when(openMRSDrugOrderMapper.map(drugOrder3, encounter)).thenReturn(mappedDrugOrder3);
when(openMRSDrugOrderMapper.map(drugOrder4, encounter)).thenReturn(mappedDrugOrder4);
emrOrderService.save(Arrays.asList(drugOrder3, drugOrder4), encounter);
ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class);
verify(encounterService).saveEncounter(encounterArgumentCaptor.capture());
Encounter savedEncounter = encounterArgumentCaptor.getValue();
ArrayList<org.openmrs.Order> savedOrders =
new ArrayList<org.openmrs.Order>(savedEncounter.getOrders());
assertThat(savedOrders.size(), is(4));
assertThat((DrugOrder) savedOrders.get(2), is(sameInstance(mappedDrugOrder3)));
assertThat((DrugOrder) savedOrders.get(3), is(sameInstance(mappedDrugOrder4)));
}
private Encounter buildEncounter(
EncounterType encounterType,
Patient patient,
Location location,
Form form,
Date when,
List<Obs> obsToCreate,
List<Order> ordersToCreate) {
Encounter encounter = new Encounter();
encounter.setPatient(patient);
encounter.setEncounterType(encounterType);
encounter.setLocation(location);
encounter.setForm(form);
encounter.setEncounterDatetime(when);
if (obsToCreate != null) {
for (Obs obs : obsToCreate) {
obs.setObsDatetime(new Date());
encounter.addObs(obs);
}
}
if (ordersToCreate != null) {
for (Order order : ordersToCreate) {
encounter.addOrder(order);
}
}
return encounter;
}
@Test
@Verifies(
value = "should return encounter with all child objects voided according to schema",
method = "voidEncounterByHtmlFormSchema")
public void testVoidEncounterByHtmlFormSchema_shouldHandleDrugOrderCorrectly() throws Exception {
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
Encounter e = new Encounter();
e.setPatient(Context.getPatientService().getPatient(2));
Date date = Context.getDateFormat().parse("01/02/2003");
e.setDateCreated(new Date());
e.setEncounterDatetime(date);
e.setLocation(Context.getLocationService().getLocation(2));
e.setProvider(Context.getPersonService().getPerson(502));
TestUtil.addObs(e, 1, 5000, date); // a matching obs
DrugOrder dor = new DrugOrder();
dor.setVoided(false);
dor.setConcept(Context.getConceptService().getConcept(792));
dor.setCreator(Context.getUserService().getUser(1));
dor.setDateCreated(new Date());
dor.setDiscontinued(false);
dor.setDrug(Context.getConceptService().getDrug(2));
dor.setOrderType(Context.getOrderService().getOrderType(1));
dor.setPatient(Context.getPatientService().getPatient(2));
dor.setStartDate(new Date());
e.addOrder(dor);
Context.getEncounterService().saveEncounter(e);
Form form = new Form();
HtmlForm htmlform = new HtmlForm();
htmlform.setForm(form);
form.setEncounterType(new EncounterType());
htmlform.setDateChanged(new Date());
htmlform.setXmlData(
new TestUtil()
.loadXmlFromFile(
XML_DATASET_PATH + "returnSectionsAndConceptsInSectionsTestFormWithGroups.xml"));
HtmlFormEntryUtil.voidEncounterByHtmlFormSchema(e, htmlform, "test void reason");
// this is going to test out the voided state of the obs in the encounter after processing:
// order was matched, so order was voided, and because that's the only thing in the encounter,
// encounter was voided too.
Assert.assertTrue(e.isVoided());
Assert.assertTrue(e.getVoidReason().equals("test void reason"));
for (Order o : e.getOrders()) {
Assert.assertTrue(o.isVoided());
Assert.assertTrue(o.getVoidReason().equals("test void reason"));
}
for (Obs o : e.getAllObs(true)) {
Assert.assertTrue(o.getVoidReason().equals("test void reason"));
}
}
@Test
@Verifies(value = "should delete encounter correctly", method = "voidEncounterByHtmlFormSchema")
public void testVoidEncounterByHtmlFormSchema_shouldDeleteEncounter() throws Exception {
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
Encounter e = new Encounter();
e.setPatient(Context.getPatientService().getPatient(2));
Date date = Context.getDateFormat().parse("01/02/2003");
e.setDateCreated(new Date());
e.setEncounterDatetime(date);
e.setLocation(Context.getLocationService().getLocation(2));
e.setProvider(Context.getPersonService().getPerson(502));
TestUtil.addObs(e, 3, 5000, date); // adding an un-matched, voided Obs
for (Obs o : e.getAllObs(true)) {
o.setVoided(true);
o.setVoidedBy(Context.getUserService().getUser(1));
o.setVoidReason("blah");
o.setDateVoided(new Date());
}
// and adding a voided drug order
DrugOrder dor = new DrugOrder();
dor.setVoided(false);
dor.setConcept(Context.getConceptService().getConcept(792));
dor.setCreator(Context.getUserService().getUser(1));
dor.setDateCreated(new Date());
dor.setDiscontinued(false);
dor.setDrug(Context.getConceptService().getDrug(2));
dor.setOrderType(Context.getOrderService().getOrderType(1));
dor.setPatient(Context.getPatientService().getPatient(2));
dor.setVoided(true);
dor.setVoidedBy(Context.getUserService().getUser(1));
dor.setVoidReason("blah");
dor.setDateVoided(new Date());
dor.setStartDate(new Date());
e.addOrder(dor);
Context.getEncounterService().saveEncounter(e);
Form form = new Form();
HtmlForm htmlform = new HtmlForm();
htmlform.setForm(form);
form.setEncounterType(new EncounterType());
htmlform.setDateChanged(new Date());
htmlform.setXmlData(
new TestUtil()
.loadXmlFromFile(
XML_DATASET_PATH + "returnSectionsAndConceptsInSectionsTestFormWithGroups.xml"));
HtmlFormEntryUtil.voidEncounterByHtmlFormSchema(e, htmlform, null);
// encounter had no non-voided objects, should be voided
Assert.assertTrue(e.isVoided());
}
@Test
@Verifies(
value = "should return encounter with all child objects voided according to schema",
method = "voidEncounterByHtmlFormSchema")
public void testVoidEncounterByHtmlFormSchema_shouldHandleDrugOrderAndObsCorrectly()
throws Exception {
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
Encounter e = new Encounter();
e.setPatient(Context.getPatientService().getPatient(2));
Date date = Context.getDateFormat().parse("01/02/2003");
e.setDateCreated(new Date());
e.setEncounterDatetime(date);
e.setLocation(Context.getLocationService().getLocation(2));
e.setProvider(Context.getPersonService().getPerson(502));
TestUtil.addObs(e, 3, 5000, date); // adding an un-matched Obs
DrugOrder dor = new DrugOrder();
dor.setVoided(false);
dor.setConcept(Context.getConceptService().getConcept(792));
dor.setCreator(Context.getUserService().getUser(1));
dor.setDateCreated(new Date());
dor.setDiscontinued(false);
dor.setDrug(Context.getConceptService().getDrug(2));
dor.setOrderType(Context.getOrderService().getOrderType(1));
dor.setPatient(Context.getPatientService().getPatient(2));
dor.setStartDate(new Date());
e.addOrder(dor);
Context.getEncounterService().saveEncounter(e);
Form form = new Form();
HtmlForm htmlform = new HtmlForm();
htmlform.setForm(form);
form.setEncounterType(new EncounterType());
htmlform.setDateChanged(new Date());
htmlform.setXmlData(
new TestUtil()
.loadXmlFromFile(
XML_DATASET_PATH + "returnSectionsAndConceptsInSectionsTestFormWithGroups.xml"));
HtmlFormEntryUtil.voidEncounterByHtmlFormSchema(e, htmlform, null);
// order was matched, obs was not, so order should be voided, obs not, encounter not.
Assert.assertTrue(!e.isVoided());
for (Order o : e.getOrders()) {
Assert.assertTrue(o.isVoided());
}
for (Obs o : e.getObs()) {
Assert.assertTrue(!o.isVoided());
}
}
@Test
public void shouldSaveOrdersToEncounterWithExistingOrders() throws ParseException {
EmrOrderServiceImpl_1_10 emrOrderService =
new EmrOrderServiceImpl_1_10(openMRSDrugOrderMapper, encounterService, openMRSOrderMapper);
EncounterTransaction.Order order1 =
new OrderBuilder().withConceptUuid("concept-uuid1").withComment("Comment").build();
EncounterTransaction.Order order2 =
new OrderBuilder().withConceptUuid("concept-uuid2").withComment("Comment").build();
Order mappedOrder1 = new Order();
Concept concept = new Concept();
concept.setUuid("concept-uuid1");
mappedOrder1.setConcept(concept);
mappedOrder1.setCommentToFulfiller("Comment");
Order mappedOrder2 = new Order();
concept = new Concept();
concept.setUuid("concept-uuid2");
mappedOrder2.setConcept(concept);
mappedOrder2.setCommentToFulfiller("Comment");
Order existingOrder1 = new Order();
Order existingOrder2 = new Order();
Encounter encounter = new Encounter();
encounter.addOrder(existingOrder1);
encounter.addOrder(existingOrder2);
when(openMRSOrderMapper.map(order1, encounter)).thenReturn(mappedOrder1);
when(openMRSOrderMapper.map(order2, encounter)).thenReturn(mappedOrder2);
emrOrderService.saveOrders(Arrays.asList(order1, order2), encounter);
ArgumentCaptor<Encounter> encounterArgumentCaptor = ArgumentCaptor.forClass(Encounter.class);
verify(encounterService).saveEncounter(encounterArgumentCaptor.capture());
Encounter savedEncounter = encounterArgumentCaptor.getValue();
ArrayList<org.openmrs.Order> savedOrders =
new ArrayList<org.openmrs.Order>(savedEncounter.getOrders());
assertThat(savedOrders.size(), is(4));
assertTrue(existsInOrdersList(mappedOrder1, savedOrders));
assertTrue(existsInOrdersList(mappedOrder2, savedOrders));
}
@RequestMapping(method = RequestMethod.POST)
public void savePatientInfo(
@RequestParam("patientId") Integer patientId,
@RequestParam(value = "encounterId", required = false) Integer encounterId,
HttpServletRequest request,
HttpServletResponse response)
throws ParseException, IOException {
Map<String, String> parameters = RegistrationWebUtils.optimizeParameters(request);
// get patient
Patient patient = Context.getPatientService().getPatient(patientId);
/*
* SAVE ENCOUNTER
*/
Encounter encounter = null;
if (encounterId != null) {
encounter = Context.getEncounterService().getEncounter(encounterId);
} else {
encounter = RegistrationWebUtils.createEncounter(patient, true);
// create OPD obs
Concept opdWardConcept =
Context.getConceptService().getConcept(RegistrationConstants.CONCEPT_NAME_OPD_WARD);
Concept selectedOPDConcept =
Context.getConceptService()
.getConcept(
Integer.parseInt(
parameters.get(RegistrationConstants.FORM_FIELD_PATIENT_OPD_WARD)));
Obs opd = new Obs();
opd.setConcept(opdWardConcept);
opd.setValueCoded(selectedOPDConcept);
encounter.addObs(opd);
// send patient to opd room/bloodbank
// harsh 5/10/2012 changed the way to get blood bank concept->shifted hardcoded dependency
// from id to name
// Concept bloodbankConcept = Context.getConceptService().getConcept(
// GlobalPropertyUtil.getInteger(RegistrationConstants.PROPERTY_BLOODBANK_CONCEPT_ID,
// 6425));
String bloodBankWardName =
GlobalPropertyUtil.getString(
RegistrationConstants.PROPERTY_BLOODBANK_OPDWARD_NAME, "Blood Bank Room");
// ghanshyam 03-sept-2013 Bug #394 [Blood bank]queue
String socn = new String(selectedOPDConcept.getName().toString());
String substringofsocn = socn.substring(0, 15);
if (!substringofsocn.equalsIgnoreCase(bloodBankWardName)) {
RegistrationWebUtils.sendPatientToOPDQueue(patient, selectedOPDConcept, true);
} else {
OrderType orderType = null;
String orderTypeName =
Context.getAdministrationService().getGlobalProperty("bloodbank.orderTypeName");
orderType = OrderUtil.getOrderTypeByName(orderTypeName);
Order order = new Order();
order.setConcept(selectedOPDConcept);
order.setCreator(Context.getAuthenticatedUser());
order.setDateCreated(new Date());
order.setOrderer(Context.getAuthenticatedUser());
order.setPatient(patient);
order.setStartDate(new Date());
order.setAccessionNumber("0");
order.setOrderType(orderType);
order.setEncounter(encounter);
encounter.addOrder(order);
}
}
// create temporary attributes
for (String name : parameters.keySet()) {
if ((name.contains(".attribute.")) && (!StringUtils.isBlank(parameters.get(name)))) {
String[] parts = name.split("\\.");
String idText = parts[parts.length - 1];
Integer id = Integer.parseInt(idText);
Concept tempCatConcept = Context.getConceptService().getConceptByName("TEMPORARY CATEGORY");
Concept temporaryAttributeConcept =
Context.getConceptService().getConcept(tempCatConcept.getConceptId());
Obs temporaryAttribute = new Obs();
temporaryAttribute.setConcept(temporaryAttributeConcept);
logger.info("concept: " + temporaryAttributeConcept);
logger.info("value: " + parameters.get(name));
temporaryAttribute.setValueAsString(parameters.get(name));
encounter.addObs(temporaryAttribute);
}
}
// save encounter
Context.getEncounterService().saveEncounter(encounter);
logger.info(
String.format(
"Save encounter for the visit of patient [encounterId=%s, patientId=%s]",
encounter.getId(), patient.getId()));
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.print("success");
}
