Example usage for org.joda.time Interval getStart

List of usage examples for org.joda.time Interval getStart

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. Interval
  6. getStart

Introduction

In this page you can find the example usage for org.joda.time Interval getStart.

Prototype

public DateTime getStart()

Source Link

Document

Gets the start of this time interval, which is inclusive, as a DateTime.

Usage

From source file:com.google.sampling.experiential.server.JDOQueryBuilder.java

License:Open Source License

private void compareDateRange(String key, String range, DateTimeZone jodaTimeZone) {
    DateTime startDate = null;//  w ww  .ja v a 2s .com
    DateTime endDate = null;

    boolean keyCannedDateRange = isKeyCannedDateRange(key);
    boolean rangeCannedDateRange = isCannedDateRange(range);
    if (keyCannedDateRange || rangeCannedDateRange) {
        String rangeName = null;
        if (keyCannedDateRange) {
            rangeName = key.substring(1);
        } else {
            rangeName = range;
        }
        Interval interval;
        if (rangeName.equals("last_week")) {
            interval = getLastWeek(jodaTimeZone);
        } else if (rangeName.equals("last_month")) {
            interval = getLast4Weeks(jodaTimeZone);
        } else {
            throw new IllegalArgumentException("Unknown date range");
        }
        startDate = interval.getStart();
        endDate = interval.getEnd().plusDays(1);

    } else {
        Iterable<String> iterable = Splitter.on("-").split(range);
        Iterator<String> iter = iterable.iterator();
        if (!iter.hasNext()) {
            throw new IllegalArgumentException("Illformed Date Range: " + range);
        }
        String firstDate = iter.next();
        String secondDate = null;
        if (iter.hasNext()) {
            secondDate = iter.next();
        }

        startDate = newDateTimeFromDateString(firstDate, jodaTimeZone);
        endDate = null;
        if (secondDate != null && !secondDate.isEmpty()) {
            endDate = newDateTimeFromDateString(secondDate, jodaTimeZone).plusDays(1);
        } else {
            endDate = startDate.plusDays(1);
        }
    }
    jdoQuery.addFilters("when >= startDateParam", "when <= endDateParam");
    jdoQuery.declareParameters("java.util.Date startDateParam", "java.util.Date endDateParam");
    jdoQuery.addParameterObjects(startDate.toDate(), endDate.toDate());
}

From source file:com.indeed.imhotep.web.QueryServlet.java

License:Apache License

