Example usage for org.joda.time Interval Interval

Introduction

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

Prototype

public Interval(Object interval, Chronology chronology) 

Source Link

Document

Constructs a time interval by converting or copying from another object, overriding the chronology.

Usage

From source file:com.manydesigns.portofino.calendar.AbstractWeek.java

License:Open Source License

public AbstractWeek(DateMidnight weekStart, DateMidnight weekEnd) {
    this.weekStart = weekStart;
    this.weekEnd = weekEnd;
    weekInterval = new Interval(weekStart, weekEnd);
    AbstractMonthView.logger.debug("Week interval: {}", weekInterval);

    AbstractMonthView.logger.debug("Initializing days");
    days = createDaysArray(7);//from www .j a  v a 2 s  . co  m
    DateMidnight dayStart = weekStart;
    for (int i = 0; i < 7; i++) {
        DateMidnight dayEnd = dayStart.plusDays(1);
        days[i] = createDay(dayStart, dayEnd);

        dayStart = dayEnd;
    }
}

---

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

License:Open Source License

private List<Interval> removeInactiveTherapyDaysFromTasksInterval(final TherapyDto therapy,
        final DateTime start, final DateTime end) {
    final DateTime therapyStart = therapy.getStart();
    final Integer daysFrequency = therapy.getDosingDaysFrequency();

    final List<Interval> intervals = new ArrayList<>();

    DateTime intervalStart = new DateTime(start);
    DateTime intervalEnd = intervalStart.withTimeAtStartOfDay().plusDays(1);

    final DateTime firstDayStart = intervalStart.withTimeAtStartOfDay();

    boolean validDayOfWeek = isInValidDaysOfWeek(intervalStart, therapy.getDaysOfWeek());
    boolean validFrequency = isInValidDaysFrequency(intervalStart, therapyStart, daysFrequency);
    boolean previousDayWasValid = validDayOfWeek && validFrequency;
    if (!previousDayWasValid) {
        intervalStart = firstDayStart.plusDays(1);
    }/*from   w  w w  .jav  a 2  s .c  om*/
    boolean validInFutureDays = false;
    while (intervalEnd.isBefore(end) || intervalEnd.equals(end)) {
        validDayOfWeek = isInValidDaysOfWeek(intervalEnd, therapy.getDaysOfWeek());
        validFrequency = isInValidDaysFrequency(intervalEnd, therapyStart, daysFrequency);
        if (validDayOfWeek && validFrequency) {
            previousDayWasValid = true;
        } else {
            if (previousDayWasValid) {
                intervals.add(new Interval(intervalStart, intervalEnd));
            }
            previousDayWasValid = false;
            intervalStart = intervalEnd.plusDays(1);
        }
        intervalEnd = intervalEnd.plusDays(1);
        validInFutureDays = true;
    }
    if (previousDayWasValid && validInFutureDays || intervalEnd.minusDays(1).isBefore(end)) {
        if (!intervalStart.isAfter(end)) {
            intervals.add(new Interval(intervalStart, end));
        }
    }
    return intervals;
}

---

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

License:Open Source License

MedicationForWarningsSearchDto buildWarningSearchDto(final MedicationTimingCluster medicationTimingCluster,
        final Long medicationId, final String route, final Double doseAmount, final String doseUnit) {
    final MedicationForWarningsSearchDto summary = new MedicationForWarningsSearchDto();
    final DateTime start = DataValueUtils.getDateTime(medicationTimingCluster.getStartDate());
    final DateTime stop = DataValueUtils.getDateTime(medicationTimingCluster.getStopDate());
    summary.setEffective(new Interval(start != null ? start : Intervals.INFINITE.getStart(),
            stop != null ? stop : Intervals.INFINITE.getEnd()));
    final MedicationDto medicationDto = getMedication(medicationId);
    if (medicationDto == null) {
        throw new IllegalArgumentException("Medication with id: " + medicationId + " not found!");
    }/*from  ww w.j ava2  s  .c o  m*/
    summary.setName(medicationDto.getName());
    summary.setShortName(medicationDto.getShortName());
    summary.setId(medicationDto.getId());

    final int dailyFrequency = getMedicationDailyFrequency(medicationTimingCluster);
    summary.setFrequency(dailyFrequency);
    summary.setFrequencyUnit("/d");

    final boolean onlyOnce = isOnlyOnceThenEx(medicationTimingCluster);
    summary.setOnlyOnce(onlyOnce);
    summary.setRouteCode(route);
    summary.setDoseAmount(doseAmount);
    summary.setDoseUnit(doseUnit);
    summary.setProspective(false);
    return summary;
}

