Example usage for org.apache.commons.lang3.time DateUtils addDays

Introduction

In this page you can find the example usage for org.apache.commons.lang3.time DateUtils addDays.

Prototype

public static Date addDays(final Date date, final int amount) 

Source Link

Document

Adds a number of days to a date returning a new object.

Usage

From source file:org.kuali.kra.subaward.service.impl.SubAwardServiceImpl.java

public Date getCalculatedFollowupDate(Date baseDate) {
    Date retDate = new Date(DateUtils.addDays(baseDate, getFollowupDateDefaultLengthInDays()).getTime());
    return retDate;
}

---

From source file:org.openmrs.api.OrderServiceTest.java

/**
 * @verifies fail for revision order if an active drug order for the same concept and care settings exists
 * @see OrderService#saveOrder(org.openmrs.Order, OrderContext)
 *///w  w  w.j  a  va 2  s  . c om
@Test
public void saveOrder_shouldFailForRevisionOrderIfAnActiveDrugOrderForTheSameConceptAndCareSettingsExists()
        throws Exception {
    final Patient patient = patientService.getPatient(2);
    final Concept aspirin = conceptService.getConcept(88);
    DrugOrder firstOrder = new DrugOrder();
    firstOrder.setPatient(patient);
    firstOrder.setConcept(aspirin);
    firstOrder.setEncounter(encounterService.getEncounter(6));
    firstOrder.setOrderer(providerService.getProvider(1));
    firstOrder.setCareSetting(orderService.getCareSetting(2));
    firstOrder.setDrug(conceptService.getDrug(3));
    firstOrder.setDateActivated(new Date());
    firstOrder.setAutoExpireDate(DateUtils.addDays(new Date(), 10));
    firstOrder.setDosingType(FreeTextDosingInstructions.class);
    firstOrder.setDosingInstructions("2 for 5 days");
    firstOrder.setQuantity(10.0);
    firstOrder.setQuantityUnits(conceptService.getConcept(51));
    firstOrder.setNumRefills(0);
    orderService.saveOrder(firstOrder, null);

    //New order in future for same concept and care setting
    DrugOrder secondOrder = new DrugOrder();
    secondOrder.setPatient(firstOrder.getPatient());
    secondOrder.setConcept(firstOrder.getConcept());
    secondOrder.setEncounter(encounterService.getEncounter(6));
    secondOrder.setOrderer(providerService.getProvider(1));
    secondOrder.setCareSetting(firstOrder.getCareSetting());
    secondOrder.setDrug(conceptService.getDrug(3));
    secondOrder.setDateActivated(new Date());
    secondOrder.setScheduledDate(DateUtils.addDays(firstOrder.getEffectiveStopDate(), 1));
    secondOrder.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    secondOrder.setDosingType(FreeTextDosingInstructions.class);
    secondOrder.setDosingInstructions("2 for 5 days");
    secondOrder.setQuantity(10.0);
    secondOrder.setQuantityUnits(conceptService.getConcept(51));
    secondOrder.setNumRefills(0);
    orderService.saveOrder(secondOrder, null);

    //Revise second order to have scheduled date overlapping with active order
    DrugOrder revision = secondOrder.cloneForRevision();
    revision.setScheduledDate(DateUtils.addDays(firstOrder.getEffectiveStartDate(), 2));
    revision.setEncounter(encounterService.getEncounter(6));
    revision.setOrderer(providerService.getProvider(1));

    expectedException.expect(APIException.class);
    expectedException.expectMessage("Order.cannot.have.more.than.one");
    orderService.saveOrder(revision, null);
}

---

From source file:org.openmrs.api.OrderServiceTest.java

/**
 * @verifies pass for revision order if an active test order for the same concept and care settings exists
 * @see OrderService#saveOrder(Order, OrderContext)
 *//*from   w  w  w  .  j a v a2  s .c  o  m*/
