/** * @see OrderService#getDiscontinuationOrder(Order) */ @Test public void getDiscontinuationOrder_shouldReturnNullIfDcOrderIsVoided() { Order order = orderService.getOrder(7); Order discontinueOrder = orderService.discontinueOrder(order, "Some reason", new Date(), providerService.getProvider(1), encounterService.getEncounter(3)); orderService.voidOrder(discontinueOrder, "Invalid reason"); Order discontinuationOrder = orderService.getDiscontinuationOrder(order); assertThat(discontinuationOrder, is(nullValue())); }
for (Order o : encounter.getOrders()) { if (!o.getVoided()) { orderService.voidOrder(o, reason);
@Test public void shouldAllowEditingADiscontinuationOrder() { Order originalDCOrder = orderService.getOrder(22); assertEquals(Order.Action.DISCONTINUE, originalDCOrder.getAction()); List<Order> originalPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient()); final Order previousOrder = originalDCOrder.getPreviousOrder(); assertNotNull(previousOrder); final Date newStartDate = originalDCOrder.getEncounter().getEncounterDatetime(); Order newDcOrder = originalDCOrder.cloneForRevision(); newDcOrder.setEncounter(originalDCOrder.getEncounter()); newDcOrder.setOrderer(originalDCOrder.getOrderer()); newDcOrder.setDateActivated(newStartDate); orderService.voidOrder(originalDCOrder, "To be replace with a new one"); assertNull(originalDCOrder.getDateStopped()); orderService.saveOrder(newDcOrder, null); //We need to flush so that we ensure the interceptor is okay with all this Context.flushSession(); assertTrue(originalDCOrder.getVoided()); List<Order> newPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient()); assertEquals(originalPatientOrders.size() + 1, newPatientOrders.size()); Collection<Order> newOrders = CollectionUtils.disjunction(originalPatientOrders, newPatientOrders); assertEquals(1, newOrders.size()); assertEquals(newOrders.iterator().next().getPreviousOrder(), previousOrder); }
/** * @see OrderService#getRevisionOrder(org.openmrs.Order) */ @Test public void getRevisionOrder_shouldNotReturnAVoidedRevisionOrder() { Order order = orderService.getOrder(7); Order revision1 = order.cloneForRevision(); revision1.setEncounter(order.getEncounter()); revision1.setOrderer(order.getOrderer()); orderService.saveOrder(revision1, null); assertEquals(revision1, orderService.getRevisionOrder(order)); orderService.voidOrder(revision1, "Testing"); assertThat(orderService.getRevisionOrder(order), is(nullValue())); //should return the new unvoided revision Order revision2 = order.cloneForRevision(); revision2.setEncounter(order.getEncounter()); revision2.setOrderer(order.getOrderer()); orderService.saveOrder(revision2, null); assertEquals(revision2, orderService.getRevisionOrder(order)); }
/** * @see org.openmrs.module.webservices.rest.web.resource.impl.BaseDelegatingResource#delete(java.lang.Object, * java.lang.String, org.openmrs.module.webservices.rest.web.RequestContext) */ @Override protected void delete(Order delegate, String reason, RequestContext context) throws ResponseException { if (delegate.isVoided()) { // DELETE is idempotent, so we return success here return; } Context.getOrderService().voidOrder(delegate, reason); }
/** * @see OrderService#voidOrder(org.openmrs.Order, String) */ @Test public void voidOrder_shouldUnsetDateStoppedOfThePreviousOrderIfTheSpecifiedOrderIsARevision() { Order order = orderService.getOrder(111); assertEquals(Action.REVISE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); orderService.voidOrder(order, "None"); Context.flushSession(); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); }
/** * @see OrderService#voidOrder(org.openmrs.Order, String) */ @Test public void voidOrder_shouldUnsetDateStoppedOfThePreviousOrderIfTheSpecifiedOrderIsADiscontinuation() { Order order = orderService.getOrder(22); assertEquals(Action.DISCONTINUE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); orderService.voidOrder(order, "None"); //Ensures order interceptor is okay with all the changes Context.flushSession(); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); }
/** * @throws InterruptedException * @see OrderService#unvoidOrder(org.openmrs.Order) */ @Test public void unvoidOrder_shouldFailForADiscontinuationOrderIfThePreviousOrderIsInactive() throws InterruptedException { Order order = orderService.getOrder(22); assertEquals(Action.DISCONTINUE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); //void the DC order for testing purposes so we can unvoid it later orderService.voidOrder(order, "None"); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); //stop the order with a different DC order orderService.discontinueOrder(previousOrder, "Testing", null, previousOrder.getOrderer(), previousOrder.getEncounter()); Thread.sleep(10); expectedException.expect(CannotUnvoidOrderException.class); expectedException.expectMessage(mss.getMessage("Order.action.cannot.unvoid", new Object[] { "discontinuation" }, null)); orderService.unvoidOrder(order); }
/** * @see OrderService#voidOrder(org.openmrs.Order, String) */ @Test public void voidOrder_shouldVoidAnOrder() { Order order = orderService.getOrder(1); assertFalse(order.getVoided()); assertNull(order.getDateVoided()); assertNull(order.getVoidedBy()); assertNull(order.getVoidReason()); orderService.voidOrder(order, "None"); assertTrue(order.getVoided()); assertNotNull(order.getDateVoided()); assertNotNull(order.getVoidedBy()); assertNotNull(order.getVoidReason()); }
/** * @throws InterruptedException * @see OrderService#unvoidOrder(org.openmrs.Order) */ @Test public void unvoidOrder_shouldFailForAReviseOrderIfThePreviousOrderIsInactive() throws InterruptedException { Order order = orderService.getOrder(111); assertEquals(Action.REVISE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); //void the DC order for testing purposes so we can unvoid it later orderService.voidOrder(order, "None"); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); //stop the order with a different REVISE order Order revise = previousOrder.cloneForRevision(); revise.setOrderer(order.getOrderer()); revise.setEncounter(order.getEncounter()); orderService.saveOrder(revise, null); Thread.sleep(10); expectedException.expect(CannotUnvoidOrderException.class); expectedException.expectMessage(mss.getMessage("Order.action.cannot.unvoid", new Object[] { "revision" }, null)); orderService.unvoidOrder(order); }
/** * @see OrderService#voidOrder(org.openmrs.Order, String) */ @Test public void shouldVoidAnOrderAndFlushSuccessfully() { Order order = orderService.getOrder(1); assertFalse(order.getVoided()); assertNull(order.getDateVoided()); assertNull(order.getVoidedBy()); assertNull(order.getVoidReason()); orderService.voidOrder(order, "None"); //forces hibernate interceptors to get invoked Context.flushSession(); assertTrue(order.getVoided()); assertNotNull(order.getDateVoided()); assertNotNull(order.getVoidedBy()); assertNotNull(order.getVoidReason()); }
Order testOrder = testEncounter.getOrders().iterator().next(); assertFalse(testOrder.getVoided()); Context.getOrderService().voidOrder(testOrder, "testing"); assertTrue(testOrder.getVoided()); TestUtil.waitForClockTick();
/** * @see OrderService#unvoidOrder(org.openmrs.Order) */ @Test public void unvoidOrder_shouldStopThePreviousOrderIfTheSpecifiedOrderIsADiscontinuation() { Order order = orderService.getOrder(22); assertEquals(Action.DISCONTINUE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); //void the DC order for testing purposes so we can unvoid it later orderService.voidOrder(order, "None"); Context.flushSession(); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); orderService.unvoidOrder(order); Context.flushSession(); assertFalse(order.getVoided()); assertNotNull(previousOrder.getDateStopped()); }
/** * @see OrderService#unvoidOrder(org.openmrs.Order) */ @Test public void unvoidOrder_shouldStopThePreviousOrderIfTheSpecifiedOrderIsARevision() { Order order = orderService.getOrder(111); assertEquals(Action.REVISE, order.getAction()); Order previousOrder = order.getPreviousOrder(); assertNotNull(previousOrder.getDateStopped()); assertFalse(order.getVoided()); //void the revise order for testing purposes so we can unvoid it later orderService.voidOrder(order, "None"); Context.flushSession(); assertTrue(order.getVoided()); assertNull(previousOrder.getDateStopped()); orderService.unvoidOrder(order); Context.flushSession(); assertFalse(order.getVoided()); assertNotNull(previousOrder.getDateStopped()); }
orderTag.discontinuedReasonStr); } else { Context.getOrderService().voidOrder(existingOrder, "Update discontinued date or reason"); discontinuationOrder = existingOrder.cloneForRevision(); discontinuationOrder.setDateActivated(orderTag.discontinuedDate);