---

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 a  v a  2  s  .  com
    }

    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));
}

---

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

License:Open Source License

private boolean handleSimilarAndLinkedTherapies(final List<TherapyDocumentationData> admissionTherapies,
        final List<TherapyDocumentationData> dischargeTherapies, final List<TherapyDocumentationData> therapies,
        final Set<TherapyDocumentationData> alreadyHandled,
        final Pair<MedicationOrderComposition, MedicationInstructionInstruction> therapyToCompare,
        final TherapyDto convertedTherapy, final Map<Long, MedicationDataForTherapyDto> medicationsDataMap,
        final Interval therapyInterval, final DateTime centralCaseEnd, final DateTime when) {
    final Pair<TherapyLinkType, TherapyDocumentationData> pair = getLinkedToTherapyPair(admissionTherapies,
            therapies, therapyToCompare);

    if (pair.getFirst() == TherapyLinkType.REGULAR_LINK) {
        final TherapyDocumentationData linkedToTherapy = pair.getSecond();
        final Interval interval = linkedToTherapy.findIntervalForId(
                TherapyIdUtils.createTherapyId(linkedToTherapy.getTherapy().getCompositionUid(),
                        linkedToTherapy.getTherapy().getEhrOrderName()));

        if (isDischargeTherapy(therapyInterval, centralCaseEnd, when)) {
            if (therapies.contains(linkedToTherapy)) {
                therapies.remove(linkedToTherapy);
            }// w w w.j av  a 2s  .c o m
            if (admissionTherapies.contains(linkedToTherapy)) {
                admissionTherapies.remove(linkedToTherapy);
            }
            final TherapyDocumentationData dischargeTherapy = createTherapyData(therapyToCompare,
                    convertedTherapy, new Interval(interval.getStart(), therapyInterval.getEnd()));
            dischargeTherapies.add(dischargeTherapy);
        } else {
            final Interval newInterval = new Interval(interval.getStart(), therapyInterval.getEnd());
            linkedToTherapy.addInterval(TherapyIdUtils.createTherapyId(convertedTherapy.getCompositionUid(),
                    convertedTherapy.getEhrOrderName()), newInterval);
            linkedToTherapy.removeInterval(
                    TherapyIdUtils.createTherapyId(linkedToTherapy.getTherapy().getCompositionUid(),
                            linkedToTherapy.getTherapy().getEhrOrderName()),
                    interval);
            linkedToTherapy.setTherapy(convertedTherapy);
        }
        return true;
    }
    if (pair.getFirst() == TherapyLinkType.LINKED_TO_ADMISSION_THERAPY
            && alreadyHandled.contains(pair.getSecond())) {
        if (isDischargeTherapy(therapyInterval, centralCaseEnd, when)) {
            final TherapyDocumentationData newDischargeTherapy = createTherapyData(therapyToCompare,
                    convertedTherapy, therapyInterval);
            dischargeTherapies.add(newDischargeTherapy);
        } else {
            final TherapyDocumentationData linkedToTherapy = pair.getSecond();
            final Interval interval = linkedToTherapy.findIntervalForId(
                    TherapyIdUtils.createTherapyId(linkedToTherapy.getTherapy().getCompositionUid(),
                            linkedToTherapy.getTherapy().getEhrOrderName()));
            final Interval newInterval = new Interval(interval.getStart(), therapyInterval.getEnd());
            linkedToTherapy.addInterval(TherapyIdUtils.createTherapyId(convertedTherapy.getCompositionUid(),
                    convertedTherapy.getEhrOrderName()), newInterval);
            linkedToTherapy.removeInterval(
                    TherapyIdUtils.createTherapyId(linkedToTherapy.getTherapy().getCompositionUid(),
                            linkedToTherapy.getTherapy().getEhrOrderName()),
                    interval);
        }
        return true;
    }

    final Pair<TherapySimilarityType, TherapyDocumentationData> similarityTypePair = getSimilarTherapyPair(
            admissionTherapies, therapies, therapyToCompare, medicationsDataMap);

    if (similarityTypePair.getFirst() == TherapySimilarityType.SIMILAR_TO_ADMISSION_THERAPY) {
        final TherapyDocumentationData similarTherapy = similarityTypePair.getSecond();

        if (isDischargeTherapy(therapyInterval, centralCaseEnd, when)) {
            final TherapyDocumentationData newTherapy = createTherapyData(therapyToCompare, convertedTherapy,
                    therapyInterval);
            dischargeTherapies.add(newTherapy);
        } else {
            similarTherapy.addInterval(TherapyIdUtils.createTherapyId(convertedTherapy.getCompositionUid(),
                    convertedTherapy.getEhrOrderName()), therapyInterval);
        }
        return true;
    }
    if (similarityTypePair.getFirst() == TherapySimilarityType.SIMILAR) {
        final TherapyDocumentationData similarTherapy = similarityTypePair.getSecond();

        if (isDischargeTherapy(therapyInterval, centralCaseEnd, when)) {
            if (therapies.contains(similarTherapy)) {
                therapies.remove(similarTherapy);
            }
            if (admissionTherapies.contains(similarTherapy)) {
                admissionTherapies.remove(similarTherapy);
            }
            final TherapyDocumentationData dischargeTherapy = createTherapyData(therapyToCompare,
                    convertedTherapy, therapyInterval);

            for (final Pair<String, Interval> pair1 : similarTherapy.getIntervals()) {
                dischargeTherapy.addInterval(pair1.getFirst(), pair1.getSecond());
            }
            dischargeTherapies.add(dischargeTherapy);
        } else {
            similarTherapy.addInterval(TherapyIdUtils.createTherapyId(convertedTherapy.getCompositionUid(),
                    convertedTherapy.getEhrOrderName()), therapyInterval);
            similarTherapy.setTherapy(convertedTherapy);
        }
        return true;
    }

    return false;
}