@Test
public void saveOrder_shouldPassForRevisionOrderIfAnActiveTestOrderForTheSameConceptAndCareSettingsExists()
        throws Exception {
    final Patient patient = patientService.getPatient(2);
    final Concept cd4Count = conceptService.getConcept(5497);
    TestOrder activeOrder = new TestOrder();
    activeOrder.setPatient(patient);
    activeOrder.setConcept(cd4Count);
    activeOrder.setEncounter(encounterService.getEncounter(6));
    activeOrder.setOrderer(providerService.getProvider(1));
    activeOrder.setCareSetting(orderService.getCareSetting(2));
    activeOrder.setDateActivated(new Date());
    activeOrder.setAutoExpireDate(DateUtils.addDays(new Date(), 10));
    orderService.saveOrder(activeOrder, null);

    //New order in future for same concept
    TestOrder secondOrder = new TestOrder();
    secondOrder.setPatient(activeOrder.getPatient());
    secondOrder.setConcept(activeOrder.getConcept());
    secondOrder.setEncounter(encounterService.getEncounter(6));
    secondOrder.setOrderer(providerService.getProvider(1));
    secondOrder.setCareSetting(activeOrder.getCareSetting());
    secondOrder.setDateActivated(new Date());
    secondOrder.setScheduledDate(DateUtils.addDays(activeOrder.getEffectiveStopDate(), 1));
    secondOrder.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    orderService.saveOrder(secondOrder, null);

    //Revise second order to have scheduled date overlapping with active order
    TestOrder revision = secondOrder.cloneForRevision();
    revision.setScheduledDate(DateUtils.addDays(activeOrder.getEffectiveStartDate(), 2));
    revision.setEncounter(encounterService.getEncounter(6));
    revision.setOrderer(providerService.getProvider(1));

    Order savedSecondOrder = orderService.saveOrder(revision, null);

    assertNotNull(orderService.getOrder(savedSecondOrder.getOrderId()));
}

---

From source file:org.openmrs.api.OrderServiceTest.java

/**
 * @see OrderService#saveOrder(org.openmrs.Order, OrderContext)
 *//*w w  w .  java 2 s.  c  o m*/
@Test
public void saveOrder_shouldSaveRevisionOrderScheduledOnDateNotOverlappingWithAnActiveOrderForTheSameConceptAndCareSetting()
        throws Exception {
    //sanity check that we have an active order
    final Patient patient = patientService.getPatient(2);
    final Concept cd4Count = conceptService.getConcept(5497);
    TestOrder activeOrder = new TestOrder();
    activeOrder.setPatient(patient);
    activeOrder.setConcept(cd4Count);
    activeOrder.setEncounter(encounterService.getEncounter(6));
    activeOrder.setOrderer(providerService.getProvider(1));
    activeOrder.setCareSetting(orderService.getCareSetting(2));
    activeOrder.setDateActivated(new Date());
    activeOrder.setAutoExpireDate(DateUtils.addDays(new Date(), 10));
    orderService.saveOrder(activeOrder, null);

    //New Drug order in future for same concept
    TestOrder secondOrder = new TestOrder();
    secondOrder.setPatient(activeOrder.getPatient());
    secondOrder.setConcept(activeOrder.getConcept());
    secondOrder.setEncounter(encounterService.getEncounter(6));
    secondOrder.setOrderer(providerService.getProvider(1));
    secondOrder.setCareSetting(activeOrder.getCareSetting());
    secondOrder.setDateActivated(new Date());
    secondOrder.setScheduledDate(DateUtils.addDays(activeOrder.getEffectiveStopDate(), 1));
    secondOrder.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    orderService.saveOrder(secondOrder, null);

    //Revise Second Order to have scheduled date not overlapping with active order
    TestOrder revision = secondOrder.cloneForRevision();
    revision.setScheduledDate(DateUtils.addDays(activeOrder.getEffectiveStopDate(), 2));
    revision.setEncounter(encounterService.getEncounter(6));
    revision.setOrderer(providerService.getProvider(1));

    Order savedRevisionOrder = orderService.saveOrder(revision, null);

    assertNotNull(orderService.getOrder(savedRevisionOrder.getOrderId()));
}

