Examples with OrderGroup org.openmrs.OrderGroup used on opensource projects

Example 1 with OrderGroup

use of org.openmrs.OrderGroup in project openmrs-core by openmrs.

the class OrderServiceTest method shouldSetTheCorrectSortWeightWhenAddingAnOrderWithANegativePosition.

@Test
public void shouldSetTheCorrectSortWeightWhenAddingAnOrderWithANegativePosition() {
    executeDataSet(ORDER_SET);
    Encounter encounter = encounterService.getEncounter(3);
    OrderSet orderSet = Context.getOrderSetService().getOrderSet(2000);
    OrderGroup orderGroup = new OrderGroup();
    orderGroup.setOrderSet(orderSet);
    orderGroup.setPatient(encounter.getPatient());
    orderGroup.setEncounter(encounter);
    Order firstOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order secondOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1001).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Set<Order> orders = new LinkedHashSet<>();
    orders.add(firstOrderWithOrderGroup);
    orders.add(secondOrderWithOrderGroup);
    encounter.setOrders(orders);
    for (OrderGroup og : encounter.getOrderGroups()) {
        if (og.getId() == null) {
            Context.getOrderService().saveOrderGroup(og);
        }
    }
    Context.flushSession();
    OrderGroup savedOrderGroup = Context.getOrderService().getOrderGroupByUuid(orderGroup.getUuid());
    Order newOrderWithNegativePosition = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(savedOrderGroup).build();
    savedOrderGroup.addOrder(newOrderWithNegativePosition, -1);
    Context.getOrderService().saveOrderGroup(savedOrderGroup);
    Context.flushSession();
    OrderGroup secondSavedOrderGroup = Context.getOrderService().getOrderGroupByUuid(orderGroup.getUuid());
    assertEquals(3, secondSavedOrderGroup.getOrders().size());
    assertEquals("The new order gets added at the last position", newOrderWithNegativePosition.getUuid(), secondSavedOrderGroup.getOrders().get(2).getUuid());
    assertThat("The new order has a higher sortWeight than the second", secondSavedOrderGroup.getOrders().get(2).getSortWeight().compareTo(secondSavedOrderGroup.getOrders().get(1).getSortWeight()), is(1));
    Order newOrderWithInvalidPosition = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(savedOrderGroup).build();
    expectedException.expect(APIException.class);
    expectedException.expectMessage("Cannot add a member which is out of range of the list");
    secondSavedOrderGroup.addOrder(newOrderWithInvalidPosition, secondSavedOrderGroup.getOrders().size() + 1);
}

Example 2 with OrderGroup

use of org.openmrs.OrderGroup in project openmrs-core by openmrs.

the class OrderServiceTest method shouldSetTheCorrectSortWeightWhenAddingAnOrderInOrderGroup.

@Test
public void shouldSetTheCorrectSortWeightWhenAddingAnOrderInOrderGroup() {
    executeDataSet(ORDER_SET);
    Encounter encounter = encounterService.getEncounter(3);
    OrderSet orderSet = Context.getOrderSetService().getOrderSet(2000);
    OrderGroup orderGroup = new OrderGroup();
    orderGroup.setOrderSet(orderSet);
    orderGroup.setPatient(encounter.getPatient());
    orderGroup.setEncounter(encounter);
    Order firstOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order secondOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1001).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Set<Order> orders = new LinkedHashSet<>();
    orders.add(firstOrderWithOrderGroup);
    orders.add(secondOrderWithOrderGroup);
    encounter.setOrders(orders);
    for (OrderGroup og : encounter.getOrderGroups()) {
        if (og.getId() == null) {
            Context.getOrderService().saveOrderGroup(og);
        }
    }
    Context.flushSession();
    OrderGroup savedOrderGroup = Context.getOrderService().getOrderGroupByUuid(orderGroup.getUuid());
    assertEquals("The first order in  savedOrderGroup is the same which is sent first in the List", firstOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(0).getUuid());
    assertEquals("The second order in  savedOrderGroup is the same which is sent second in the List", secondOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(1).getUuid());
    assertThat("The first order has a lower sortWeight than the second", savedOrderGroup.getOrders().get(0).getSortWeight().compareTo(savedOrderGroup.getOrders().get(1).getSortWeight()), is(-1));
    Order newOrderWithoutAnyPosition = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(savedOrderGroup).build();
    savedOrderGroup.addOrder(newOrderWithoutAnyPosition);
    Context.getOrderService().saveOrderGroup(savedOrderGroup);
    Context.flushSession();
    OrderGroup secondSavedOrderGroup = Context.getOrderService().getOrderGroupByUuid(orderGroup.getUuid());
    assertEquals("The first order in  savedOrderGroup is the same which is sent first in the List", firstOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(0).getUuid());
    assertEquals("The second order in  savedOrderGroup is the same which is sent second in the List", secondOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(1).getUuid());
    assertEquals("The third order in  savedOrderGroup is the same which is sent third in the List", secondSavedOrderGroup.getOrders().get(2).getUuid(), newOrderWithoutAnyPosition.getUuid());
    assertThat("The third order has a higher sortWeight than the second", savedOrderGroup.getOrders().get(2).getSortWeight().compareTo(savedOrderGroup.getOrders().get(1).getSortWeight()), is(1));
}