private static String intervalListToString(List<Interval> intervals) {
    if (intervals == null) {
        return "";
    }//w  ww.  j  a  v a 2  s.com

    final StringBuilder sb = new StringBuilder();
    for (Interval interval : intervals) {
        if (sb.length() != 0) {
            sb.append(",");
        }
        sb.append(interval.getStart().toString(yyyymmddhh)).append("-")
                .append(interval.getEnd().toString(yyyymmddhh));
    }
    return sb.toString();
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksForContinuousInfusion(final String patientId,
        final TherapyDto therapy, final Interval taskCreationInterval, final DateTime lastTaskTimestamp,
        final AdministrationTaskCreateActionEnum action) {
    final TherapyDoseDto dose;
    if (therapy instanceof ConstantComplexTherapyDto) {
        dose = getTherapyDoseForComplexTherapyWithRate(((ConstantComplexTherapyDto) therapy).getDoseElement());
    } else if (therapy instanceof OxygenTherapyDto) {
        dose = getTherapyDoseForOxygenTherapy((OxygenTherapyDto) therapy);
    } else {//from   w  w  w .  j a va 2  s . c  o m
        throw new IllegalArgumentException("therapy type not supported for this method");
    }

    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();

    //noinspection OverlyComplexBooleanExpression
    final boolean createStartTask = action == AdministrationTaskCreateActionEnum.PRESCRIBE
            || action == AdministrationTaskCreateActionEnum.MODIFY_BEFORE_START
            || action == AdministrationTaskCreateActionEnum.REISSUE
            || action == AdministrationTaskCreateActionEnum.PREVIEW_TIMES_ON_NEW_PRESCRIPTION
            || (action == AdministrationTaskCreateActionEnum.AUTO_CREATE && lastTaskTimestamp == null);

    if (createStartTask) {
        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.START, taskCreationInterval.getStart(), dose);
        taskRequests.add(startTaskRequest);
    } else if (action == AdministrationTaskCreateActionEnum.MODIFY) {
        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.ADJUST_INFUSION, taskCreationInterval.getStart(), dose);
        taskRequests.add(startTaskRequest);
    }

    final DateTime therapyEnd = therapy.getEnd();
    if (therapyEnd != null && !therapyEnd.isAfter(taskCreationInterval.getEnd())) {
        final NewTaskRequestDto endTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.STOP, therapyEnd, null);
        taskRequests.add(endTaskRequest);
    }

    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksForVariableContinuousInfusion(final String patientId,
        final VariableComplexTherapyDto therapy, final Interval taskCreationInterval,
        final AdministrationTaskCreateActionEnum action, final DateTime lastTaskTimestamp,
        final DateTime actionTimestamp) {
    final DateTime therapyStart = therapy.getStart();

    final Map<HourMinuteDto, TherapyDoseDto> timesWithDosesMap = getTimesDosesMapForVariableTherapies(therapy);

    final HourMinuteDto lastChangeHourMinute = Iterables.getLast(timesWithDosesMap.keySet());

    final boolean isTwoDayInfusion = therapyStart.isAfter(
            therapyStart.withTime(lastChangeHourMinute.getHour(), lastChangeHourMinute.getMinute(), 0, 0));
    final DateTime lastChangeTime = isTwoDayInfusion
            ? therapyStart.withTime(lastChangeHourMinute.getHour(), lastChangeHourMinute.getMinute(), 0, 0)
                    .plusDays(1)/*from w w w .j  a  va 2 s  .c  om*/
            : therapyStart.withTime(lastChangeHourMinute.getHour(), lastChangeHourMinute.getMinute(), 0, 0);

    final HourMinuteDto firstChangeHourMinute = Iterables.getFirst(timesWithDosesMap.keySet(), null);

    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();

    //noinspection OverlyComplexBooleanExpression
    final boolean createStartTask = action == AdministrationTaskCreateActionEnum.PRESCRIBE
            || action == AdministrationTaskCreateActionEnum.MODIFY_BEFORE_START
            || action == AdministrationTaskCreateActionEnum.PREVIEW_TIMES_ON_NEW_PRESCRIPTION
            || action == AdministrationTaskCreateActionEnum.MODIFY
            || (action == AdministrationTaskCreateActionEnum.AUTO_CREATE && lastTaskTimestamp == null);

    if (createStartTask) {
        final TherapyDoseDto dose = timesWithDosesMap.get(firstChangeHourMinute);

        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.START, therapyStart, dose);
        taskRequests.add(startTaskRequest);
    } else if (action == AdministrationTaskCreateActionEnum.REISSUE) {
        final TherapyDoseDto dose;
        final DateTime restartTime;
        if (actionTimestamp.isBefore(therapyStart)) {
            dose = timesWithDosesMap.get(firstChangeHourMinute);
            restartTime = therapyStart;
        } else if (actionTimestamp.isAfter(lastChangeTime)) {
            dose = timesWithDosesMap.get(lastChangeHourMinute);
            restartTime = actionTimestamp;
        } else {
            dose = getPreviousAdministrationTimeWithDose(actionTimestamp, timesWithDosesMap, true).getSecond();
            restartTime = actionTimestamp;
        }
        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.START, restartTime, dose);
        taskRequests.add(startTaskRequest);
    }

    Pair<DateTime, TherapyDoseDto> nextTimeWithDose = getNextAdministrationTimeWithDose(action, therapy,
            therapyStart, timesWithDosesMap, false);

    while (!nextTimeWithDose.getFirst().isAfter(taskCreationInterval.getEnd())
            && !nextTimeWithDose.getFirst().isAfter(lastChangeTime)) {
        if (nextTimeWithDose.getFirst().isAfter(taskCreationInterval.getStart())) {
            taskRequests
                    .add(createMedicationTaskRequest(patientId, therapy, AdministrationTypeEnum.ADJUST_INFUSION,
                            nextTimeWithDose.getFirst(), nextTimeWithDose.getSecond()));
        }
        nextTimeWithDose = getNextAdministrationTimeWithDose(action, therapy, nextTimeWithDose.getFirst(),
                timesWithDosesMap, false);
    }

    final DateTime therapyEnd = therapy.getEnd();
    if (therapyEnd != null && !therapyEnd.isAfter(taskCreationInterval.getEnd())) {
        final NewTaskRequestDto endTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.STOP, therapyEnd, null);
        taskRequests.add(endTaskRequest);
    }
    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksForRecurringContinuousInfusion(final String patientId,
        final TherapyDto therapy, final Interval taskCreationInterval,
        final AdministrationTaskCreateActionEnum action, final DateTime lastTaskTimestamp,
        final DateTime actionTimestamp) {
    final DateTime therapyStart = therapy.getStart();
    final DateTime therapyEnd = therapy.getEnd();

    final Map<HourMinuteDto, TherapyDoseDto> timesWithDosesMap = getTimesDosesMapForVariableTherapies(
            (VariableTherapy) therapy);/*from   w  ww. j a v  a  2s .c  o  m*/

    final Pair<DateTime, TherapyDoseDto> lastOrCurrentTimeDose = getPreviousAdministrationTimeWithDose(
            therapyStart, timesWithDosesMap, true);

    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();

    //noinspection OverlyComplexBooleanExpression
    final boolean createStartTask = action == AdministrationTaskCreateActionEnum.PRESCRIBE
            || action == AdministrationTaskCreateActionEnum.PREVIEW_TIMES_ON_NEW_PRESCRIPTION
            || action == AdministrationTaskCreateActionEnum.MODIFY_BEFORE_START
            || (action == AdministrationTaskCreateActionEnum.AUTO_CREATE && lastTaskTimestamp == null);

    if (createStartTask) {
        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.START, therapyStart, lastOrCurrentTimeDose.getSecond());
        taskRequests.add(startTaskRequest);
    } else if (action == AdministrationTaskCreateActionEnum.MODIFY) {
        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.ADJUST_INFUSION, therapyStart, lastOrCurrentTimeDose.getSecond());
        taskRequests.add(startTaskRequest);
    } else if (action == AdministrationTaskCreateActionEnum.REISSUE) {
        final Pair<DateTime, TherapyDoseDto> reissueTimeDose = getPreviousAdministrationTimeWithDose(
                actionTimestamp, timesWithDosesMap, true);

        final NewTaskRequestDto startTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.START, actionTimestamp, reissueTimeDose.getSecond());
        taskRequests.add(startTaskRequest);
    }

    Pair<DateTime, TherapyDoseDto> nextTime = getNextAdministrationTimeWithDose(action, therapy,
            taskCreationInterval.getStart(), timesWithDosesMap, false);

    while (!nextTime.getFirst().isAfter(taskCreationInterval.getEnd())) {
        taskRequests.add(createMedicationTaskRequest(patientId, therapy, AdministrationTypeEnum.ADJUST_INFUSION,
                nextTime.getFirst(), nextTime.getSecond()));
        nextTime = getNextAdministrationTimeWithDose(action, therapy, nextTime.getFirst(), timesWithDosesMap,
                false);
    }

    if (therapyEnd != null && !therapyEnd.isAfter(taskCreationInterval.getEnd())) {
        final NewTaskRequestDto endTaskRequest = createMedicationTaskRequest(patientId, therapy,
                AdministrationTypeEnum.STOP, therapyEnd, null);
        taskRequests.add(endTaskRequest);
    }
    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksForConstantComplexTherapyWithRate(final String patientId,
        final ConstantComplexTherapyDto therapy, final Interval taskCreationInterval,
        final Map<HourMinuteDto, TherapyDoseDto> timesWithDosesMap,
        final AdministrationTaskCreateActionEnum action) {
    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();
    if (!timesWithDosesMap.isEmpty()) {
        Pair<DateTime, TherapyDoseDto> next = getNextAdministrationTimeWithDose(action, therapy,
                taskCreationInterval.getStart(), timesWithDosesMap,
                action.isTaskCreationIntervalStartIncluded());

        DateTime nextTaskTime = next.getFirst();

        final int duration = therapy.getDoseElement().getDuration();
        while (!isAfterTherapyEnd(therapy, nextTaskTime)) {
            if (nextTaskTime.isAfter(taskCreationInterval.getEnd())) {
                break;
            }//from  w w  w. j  a v a2  s .c  om

            final String groupUUId = action == AdministrationTaskCreateActionEnum.PREVIEW_TIMES_ON_NEW_PRESCRIPTION
                    ? null
                    : administrationUtils
                            .generateGroupUUId(Opt.of(therapy.getStart()).orElseGet(DateTime::now));

            taskRequests.add(createMedicationTaskRequestWithGroupUUId(patientId, groupUUId, therapy,
                    AdministrationTypeEnum.START, nextTaskTime, next.getSecond()));

            final DateTime plannedStopTaskTime = nextTaskTime.plusMinutes(duration);
            final DateTime actualStopTaskTime = isAfterTherapyEnd(therapy, plannedStopTaskTime)
                    ? therapy.getEnd()
                    : plannedStopTaskTime;

            taskRequests.add(createMedicationTaskRequestWithGroupUUId(patientId, groupUUId, therapy,
                    AdministrationTypeEnum.STOP, actualStopTaskTime, null));

            next = getNextAdministrationTimeWithDose(action, therapy, nextTaskTime, timesWithDosesMap, false);
            nextTaskTime = next.getFirst();
        }
    }

    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksFromAdministrationTimes(final String patientId,
        final TherapyDto therapy, final Interval taskCreationInterval,
        final Map<HourMinuteDto, TherapyDoseDto> timesWithDosesMap,
        final AdministrationTaskCreateActionEnum action) {
    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();

    if (!timesWithDosesMap.isEmpty()) {
        Pair<DateTime, TherapyDoseDto> nextTime = getNextAdministrationTimeWithDose(action, therapy,
                taskCreationInterval.getStart(), timesWithDosesMap,
                action.isTaskCreationIntervalStartIncluded());

        while (!nextTime.getFirst().isAfter(taskCreationInterval.getEnd())) {
            taskRequests.add(createMedicationTaskRequest(patientId, therapy, AdministrationTypeEnum.START,
                    nextTime.getFirst(), nextTime.getSecond()));
            nextTime = getNextAdministrationTimeWithDose(action, therapy, nextTime.getFirst(),
                    timesWithDosesMap, false);
        }/* ww  w.  j  a  va 2 s .c o  m*/
    }

    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private List<NewTaskRequestDto> createTasksForVariableComplexTherapy(final String patientId,
        final VariableComplexTherapyDto therapy, final Interval taskCreationInterval,
        final Map<HourMinuteDto, TherapyDoseDto> timesWithDosesMap,
        final AdministrationTaskCreateActionEnum action) {
    final List<TimedComplexDoseElementDto> timedDoseElements = therapy.getTimedDoseElements();
    final List<NewTaskRequestDto> taskRequests = new ArrayList<>();
    if (!timesWithDosesMap.isEmpty()) {
        Pair<DateTime, TherapyDoseDto> next = getNextAdministrationTimeWithDose(action, therapy,
                taskCreationInterval.getStart(), timesWithDosesMap,
                action.isTaskCreationIntervalStartIncluded());

        DateTime nextTaskTime = next.getFirst();

        if (action == AdministrationTaskCreateActionEnum.REISSUE) // move on to first next START task in taskCreationInterval
        {/*ww  w .  j  a  va2 s. c  om*/
            while (!isFirstPrescribedComplexDoseElement(timedDoseElements, nextTaskTime)) {
                next = getNextAdministrationTimeWithDose(AdministrationTaskCreateActionEnum.REISSUE, therapy,
                        nextTaskTime, timesWithDosesMap, false);

                nextTaskTime = next.getFirst();
            }
        }

        final Map<HourMinuteDto, Integer> durations = therapy.getTimedDoseElements().stream().collect(Collectors
                .toMap(TimedComplexDoseElementDto::getDoseTime, d -> d.getDoseElement().getDuration()));

        final boolean preview = action == AdministrationTaskCreateActionEnum.PREVIEW_TIMES_ON_NEW_PRESCRIPTION;
        String groupUUId = null;
        while (!isAfterTherapyEnd(therapy, nextTaskTime)) {
            final boolean isFirst = isFirstPrescribedComplexDoseElement(timedDoseElements, nextTaskTime);
            final boolean isLast = isLastPrescribedComplexDoseElement(timedDoseElements, nextTaskTime);
            if (nextTaskTime.isAfter(taskCreationInterval.getEnd()) && isFirst) {
                break;
            }

            if (isFirst && !preview) {
                groupUUId = administrationUtils
                        .generateGroupUUId(Opt.of(therapy.getStart()).orElseGet(DateTime::now));
            }

            Preconditions.checkArgument(preview || groupUUId != null,
                    "groupUUId must be set for start administration!");

            taskRequests.add(createMedicationTaskRequestWithGroupUUId(patientId, groupUUId, therapy,
                    isFirst ? AdministrationTypeEnum.START : AdministrationTypeEnum.ADJUST_INFUSION,
                    nextTaskTime, next.getSecond()));

            if (isLast) {
                final DateTime stopTaskTime = nextTaskTime
                        .plusMinutes(getDoseDurationForDate(durations, nextTaskTime));
                final boolean stopTimeAfterTherapyEnd = isAfterTherapyEnd(therapy, stopTaskTime);
                taskRequests.add(createMedicationTaskRequestWithGroupUUId(patientId, groupUUId, therapy,
                        AdministrationTypeEnum.STOP, stopTimeAfterTherapyEnd ? therapy.getEnd() : stopTaskTime,
                        null));

                if (stopTimeAfterTherapyEnd) {
                    break;
                }
            }

            next = getNextAdministrationTimeWithDose(action, therapy, next.getFirst(), timesWithDosesMap,
                    false);
            nextTaskTime = next.getFirst();

            if (!isLast && isAfterTherapyEnd(therapy, nextTaskTime)) {
                taskRequests.add(createMedicationTaskRequestWithGroupUUId(patientId, groupUUId, therapy,
                        AdministrationTypeEnum.STOP, therapy.getEnd(), null));
            }
        }
    }

    return taskRequests;
}

From source file:com.marand.thinkmed.medications.administration.impl.AdministrationTaskCreatorImpl.java

License:Open Source License

private Opt<Pair<DateTime, TherapyDoseDto>> getTimedDoseForVariableDaysTherapy(
        final VariableSimpleTherapyDto therapy, final Interval taskCreationInterval,
        final AdministrationTaskCreateActionEnum action, final TimedSimpleDoseElementDto timedDoseElement,
        final DateTime date) {
    final HourMinuteDto doseTime = timedDoseElement.getDoseTime();
    final DateTime administrationDateTime = date.withTimeAtStartOfDay().plusHours(doseTime.getHour())
            .plusMinutes(doseTime.getMinute());
    final TherapyDoseDto dose = getTherapyDoseForSimpleTherapy(timedDoseElement.getDoseElement(), therapy);

    final DateTime taskCreationIntervalEnd = taskCreationInterval.getEnd();
    final boolean inTaskCreationInterval;
    //noinspection IfMayBeConditional
    if (action.isTaskCreationIntervalStartIncluded()) {
        inTaskCreationInterval = taskCreationInterval.contains(administrationDateTime)
                || taskCreationIntervalEnd.equals(administrationDateTime);
    } else {/*from   ww  w.jav a  2 s . c o m*/
        inTaskCreationInterval = taskCreationInterval.getStart().isBefore(administrationDateTime)
                && (taskCreationIntervalEnd.isAfter(administrationDateTime)
                        || taskCreationIntervalEnd.equals(administrationDateTime));
    }

    if (dose != null && dose.getNumerator() != null && inTaskCreationInterval) {
        return Opt.of(Pair.of(administrationDateTime, dose));
    }
    return Opt.none();
}

From source file:com.marand.thinkmed.medications.business.impl.DefaultMedicationsBo.java

License:Open Source License

@Override
public boolean isTherapyActive(final List<String> daysOfWeek, final Integer dosingDaysFrequency,
        final Interval therapyInterval, final DateTime when) {
    if (therapyInterval.overlap(Intervals.wholeDay(when)) == null) {
        return false;
    }//from ww w .j  a  va  2 s .c  o m
    if (daysOfWeek != null) {
        boolean activeDay = false;
        final String searchDay = MedicationsEhrUtils.dayOfWeekToEhrEnum(when).name();
        for (final String day : daysOfWeek) {
            if (day.equals(searchDay)) {
                activeDay = true;
            }
        }
        if (!activeDay) {
            return false;
        }
    }
    if (dosingDaysFrequency != null) {
        final int daysFromStart = Days
                .daysBetween(therapyInterval.getStart().withTimeAtStartOfDay(), when.withTimeAtStartOfDay())
                .getDays();
        if (daysFromStart % dosingDaysFrequency != 0) {
            return false;
        }
    }
    return true;
}