---

From source file:org.openmrs.api.OrderServiceTest.java

/**
 * @verifies pass if an active drug order for the same drug formulation exists beyond new
 *           order's schedule/* w ww .java 2s .  c om*/
 * @see OrderService#saveOrder(org.openmrs.Order, OrderContext)
 */
@Test
public void saveOrder_shouldPassIfAnActiveDrugOrderForTheSameDrugFormulationExistsBeyondSchedule()
        throws Exception {
    executeDataSet("org/openmrs/api/include/OrderServiceTest-DrugOrders.xml");
    final Patient patient = patientService.getPatient(2);

    DrugOrder existingOrder = (DrugOrder) orderService.getOrder(2000);
    int initialActiveOrderCount = orderService.getActiveOrders(patient, null, null, null).size();

    //New Drug order
    DrugOrder order = new DrugOrder();
    order.setPatient(patient);
    order.setDrug(existingOrder.getDrug());
    order.setEncounter(encounterService.getEncounter(6));
    order.setOrderer(providerService.getProvider(1));
    order.setCareSetting(existingOrder.getCareSetting());
    order.setDosingType(FreeTextDosingInstructions.class);
    order.setDosingInstructions("2 for 10 days");
    order.setQuantity(10.0);
    order.setQuantityUnits(conceptService.getConcept(51));
    order.setNumRefills(2);
    order.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);

    order.setScheduledDate(DateUtils.addDays(existingOrder.getDateStopped(), 1));

    orderService.saveOrder(order, null);
    List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
    assertEquals(++initialActiveOrderCount, activeOrders.size());
}

---

From source file:org.openmrs.ISO8601Duration.java

/**
 * Add this duration to given startDate/*from w  ww.ja  v  a2  s.c  o  m*/
 * 
 * @param startDate
 * @param frequency is used to calculate time to be added to startDate when duration unit is
 *            'Recurring Interval'
 * @return date which is startDate plus duration
 */
public Date addToDate(Date startDate, OrderFrequency frequency) {
    if (SECONDS_CODE.equals(code))
        return DateUtils.addSeconds(startDate, duration);
    if (MINUTES_CODE.equals(code))
        return DateUtils.addMinutes(startDate, duration);
    if (HOURS_CODE.equals(code))
        return DateUtils.addHours(startDate, duration);
    if (DAYS_CODE.equals(code))
        return DateUtils.addDays(startDate, duration);
    if (WEEKS_CODE.equals(code))
        return DateUtils.addWeeks(startDate, duration);
    if (MONTHS_CODE.equals(code))
        return DateUtils.addMonths(startDate, duration);
    if (YEARS_CODE.equals(code))
        return DateUtils.addYears(startDate, duration);
    if (RECURRING_INTERVAL_CODE.equals(code)) {
        if (frequency == null)
            throw new APIException("Frequency can not be null when duration in Recurring Interval");
        return DateUtils.addSeconds(startDate,
                (int) (duration * SECONDS_PER_DAY / frequency.getFrequencyPerDay()));
    }
    throw new APIException(String.format("Unknown code '%s' for ISO8601 duration units", code));
}

---

From source file:org.openmrs.module.emrapi.encounter.mapper.OpenMRSDrugOrderMapper1_10Test.java