Example 3 with OrderGroup

use of org.openmrs.OrderGroup in project openmrs-core by openmrs.

the class OrderServiceTest method shouldSaveOrdersWithSortWeightWhenWithinAOrderGroup.

@Test
public void shouldSaveOrdersWithSortWeightWhenWithinAOrderGroup() {
    executeDataSet(ORDER_SET);
    Encounter encounter = encounterService.getEncounter(3);
    OrderSet orderSet = Context.getOrderSetService().getOrderSet(2000);
    OrderGroup orderGroup = new OrderGroup();
    orderGroup.setOrderSet(orderSet);
    orderGroup.setPatient(encounter.getPatient());
    orderGroup.setEncounter(encounter);
    Order firstOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order secondOrderWithOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1001).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order orderWithoutOrderGroup = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).build();
    Set<Order> orders = new LinkedHashSet<>();
    orders.add(firstOrderWithOrderGroup);
    orders.add(secondOrderWithOrderGroup);
    orders.add(orderWithoutOrderGroup);
    encounter.setOrders(orders);
    for (OrderGroup og : encounter.getOrderGroups()) {
        if (og.getId() == null) {
            Context.getOrderService().saveOrderGroup(og);
        }
    }
    for (Order o : encounter.getOrdersWithoutOrderGroups()) {
        if (o.getId() == null) {
            Context.getOrderService().saveOrder(o, null);
        }
    }
    Context.flushSession();
    OrderGroup savedOrderGroup = Context.getOrderService().getOrderGroupByUuid(orderGroup.getUuid());
    Order savedOrder = Context.getOrderService().getOrderByUuid(orderWithoutOrderGroup.getUuid());
    assertEquals("The first order in  savedOrderGroup is the same which is sent first in the List", firstOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(0).getUuid());
    assertEquals("The second order in  savedOrderGroup is the same which is sent second in the List", secondOrderWithOrderGroup.getUuid(), savedOrderGroup.getOrders().get(1).getUuid());
    assertNull("The order which doesn't belong to an orderGroup has no sortWeight", savedOrder.getSortWeight());
    assertThat("The first order has a lower sortWeight than the second", savedOrderGroup.getOrders().get(0).getSortWeight().compareTo(savedOrderGroup.getOrders().get(1).getSortWeight()), is(-1));
}

Example 4 with OrderGroup

use of org.openmrs.OrderGroup in project openmrs-core by openmrs.

the class EncounterServiceTest method shouldSaveMultipleOrderGroupsIfDifferentOrdersHaveDifferentOrderGroups.

@Test
public void shouldSaveMultipleOrderGroupsIfDifferentOrdersHaveDifferentOrderGroups() {
    executeDataSet(ORDER_SET);
    Encounter encounter = new Encounter();
    encounter.setPatient(Context.getPatientService().getPatient(3));
    encounter.setEncounterType(Context.getEncounterService().getEncounterType(1));
    encounter.setEncounterDatetime(new Date());
    Context.getEncounterService().saveEncounter(encounter);
    Integer encounterId = Context.getEncounterService().getEncounterByUuid(encounter.getUuid()).getId();
    // Created a new OrderGroup
    OrderSet orderSet = Context.getOrderSetService().getOrderSet(2000);
    OrderGroup orderGroup = new OrderGroup();
    orderGroup.setOrderSet(orderSet);
    orderGroup.setPatient(encounter.getPatient());
    orderGroup.setEncounter(Context.getEncounterService().getEncounter(encounterId));
    // Created a new OrderGroup
    OrderGroup orderGroup2 = new OrderGroup();
    orderGroup2.setEncounter(Context.getEncounterService().getEncounter(encounterId));
    orderGroup2.setPatient(encounter.getPatient());
    // Added this OrderGroup to two new orders
    Order newOrder1 = new OrderBuilder().withAction(Order.Action.NEW).withPatient(3).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(encounterId).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order newOrder2 = new OrderBuilder().withAction(Order.Action.NEW).withPatient(3).withConcept(1001).withCareSetting(1).withOrderer(1).withEncounter(encounterId).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Order newOrder3 = new OrderBuilder().withAction(Order.Action.NEW).withPatient(3).withConcept(1002).withCareSetting(1).withOrderer(1).withEncounter(encounterId).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup2).build();
    Order newOrder4 = new OrderBuilder().withAction(Order.Action.NEW).withPatient(3).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(encounterId).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).build();
    Order newOrder5 = new OrderBuilder().withAction(Order.Action.NEW).withPatient(3).withConcept(1001).withCareSetting(1).withOrderer(1).withEncounter(encounterId).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup2).build();
    // Add these orders to the Encounter
    encounter.addOrder(newOrder1);
    encounter.addOrder(newOrder2);
    encounter.addOrder(newOrder3);
    encounter.addOrder(newOrder4);
    encounter.addOrder(newOrder5);
    Context.getEncounterService().saveEncounter(encounter);
    Context.flushSession();
    List<Order> orders = new ArrayList<>(Context.getEncounterService().getEncounterByUuid(encounter.getUuid()).getOrders());
    HashMap<Integer, OrderGroup> orderGroups = new HashMap<>();
    for (Order order : orders) {
        if (order.getOrderGroup() != null) {
            orderGroups.put(order.getOrderGroup().getId(), order.getOrderGroup());
        }
    }
    assertEquals("Two New Order Groups Get Saved", 2, orderGroups.size());
}

