/** @see org.openmrs.api.EncounterService#unvoidEncounter(org.openmrs.Encounter) */ public Encounter unvoidEncounter(Encounter encounter) throws APIException { // if authenticated user is not supposed to edit encounter of certain type if (!canEditEncounter(encounter, null)) { throw new APIException( "Encounter.error.privilege.required.unvoid", new Object[] {encounter.getEncounterType().getEditPrivilege()}); } String voidReason = encounter.getVoidReason(); if (voidReason == null) { voidReason = ""; } ObsService os = Context.getObsService(); for (Obs o : encounter.getObsAtTopLevel(true)) { if (voidReason.equals(o.getVoidReason())) { os.unvoidObs(o); } } OrderService orderService = Context.getOrderService(); for (Order o : encounter.getOrders()) { if (voidReason.equals(o.getVoidReason())) { orderService.unvoidOrder(o); } } encounter.setVoided(false); encounter.setVoidedBy(null); encounter.setDateVoided(null); encounter.setVoidReason(null); Context.getEncounterService().saveEncounter(encounter); return encounter; }
@Test public void shouldAddNewDrugOrderWhenPrnIsTrueWIthNoDosageFrequencyOrDosageInstruction() { EncounterTransaction.DrugOrder drugOrder = new DrugOrderBuilder() .withBasicValues("drug-uuid", "test-concept-uuid", today, today, 3, "", "") .withPrn(true) .build(); Concept drugConcept = new Concept(3); OrderType drugOrderType = new OrderType("Drug Order", "this is a drug order type"); when(orderService.getAllOrderTypes()).thenReturn(asList(drugOrderType)); when(conceptService.getConceptByUuid("test-concept-uuid")).thenReturn(drugConcept); Drug drug = new Drug(); drug.setName("test drug"); when(conceptService.getDrugByUuid("drug-uuid")).thenReturn(drug); encounterDrugOrderServiceHelper.update(encounter, asList(drugOrder)); assertThat(encounter.getOrders().size(), is(1)); org.openmrs.DrugOrder order = (org.openmrs.DrugOrder) encounter.getOrders().iterator().next(); assertEquals(drugConcept, order.getConcept()); assertEquals(drugOrderType, order.getOrderType()); assertEquals(patient, order.getPatient()); assertEquals(encounter, order.getEncounter()); assertEquals(today, order.getStartDate()); assertEquals(today, order.getAutoExpireDate()); assertEquals(drug.getDisplayName(), order.getDrug().getDisplayName()); assertEquals(Double.valueOf(3), order.getDose()); assertEquals(true, order.getPrn()); assertEquals(null, order.getFrequency()); assertEquals(null, order.getUnits()); }
@Test public void discontinueOrder() throws Exception { Provider provider = mock(Provider.class); handleEncounterProvider(provider); Order mrsOrder = new Order(); when(orderService.getOrderByUuid("previous order uuid")).thenReturn(mrsOrder); Date createdDate = new Date(); EncounterTransaction.Concept blood = new EncounterTransaction.Concept("bloodConceptUuid", "blood"); EncounterTransaction.Order etOrder = new OrderBuilder() .withAction(org.openmrs.Order.Action.DISCONTINUE.toString()) .withUuid("orderUuid") .withConcept(blood) .withPreviousOrderUuid("previous order uuid") .withDateCreated(createdDate) .build(); OpenMRSOrderMapper orderMapper = new OpenMRSOrderMapper(orderService, conceptService); Order order = orderMapper.map(etOrder, encounter); Assert.assertEquals(org.openmrs.Order.Action.DISCONTINUE, order.getAction()); }
@Test public void createRevisedOrderFromEtOrder() { Provider provider = mock(Provider.class); handleEncounterProvider(provider); Order originalOrder = new Order(); when(orderService.getOrderByUuid("previousOrderUuid")).thenReturn(originalOrder); Date currentDate = new Date(); EncounterTransaction.Order etOrder = new EncounterTransaction.Order(); etOrder.setUuid(null); etOrder.setPreviousOrderUuid("previousOrderUuid"); etOrder.setAutoExpireDate(currentDate); etOrder.setCommentToFulfiller("Comment"); OpenMRSOrderMapper orderMapper = new OpenMRSOrderMapper(orderService, conceptService); Order order = orderMapper.map(etOrder, encounter); verify(orderService).getOrderByUuid("previousOrderUuid"); Assert.assertEquals(encounter, order.getEncounter()); Assert.assertEquals("Comment", order.getCommentToFulfiller()); Assert.assertEquals(currentDate, order.getAutoExpireDate()); Assert.assertEquals(provider, order.getOrderer()); }
/** * @see org.openmrs.api.EncounterService#voidEncounter(org.openmrs.Encounter, java.lang.String) */ public Encounter voidEncounter(Encounter encounter, String reason) { // if authenticated user is not supposed to edit encounter of certain type if (!canEditEncounter(encounter, null)) { throw new APIException( String.format( "Privilege %s required to void encounters of this type", encounter.getEncounterType().getEditPrivilege())); } if (reason == null) { throw new IllegalArgumentException("The argument 'reason' is required and so cannot be null"); } ObsService os = Context.getObsService(); for (Obs o : encounter.getObsAtTopLevel(false)) { if (!o.isVoided()) { os.voidObs(o, reason); } } OrderService orderService = Context.getOrderService(); for (Order o : encounter.getOrders()) { if (!o.isVoided()) { orderService.voidOrder(o, reason); } } encounter.setVoided(true); encounter.setVoidedBy(Context.getAuthenticatedUser()); // we expect the dateVoided to be already set by AOP logic at this point unless this method was // called within the API, // this ensures that original ParentVoidedDate and the dateVoided of associated objects will // always match for the // unvoid handler to work if (encounter.getDateVoided() == null) { encounter.setDateVoided(new Date()); } encounter.setVoidReason(reason); Context.getEncounterService().saveEncounter(encounter); return encounter; }
/** * @verifies not allow a future dateActivated * @see OrderValidator#validate(Object, org.springframework.validation.Errors) */ @Test public void validate_shouldNotAllowAFutureDateActivated() throws Exception { Patient patient = Context.getPatientService().getPatient(7); TestOrder order = new TestOrder(); order.setPatient(patient); order.setOrderType(orderService.getOrderTypeByName("Test order")); order.setEncounter(Context.getEncounterService().getEncounter(3)); order.setConcept(Context.getConceptService().getConcept(5497)); order.setOrderer(Context.getProviderService().getProvider(1)); order.setCareSetting(orderService.getCareSetting(1)); Calendar cal = Calendar.getInstance(); cal.add(Calendar.HOUR_OF_DAY, 1); order.setDateActivated(cal.getTime()); Errors errors = new BindException(order, "order"); new OrderValidator().validate(order, errors); Assert.assertTrue(errors.hasFieldErrors("dateActivated")); Assert.assertEquals( "Order.error.dateActivatedInFuture", errors.getFieldError("dateActivated").getCode()); }
/* here's the logic for what happens if there is a future regimen: * * * //1. if no drug order of a specific DrugOrder, (create the new order). (OUTCOME1) //2. if DrugOrder, for all DrugOrders: //a. if new start is before old start //NEW ORDER HAS STOP DATE -- create the older as is, and make adjustments: //1. if new end is before or equal to old start (create the new order) (OUTCOME2) //2. if new end is after old start and ( before old end or old end is infinite) //if order is different, adjust the start date of the old order to the end date of the new (create the new order) (OUTCOME3) //if order is same void old order(doesn't matter if old order has infinite stop date or not) (create the new order) (OUTCOME4) //3. if end date is greater than or equal to old end -- void old order (create the new order) (OUTCOME5) //NEW ORDER DOESN'T HAVE STOP DATE //4. orders are different //set end date of new to beginning of old and stop iterating over existing drug orders time sequence (create the new order, modified) (OUTCOME6) //5. orders are the same //delete the old order (create the new order) (OUTCOME7) //b. if start is the same // void existing (create the new order) (OUTCOME8) //c. if start is after existing start //1. if order is after old drug end (create the new order) (OUTCOME9) //2. if order is before old drug end or equal to old drug end or old drug end date is infinite //if orders are the same update the old order with the new, taking the new end date value (Do not create new order) (OUTCOME10) //if orders are different adjust the old to end on new start date (create the new order) (OUTCOME11) * */ public static void setRegimen( Patient patient, Date effectiveDate, Collection<DrugOrder> drugOrders, Concept reasonForChange, Encounter encounterForChange) { RegimenHistory history = getRegimenHistory(patient); Regimen regOnDate = history.getRegimen(effectiveDate); List<Regimen> regAfterDate = history.getRegimensAfter(effectiveDate); OrderService os = Context.getOrderService(); if (encounterForChange != null) { Context.getEncounterService().saveEncounter(encounterForChange); for (DrugOrder drugOrder : drugOrders) { drugOrder.setEncounter(encounterForChange); } } if (!anyRegimens(regAfterDate)) { if (regOnDate == null || regOnDate.getComponents().isEmpty()) { // case: there is no existing regimen on the regimen start date, and there are no new // regimens after this date // go ahead and create the regimen: for (DrugOrder drugOrder : drugOrders) { Context.getOrderService().saveOrder(drugOrder); } } else { // case: there are still open orders and there are no new regimens after this date // first see what existing things we need to stop for (RegimenComponent before : regOnDate.getComponents()) { // stop the old order only if it isn't exactly identical to a new order (excluding // discontinued_date) for (DrugOrder newOrder : drugOrders) { // but either concept or drug is the same if (!before.getDrugOrder().getDiscontinued() && drugOrderMatchesDrugConcept(before.getDrugOrder(), newOrder) && !regimenComponentIsTheSameAsDrugOrderExcludingDates( before.getDrugOrder(), newOrder)) { discontinueOrder(before.getDrugOrder(), effectiveDate, reasonForChange); } } } // now see what new things to start (or extend) for (DrugOrder newOrder : drugOrders) { // create a new order if there isn't already an existing match, // or if there is (excluding discontinued date) you need to extend, or null the stop date boolean alreadyExists = false; for (RegimenComponent before : regOnDate.getComponents()) { if (!before.getDrugOrder().getDiscontinued() && regimenComponentIsTheSameAsDrugOrderExcludingDates( before.getDrugOrder(), newOrder)) { alreadyExists = true; before.getDrugOrder().setDiscontinuedDate(newOrder.getDiscontinuedDate()); before.getDrugOrder().setAutoExpireDate(newOrder.getAutoExpireDate()); before.getDrugOrder().setPrn(newOrder.getPrn()); before.getDrugOrder().setInstructions(newOrder.getInstructions()); os.saveOrder(before.getDrugOrder()); newOrder.setOrderId(before.getDrugOrder().getOrderId()); break; } } if (!alreadyExists) { os.saveOrder(newOrder); } } } } else { // there is a regimen change after the new drug order start date for (DrugOrder newOrder : drugOrders) { boolean saveOrder = false; boolean merged = false; history = getRegimenHistory(patient); List<DrugOrder> existingDrugOrders = getDrugOrdersInOrderByDrugOrConcept(history, newOrder); if (existingDrugOrders.size() == 0) { saveOrder = setSaveOrder(merged); // (OUTCOME1) } else { for (DrugOrder before : existingDrugOrders) { if (newOrder.getStartDate().before(before.getStartDate())) { if (newOrder.getDiscontinuedDate() != null) { if (newOrder.getDiscontinuedDate().before(before.getStartDate()) || newOrder.getDiscontinuedDate().equals(before.getStartDate())) { saveOrder = setSaveOrder(merged); // (OUTCOME2) } else if (newOrder.getDiscontinuedDate().after(before.getStartDate()) && (before.getDiscontinuedDate() == null || newOrder.getDiscontinuedDate().before(before.getDiscontinuedDate()))) { if (!regimenComponentIsTheSameAsDrugOrderExcludingDates(before, newOrder)) { // (OUTCOME3) before.setStartDate(newOrder.getDiscontinuedDate()); os.saveOrder(before); saveOrder = setSaveOrder(merged); } else { // (OUTCOME4) os.voidOrder(before, "overwritten"); saveOrder = setSaveOrder(merged); } } else if (before.getDiscontinuedDate() != null && (newOrder.getDiscontinuedDate().after(before.getDiscontinuedDate()) || newOrder.getDiscontinuedDate().equals(before.getDiscontinuedDate()))) { // (OUTCOME5) os.voidOrder(before, "overwritten"); saveOrder = setSaveOrder(merged); } } else { // new order has infinite end date if (!regimenComponentIsTheSameAsDrugOrderExcludingDates(before, newOrder)) { // (OUTCOME6) newOrder.setDiscontinuedDate(before.getStartDate()); saveOrder = setSaveOrder(merged); break; } else { // (OUTCOME7) os.voidOrder(before, "overwritten"); saveOrder = setSaveOrder(merged); } } } else if (newOrder.getStartDate().equals(before.getStartDate())) { // b // (OUTCOME8) os.voidOrder(before, "overwritten"); saveOrder = setSaveOrder(merged); } else { // c -- start date is after or equal to old end date if (before.getDiscontinuedDate() != null && newOrder.getStartDate().after(before.getDiscontinuedDate())) // 1 // (OUTCOME9) saveOrder = setSaveOrder(merged); if (before.getDiscontinuedDate() == null || newOrder.getStartDate().before(before.getDiscontinuedDate()) || newOrder.getStartDate().equals(before.getDiscontinuedDate())) { // 2 if (regimenComponentIsTheSameAsDrugOrderExcludingDates(before, newOrder)) { // (OUTCOME10) before.setDiscontinuedDate(newOrder.getDiscontinuedDate()); before.setAutoExpireDate(newOrder.getAutoExpireDate()); before.setPrn(newOrder.getPrn()); before.setInstructions(newOrder.getInstructions()); os.saveOrder(before); saveOrder = false; newOrder.setOrderId(before.getOrderId()); merged = true; } else { // (OUTCOME11) before.setDiscontinuedDate(newOrder.getStartDate()); os.saveOrder(before); saveOrder = setSaveOrder(merged); } } } } } if (saveOrder) os.saveOrder(newOrder); } } }