@Test
public void shouldClearScheduledDateAndUrgencyWhenScheduledOrderRevisedToStartFromToday() {
    DrugOrder previousOpenMrsDrugOrder = new DrugOrder();
    previousOpenMrsDrugOrder.setScheduledDate(DateUtils.addDays(new Date(), 2));
    previousOpenMrsDrugOrder.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    previousOpenMrsDrugOrder.setUuid(UUID.randomUUID().toString());
    Drug drug = new Drug();
    drug.setUuid(DRUG_UUID);//from  w w w  . j a  va  2s .c o m
    previousOpenMrsDrugOrder.setDrug(drug);
    when(orderService.getOrderByUuid(previousOpenMrsDrugOrder.getUuid())).thenReturn(previousOpenMrsDrugOrder);
    EncounterTransaction.DrugOrder revisedDrugOrder = new DrugOrderBuilder().withScheduledDate(null)
            .withAction(Order.Action.REVISE.name()).withPreviousOrderUuid(previousOpenMrsDrugOrder.getUuid())
            .withDrugUuid(DRUG_UUID).withDurationUnits(DAY_DURATION_UNIT).build();

    DrugOrder revisedOpenMrsDrugOrder = openMRSDrugOrderMapper.map(revisedDrugOrder, encounter);

    assertThat(revisedOpenMrsDrugOrder.getUrgency(), is(equalTo(OpenMRSDrugOrderMapper.DEFAULT_URGENCY)));
    assertNull(revisedOpenMrsDrugOrder.getScheduledDate());
}

---

From source file:org.openmrs.order.OrderUtilTest.java

/**
 * @verifies return true if order1 and order2 do not have end date
 * @see OrderUtil#checkScheduleOverlap(Order,Order)
 *///from  ww w .ja v a2 s.c  om
@Test
public void checkScheduleOverlap_shouldReturnTrueIfOrder1AndOrder2DoNotHaveEndDate() throws Exception {
    Date date = new Date();
    Order order1 = new Order();
    order1.setScheduledDate(DateUtils.addDays(date, 4)); //Order1 scheduled after 4 days without stop date
    order1.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);

    Order order2 = new Order();
    order2.setDateActivated(date);
    order2.setScheduledDate(DateUtils.addDays(date, 6)); //Order2 scheduled after 6 days without stop date
    order2.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);

    assertTrue(OrderUtil.checkScheduleOverlap(order1, order2));
    assertTrue(OrderUtil.checkScheduleOverlap(order2, order1)); //Checks vice versa
}

---

From source file:org.openmrs.order.OrderUtilTest.java

/**
 * @verifies return true if order1 and order2 have same start dates
 * @see OrderUtil#checkScheduleOverlap(Order,Order)
 *///from  ww w .j a va 2s .com
@Test
public void checkScheduleOverlap_shouldReturnTrueIfOrder1AndOrder2HaveSameStartDates() throws Exception {
    Date date = new Date();
    Order order1 = new Order();
    order1.setDateActivated(date);
    order1.setScheduledDate(DateUtils.addDays(date, 6)); //Order1 scheduled after 6 days
    order1.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);

    Order order2 = new Order();
    order2.setDateActivated(date);
    order2.setScheduledDate(DateUtils.addDays(date, 6)); //Order2 also scheduled after 6 days
    order2.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);

    assertTrue(OrderUtil.checkScheduleOverlap(order1, order2));
    assertTrue(OrderUtil.checkScheduleOverlap(order2, order1));
    assertTrue(OrderUtil.checkScheduleOverlap(order2, order2));
}

---

From source file:org.openmrs.order.OrderUtilTest.java

/**
 * @verifies return false if order1 ends before order2 starts Checks vice versa
 * @see OrderUtil#checkScheduleOverlap(Order,Order)
 *//* ww w .j  a va  2s  .  c om*/
@Test
public void checkScheduleOverlap_shouldReturnFalseIfOrder1EndsBeforeOrder2Starts() throws Exception {
    Date date = new Date();
    Order order1 = new Order();
    order1.setDateActivated(date);
    order1.setAutoExpireDate(DateUtils.addDays(date, 2)); //Order1 getting expired after 2 days

    Order order2 = new Order();
    order2.setDateActivated(date);
    order2.setScheduledDate(DateUtils.addDays(date, 4)); //Order2 scheduled after 4 days
    order2.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    assertFalse(OrderUtil.checkScheduleOverlap(order1, order2));
    assertFalse(OrderUtil.checkScheduleOverlap(order2, order1));
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• »