---

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

License:Open Source License

@Override
@Transactional/*  ww w  . j a  va 2 s . com*/
@ServiceMethod(auditing = @Auditing(level = Level.FULL))
public DateTime findPreviousTaskForTherapy(final String patientId, final String compositionUid,
        final String ehrOrderName, final DateTime when) {
    Pair<MedicationOrderComposition, MedicationInstructionInstruction> instructionPair = medicationsOpenEhrDao
            .getTherapyInstructionPair(patientId, compositionUid, ehrOrderName);

    while (instructionPair != null) {
        final List<AdministrationDto> administrations = administrationProvider
                .getTherapiesAdministrations(patientId, Collections.singletonList(instructionPair), null);

        final String therapyId = TherapyIdUtils.createTherapyId(instructionPair.getFirst(),
                instructionPair.getSecond());

        final DateTime lastTask = medicationsTasksProvider.findLastAdministrationTaskTimeForTherapy(patientId,
                therapyId, new Interval(when.minusDays(10), when), false).orElse(null);

        final DateTime lastAdministration = administrations.stream()
                .filter(a -> a.getAdministrationResult() != AdministrationResultEnum.NOT_GIVEN)
                .map(AdministrationDto::getAdministrationTime).max(Comparator.naturalOrder()).orElse(null);

        final DateTime lastTime = getMostRecent(lastTask, lastAdministration);
        if (lastTime != null) {
            return lastTime;
        }

        instructionPair = getInstructionFromLink(patientId, instructionPair.getSecond(), EhrLinkType.UPDATE,
                true);
    }
    return null;
}

---

From source file:com.marand.thinkmed.medications.business.util.MedicationsEhrUtils.java

License:Open Source License

public static Interval getInstructionInterval(final OrderActivity.MedicationTimingCluster medicationTiming) {
    final DateTime start = DataValueUtils.getDateTime(medicationTiming.getStartDate());
    final DateTime stop = medicationTiming.getStopDate() != null
            ? DataValueUtils.getDateTime(medicationTiming.getStopDate())
            : null;/*from  w w  w. ja  va2s.c om*/

    return stop != null ? new Interval(start, stop) : Intervals.infiniteFrom(start);
}

---

From source file:com.marand.thinkmed.medications.connector.impl.demo.DemoMedicationsConnector.java

License:Open Source License

@Override
public Interval getLastDischargedCentralCaseEffectiveInterval(final String patientId) {
    return new Interval(new DateTime(2014, 10, 10, 12, 0), new DateTime(2014, 11, 15, 12, 0));
}

