Example usage for org.joda.time Interval getEnd

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

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

Introduction

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

Prototype

public DateTime getEnd()

Source Link

Document

Gets the end of this time interval, which is exclusive, as a DateTime.

Usage

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

License:Apache License

private static String intervalListToString(List<Interval> intervals) {
    if (intervals == null) {
        return "";
    }/*  ww  w. j  a va 2s . c  o  m*/

    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.jav  a2s .co  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 .ja  v a  2s  .  com*/
            : 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);//  ww w  . j  a v  a  2  s  . com

    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 a 2s  .c o  m*/

            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);
        }/*from  w  w w  . j a va2  s . c om*/
    }

    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
        {/* www.  ja v a  2 s . c o m*/
            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 List<NewTaskRequestDto> createTasksForVariableDaysTherapy(final String patientId,
        final VariableSimpleTherapyDto therapy, final Interval taskCreationInterval,
        final AdministrationTaskCreateActionEnum action) {
    final Map<DateTime, TherapyDoseDto> timesWithDosesMap = new HashMap<>();

    for (final TimedSimpleDoseElementDto timedDoseElement : therapy.getTimedDoseElements()) {
        getTimedDoseForVariableDaysTherapy(therapy, taskCreationInterval, action, timedDoseElement,
                timedDoseElement.getDate()).forEach(e -> timesWithDosesMap.put(e.getFirst(), e.getSecond()));
    }/* ww  w.j  a v  a  2 s . c o m*/

    final DateTime lastAdministrationDateTime = timesWithDosesMap.entrySet().stream().map(Map.Entry::getKey)
            .max(Comparator.naturalOrder()).orElse(null);

    final boolean therapyContinuesAfterLastDefinedDose = lastAdministrationDateTime != null
            && lastAdministrationDateTime.isBefore(taskCreationInterval.getEnd());
    if (therapyContinuesAfterLastDefinedDose) {
        //repeat last day
        final DateTime lastDayStart = lastAdministrationDateTime.withTimeAtStartOfDay();
        final List<TimedSimpleDoseElementDto> lastDayDoses = therapy.getTimedDoseElements().stream()
                .filter(t -> t.getDate().withTimeAtStartOfDay().equals(lastDayStart))
                .collect(Collectors.toList());

        DateTime nextDay = lastDayStart.plusDays(1);
        while (taskCreationInterval.contains(nextDay)) {
            for (final TimedSimpleDoseElementDto timedDoseElement : lastDayDoses) {
                getTimedDoseForVariableDaysTherapy(therapy, taskCreationInterval, action, timedDoseElement,
                        nextDay).forEach(e -> timesWithDosesMap.put(e.getFirst(), e.getSecond()));
            }
            nextDay = nextDay.plusDays(1);
        }
    }

    return timesWithDosesMap.keySet().stream().sorted(Comparator.naturalOrder())
            .filter(administrationTime -> !administrationTime.isAfter(taskCreationInterval.getEnd()))
            .map(administrationTime -> createMedicationTaskRequest(patientId, therapy,
                    AdministrationTypeEnum.START, administrationTime,
                    timesWithDosesMap.get(administrationTime)))
            .collect(Collectors.toList());
}

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 w w  w .jav  a2s  .  co  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

DocumentationTherapiesDto getTherapiesForDocumentation(final String patientId, final String centralCaseId,
        final Interval centralCaseEffective,
        final List<Pair<MedicationOrderComposition, MedicationInstructionInstruction>> instructionPairs,
        final Map<Long, MedicationDataForTherapyDto> medicationsDataMap, final boolean isOutpatient,
        final DateTime when, final Locale locale) {
    final List<TherapyDocumentationData> therapies = new ArrayList<>();
    final List<TherapyDocumentationData> dischargeTherapies = new ArrayList<>();
    final List<TherapyDocumentationData> admissionTherapies = new ArrayList<>();
    final List<TherapyDto> taggedTherapiesForPrescription = new ArrayList<>();

    if (!isOutpatient) {
        //use taggedTherapiesForPrescription to display medication on discharge list for EMRAM
        final List<MedicationOnDischargeComposition> dischargeCompositions = medicationsOpenEhrDao
                .findMedicationOnDischargeCompositions(patientId, centralCaseEffective);

        for (final MedicationOnDischargeComposition dischargeComposition : dischargeCompositions) {
            final TherapyDto convertedTherapy = convertInstructionToTherapyDtoWithDisplayValues(
                    dischargeComposition,
                    dischargeComposition.getMedicationDetail().getMedicationInstruction().get(0), null, null,
                    when, true, locale);

            taggedTherapiesForPrescription.add(convertedTherapy);
        }//from  w  ww. j ava 2  s . co  m
    }

    final Set<TherapyDocumentationData> alreadyHandled = new HashSet<>();

    final boolean isOutpatientOrLastsOneDay = isOutpatient
            || Intervals.durationInDays(centralCaseEffective) <= 1;

    for (final Pair<MedicationOrderComposition, MedicationInstructionInstruction> instructionPair : instructionPairs) {
        final DateTime therapyStart = DataValueUtils.getDateTime(
                instructionPair.getSecond().getOrder().get(0).getMedicationTiming().getStartDate());
        final DateTime therapyEnd = DataValueUtils
                .getDateTime(instructionPair.getSecond().getOrder().get(0).getMedicationTiming().getStopDate());

        final TherapyDto convertedTherapy = convertInstructionToTherapyDtoWithDisplayValues(
                instructionPair.getFirst(), instructionPair.getSecond(), null, null, when, true, locale);

        if (!areAllIngredientsSolutions(convertedTherapy)) {
            final Interval therapyInterval = new Interval(therapyStart,
                    therapyEnd != null ? therapyEnd : Intervals.INFINITE.getEnd());

            final boolean handled = handleSimilarAndLinkedTherapies(admissionTherapies, dischargeTherapies,
                    therapies, alreadyHandled, instructionPair, convertedTherapy, medicationsDataMap,
                    therapyInterval, centralCaseEffective.getEnd(), when);

            final TherapyDocumentationData therapy = createTherapyData(instructionPair, convertedTherapy,
                    therapyInterval);
            alreadyHandled.add(therapy);

            if (!handled) {
                if (isOutpatientOrLastsOneDay) {
                    if (therapyInterval.overlaps(Intervals.wholeDay(centralCaseEffective.getStart()))) {
                        therapies.add(therapy);
                    }
                } else {
                    boolean isAdmission = false;
                    if (therapyInterval.overlaps(Intervals.wholeDay(centralCaseEffective.getStart()))) {
                        admissionTherapies.add(therapy);
                        isAdmission = true;
                    }

                    boolean isDischarge = false;
                    if (isDischargeTherapy(therapyInterval, centralCaseEffective.getEnd(), when)) {
                        dischargeTherapies.add(therapy);
                        isDischarge = true;
                    }

                    if (!isAdmission && !isDischarge) {
                        if (therapyInterval.overlaps(centralCaseEffective)) {
                            therapies.add(therapy);
                        }
                    }
                }
            }
        }
    }

    return new DocumentationTherapiesDto(getTherapyDisplayValuesForDocumentation(therapies, locale),
            getTherapyDisplayValuesForDocumentation(dischargeTherapies, locale),
            getTherapyDisplayValuesForDocumentation(admissionTherapies, locale),
            getTherapyDisplayValues(taggedTherapiesForPrescription, locale));
}