Example 5 with OrderGroup

use of org.openmrs.OrderGroup in project openmrs-core by openmrs.

the class EncounterServiceImpl method saveEncounter.

/**
 * @see org.openmrs.api.EncounterService#saveEncounter(org.openmrs.Encounter)
 */
@Override
public Encounter saveEncounter(Encounter encounter) throws APIException {
    // if authenticated user is not supposed to edit encounter of certain type
    failIfDeniedToEdit(encounter);
    // If new encounter, try to assign a visit using the registered visit assignment handler.
    createVisitForNewEncounter(encounter);
    // check permissions
    boolean isNewEncounter = requirePrivilege(encounter);
    // This must be done after setting dateCreated etc on the obs because
    // of the way the ORM tools flush things and check for nullity
    // This also must be done before the save encounter so we can use the
    // orig date
    // after the save
    Patient p = encounter.getPatient();
    Date originalDate;
    Location originalLocation = null;
    if (!isNewEncounter) {
        // fetch the datetime from the database prior to saving for this
        // encounter
        // to see if it has changed and change all obs after saving if so
        originalDate = dao.getSavedEncounterDatetime(encounter);
        if (encounter.getLocation() != null) {
            originalLocation = dao.getSavedEncounterLocation(encounter);
        }
        // Our data model duplicates the patient column to allow for
        // observations to
        // not have to look up the parent Encounter to find the patient
        // Therefore, encounter.patient must always equal
        // encounter.observations[0-n].patient
        // If we are changing encounter.encounterDatetime, then we need to
        // also apply that
        // to Obs that inherited their obsDatetime from the encounter in the
        // first place
        Date newDate = encounter.getEncounterDatetime();
        Location newLocation = encounter.getLocation();
        for (Obs obs : encounter.getAllObs(true)) {
            // if the date was changed
            if (OpenmrsUtil.compare(originalDate, newDate) != 0 && OpenmrsUtil.compare(obs.getObsDatetime(), originalDate) == 0) {
                // if the obs datetime is the same as the
                // original encounter datetime, fix it
                obs.setObsDatetime(newDate);
            }
            if (!OpenmrsUtil.nullSafeEquals(newLocation, originalLocation) && obs.getLocation().equals(originalLocation)) {
                obs.setLocation(newLocation);
            }
            // encounter, fix it
            if (!obs.getPerson().getPersonId().equals(p.getPatientId())) {
                obs.setPerson(p);
            }
        }
    }
    // same goes for Orders
    for (Order o : encounter.getOrders()) {
        if (!p.equals(o.getPatient())) {
            o.setPatient(p);
        }
    }
    // do the actual saving to the database
    dao.saveEncounter(encounter);
    // save the new orderGroups
    for (OrderGroup orderGroup : encounter.getOrderGroups()) {
        Context.getOrderService().saveOrderGroup(orderGroup);
    }
    // save the new orders which do not have order groups
    for (Order o : encounter.getOrdersWithoutOrderGroups()) {
        if (o.getOrderId() == null) {
            Context.getOrderService().saveOrder(o, null);
        }
    }
    // save the Obs
    String changeMessage = Context.getMessageSourceService().getMessage("Obs.void.reason.default");
    ObsService os = Context.getObsService();
    List<Obs> obsToRemove = new ArrayList<>();
    List<Obs> obsToAdd = new ArrayList<>();
    for (Obs o : encounter.getObsAtTopLevel(true)) {
        if (o.getId() == null) {
            os.saveObs(o, null);
        } else {
            Obs newObs = os.saveObs(o, changeMessage);
            // The logic in saveObs evicts the old obs instance, so we need to update the collection
            // with the newly loaded and voided instance, apparently reloading the encounter
            // didn't do the tick
            obsToRemove.add(o);
            obsToAdd.add(os.getObs(o.getId()));
            obsToAdd.add(newObs);
        }
    }
    removeGivenObsAndTheirGroupMembersFromEncounter(obsToRemove, encounter);
    addGivenObsAndTheirGroupMembersToEncounter(obsToAdd, encounter);
    return encounter;
}