---

From source file:com.marand.thinkmed.medications.dao.openehr.MedicationsOpenEhrDao.java

License:Open Source License

public List<Interval> getPatientBaselineInfusionIntervals(final String patientId,
        final Interval searchInterval) {
    final String ehrId = currentSession().findEhr(patientId);
    if (!StringUtils.isEmpty(ehrId)) {
        currentSession().useEhr(ehrId);// w  ww  .  j a  v  a  2  s  . co  m
        final StringBuilder sb = new StringBuilder();
        sb.append("SELECT i/activities[at0001]/description[at0002]/items[at0010]/items[at0012]/value, "
                + "i/activities[at0001]/description[at0002]/items[at0010]/items[at0013]/value")
                .append(" FROM EHR[ehr_id/value='").append(ehrId).append("']")
                .append(" CONTAINS Composition c[openEHR-EHR-COMPOSITION.encounter.v1]")
                .append(" CONTAINS Instruction i[openEHR-EHR-INSTRUCTION.medication.v1]")
                .append(" CONTAINS Cluster cl[openEHR-EHR-CLUSTER.infusion_details.v1]")
                .append(" WHERE c/name/value = 'Medication order'")
                .append(" AND cl/items[at0007]/value/defining_code/code_string='")
                .append(InfusionAdministrationDetailsPurpose.BASELINE_ELECTROLYTE_INFUSION.getTerm().getCode())
                .append('\'');
        appendMedicationTimingIntervalCriterion(sb, searchInterval);

        return queryEhrContent(sb.toString(), (resultRow, hasNext) -> {
            final DvDateTime dvTherapyStart = (DvDateTime) resultRow[0];
            final DvDateTime dvTherapyEnd = (DvDateTime) resultRow[1];
            if (dvTherapyEnd != null) {
                return new Interval(DataValueUtils.getDateTime(dvTherapyStart),
                        DataValueUtils.getDateTime(dvTherapyEnd));
            }
            return Intervals.infiniteFrom(DataValueUtils.getDateTime(dvTherapyStart));
        });
    }
    return new ArrayList<>();
}

---

From source file:com.marand.thinkmed.medications.dao.openehr.OpenEhrMedicationsDao.java

License:Open Source License

@Override
public List<Interval> getPatientBaselineInfusionIntervals(final Long patientId, final Interval searchInterval) {
    final String ehrId = currentSession().findEhr(patientId);
    if (!StringUtils.isEmpty(ehrId)) {
        currentSession().useEhr(ehrId);/*  www.  ja  v a 2  s  .  co  m*/
        final StringBuilder sb = new StringBuilder();
        sb.append("SELECT i/activities[at0001]/description[at0002]/items[at0010]/items[at0012]/value, "
                + "i/activities[at0001]/description[at0002]/items[at0010]/items[at0013]/value")
                .append(" FROM EHR[ehr_id/value='").append(ehrId).append("']")
                .append(" CONTAINS Composition c[openEHR-EHR-COMPOSITION.encounter.v1]")
                .append(" CONTAINS Instruction i[openEHR-EHR-INSTRUCTION.medication.v1]")
                .append(" CONTAINS Cluster cl[openEHR-EHR-CLUSTER.infusion_details.v1]")
                .append(" WHERE c/name/value = 'Medication order'")
                .append(" AND cl/items[at0007]/value/defining_code/code_string='")
                .append(InfusionAdministrationDetailsPurpose.BASELINE_ELECTROLYTE_INFUSION.getTerm().getCode())
                .append('\'');
        appendMedicationTimingIntervalCriterion(sb, searchInterval);

        return queryEhrContent(sb.toString(), new ResultRowProcessor<Object[], Interval>() {

            @Override
            public Interval process(final Object[] resultRow, final boolean hasNext)
                    throws ProcessingException {
                final DvDateTime dvTherapyStart = (DvDateTime) resultRow[0];
                final DvDateTime dvTherapyEnd = (DvDateTime) resultRow[1];
                if (dvTherapyEnd != null) {
                    return new Interval(DataValueUtils.getDateTime(dvTherapyStart),
                            DataValueUtils.getDateTime(dvTherapyEnd));
                }
                return Intervals.infiniteFrom(DataValueUtils.getDateTime(dvTherapyStart));
            }
        });
    }
    return new ArrayList<>();
}

---

• «
• 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
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• »