Example usage for org.apache.commons.lang.time DateUtils isSameDay

List of usage examples for org.apache.commons.lang.time DateUtils isSameDay

Introduction

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

Prototype

public static boolean isSameDay(Calendar cal1, Calendar cal2) 

Source Link

Document

Checks if two calendar objects are on the same day ignoring time.

28 Mar 2002 13:45 and 28 Mar 2002 06:01 would return true.

Usage

From source file:org.openhab.binding.astro.internal.calc.SunCalc.java

private Sun getSunInfo(Calendar calendar, double latitude, double longitude, boolean onlyAstro) {
    double lw = -longitude * DEG2RAD;
    double phi = latitude * DEG2RAD;
    double j = DateTimeUtils.midnightDateToJulianDate(calendar) + 0.5;
    double n = getJulianCycle(j, lw);
    double js = getApproxSolarTransit(0, lw, n);
    double m = getSolarMeanAnomaly(js);
    double c = getEquationOfCenter(m);
    double lsun = getEclipticLongitude(m, c);
    double d = getSunDeclination(lsun);
    double jtransit = getSolarTransit(js, m, lsun);
    double w0 = getHourAngle(H0, phi, d);
    double w1 = getHourAngle(H0 + SUN_DIAMETER, phi, d);
    double jset = getSunsetJulianDate(w0, m, lsun, lw, n);
    double jsetstart = getSunsetJulianDate(w1, m, lsun, lw, n);
    double jrise = getSunriseJulianDate(jtransit, jset);
    double jriseend = getSunriseJulianDate(jtransit, jsetstart);
    double w2 = getHourAngle(H1, phi, d);
    double jnau = getSunsetJulianDate(w2, m, lsun, lw, n);
    double Jciv2 = getSunriseJulianDate(jtransit, jnau);

    double w3 = getHourAngle(H2, phi, d);
    double w4 = getHourAngle(H3, phi, d);
    double jastro = getSunsetJulianDate(w3, m, lsun, lw, n);
    double jdark = getSunsetJulianDate(w4, m, lsun, lw, n);
    double jnau2 = getSunriseJulianDate(jtransit, jastro);
    double jastro2 = getSunriseJulianDate(jtransit, jdark);

    Sun sun = new Sun();
    sun.setAstroDawn(new Range(DateTimeUtils.toCalendar(jastro2), DateTimeUtils.toCalendar(jnau2)));
    sun.setAstroDusk(new Range(DateTimeUtils.toCalendar(jastro), DateTimeUtils.toCalendar(jdark)));

    if (onlyAstro) {
        return sun;
    }//from  w  w w .j  a v a  2 s.c  o m

    sun.setNoon(new Range(DateTimeUtils.toCalendar(jtransit),
            DateTimeUtils.toCalendar(jtransit + JD_ONE_MINUTE_FRACTION)));
    sun.setRise(new Range(DateTimeUtils.toCalendar(jrise), DateTimeUtils.toCalendar(jriseend)));
    sun.setSet(new Range(DateTimeUtils.toCalendar(jsetstart), DateTimeUtils.toCalendar(jset)));

    sun.setCivilDawn(new Range(DateTimeUtils.toCalendar(Jciv2), DateTimeUtils.toCalendar(jrise)));
    sun.setCivilDusk(new Range(DateTimeUtils.toCalendar(jset), DateTimeUtils.toCalendar(jnau)));

    sun.setNauticDawn(new Range(DateTimeUtils.toCalendar(jnau2), DateTimeUtils.toCalendar(Jciv2)));
    sun.setNauticDusk(new Range(DateTimeUtils.toCalendar(jnau), DateTimeUtils.toCalendar(jastro)));

    boolean isSunUpAllDay = isSunUpAllDay(calendar, latitude, longitude);

    // daylight
    Range daylightRange = new Range();
    if (sun.getRise().getStart() == null && sun.getRise().getEnd() == null) {
        if (isSunUpAllDay) {
            daylightRange = new Range(DateTimeUtils.truncateToMidnight(calendar),
                    DateTimeUtils.truncateToMidnight(addDays(calendar, 1)));
        }
    } else {
        daylightRange = new Range(sun.getRise().getEnd(), sun.getSet().getStart());
    }
    sun.setDaylight(daylightRange);

    // morning night
    Sun sunYesterday = getSunInfo(addDays(calendar, -1), latitude, longitude, true);
    Range morningNightRange = null;
    if (sunYesterday.getAstroDusk().getEnd() != null
            && DateUtils.isSameDay(sunYesterday.getAstroDusk().getEnd(), calendar)) {
        morningNightRange = new Range(sunYesterday.getAstroDusk().getEnd(), sun.getAstroDawn().getStart());
    } else if (isSunUpAllDay) {
        morningNightRange = new Range();
    } else {
        morningNightRange = new Range(DateTimeUtils.truncateToMidnight(calendar),
                sun.getAstroDawn().getStart());
    }
    sun.setMorningNight(morningNightRange);

    // evening night
    Range eveningNightRange = null;
    if (sun.getAstroDusk().getEnd() != null && DateUtils.isSameDay(sun.getAstroDusk().getEnd(), calendar)) {
        eveningNightRange = new Range(sun.getAstroDusk().getEnd(),
                DateTimeUtils.truncateToMidnight(addDays(calendar, 1)));
    } else {
        eveningNightRange = new Range();
    }
    sun.setEveningNight(eveningNightRange);

    // night
    if (isSunUpAllDay) {
        sun.setNight(new Range());
    } else {
        Sun sunTomorrow = getSunInfo(addDays(calendar, 1), latitude, longitude, true);
        sun.setNight(new Range(sun.getAstroDusk().getEnd(), sunTomorrow.getAstroDawn().getStart()));
    }

    // eclipse
    SunEclipse eclipse = sun.getEclipse();
    MoonCalc mc = new MoonCalc();

    double partial = mc.getEclipse(calendar, MoonCalc.ECLIPSE_TYPE_SUN, j, MoonCalc.ECLIPSE_MODE_PARTIAL);
    eclipse.setPartial(DateTimeUtils.toCalendar(partial));
    double ring = mc.getEclipse(calendar, MoonCalc.ECLIPSE_TYPE_SUN, j, MoonCalc.ECLIPSE_MODE_RING);
    eclipse.setRing(DateTimeUtils.toCalendar(ring));
    double total = mc.getEclipse(calendar, MoonCalc.ECLIPSE_TYPE_SUN, j, MoonCalc.ECLIPSE_MODE_TOTAL);
    eclipse.setTotal(DateTimeUtils.toCalendar(total));

    return sun;
}

From source file:org.openmrs.module.amrsreports.db.hibernate.MohHibernateCoreDAO.java

/**
 * post-process a list of observations from a criteria; duplicate data FTL
 *
 * @param criteria            the object with data in it
 * @param mohFetchRestriction information for limiting fetch, specifically the size
 * @return a list of processed (cleaned) observations
 *///from  ww  w  . j a v a  2 s  .c o m
private List<Obs> processObs(Criteria criteria, MohFetchRestriction mohFetchRestriction) {
    List<Obs> observations = new ArrayList<Obs>();

    // TODO: further optimization would be adding start date and end date parameter in the obs restrictions
    ScrollableResults scrollableResults = criteria.scroll(ScrollMode.FORWARD_ONLY);

    Integer size = mohFetchRestriction.getSize();

    // scroll the results
    Obs processedObs = null;
    while (scrollableResults.next() && OpenmrsUtil.compareWithNullAsGreatest(observations.size(), size) == -1) {
        Obs obs = (Obs) scrollableResults.get(0);
        // TODO: thanks to Ampath for the duplicate data, we need to sanitize the query results here
        if (processedObs != null && !obs.isObsGrouping()) {
            if (DateUtils.isSameDay(processedObs.getObsDatetime(), obs.getObsDatetime())
                    && OpenmrsUtil.nullSafeEquals(processedObs.getConcept(), obs.getConcept())
                    && OpenmrsUtil.nullSafeEquals(processedObs.getValueCoded(), obs.getValueCoded())
                    && (OpenmrsUtil.nullSafeEquals(processedObs.getValueNumeric(), obs.getValueNumeric()))) {
                continue;
            }
        }
        processedObs = obs;
        observations.add(obs);
    }
    scrollableResults.close();
    return observations;
}

From source file:org.openmrs.module.clinicalsummary.db.hibernate.HibernateCoreDAO.java

/**
 * @see CoreDAO#getPatientObservations(Integer, java.util.Map, org.openmrs.module.clinicalsummary.util.FetchRestriction)
 */// w ww. j a  v  a  2 s .  co  m
@Override
public List<Obs> getPatientObservations(final Integer patientId,
        final Map<String, Collection<OpenmrsObject>> restrictions, final FetchRestriction fetchRestriction)
        throws DAOException {
    Criteria criteria = sessionFactory.getCurrentSession().createCriteria(Obs.class);
    criteria.createAlias("person", "person");
    criteria.add(Restrictions.eq("person.personId", patientId));

    criteria.setFirstResult(0);
    if (fetchRestriction.getStart() != null)
        criteria.setFirstResult(fetchRestriction.getStart());

    if (fetchRestriction.getSize() != null && fetchRestriction.getSize() == 1)
        criteria.setMaxResults(fetchRestriction.getSize());

    Order order = Order.desc("obsDatetime");
    if (OpenmrsUtil.nullSafeEquals(FetchOrdering.ORDER_ASCENDING, fetchRestriction.getFetchOrdering()))
        order = Order.asc("obsDatetime");

    criteria.addOrder(order);

    Obs observation = new Obs();
    for (String property : restrictions.keySet()) {
        Collection<OpenmrsObject> propertyValues = restrictions.get(property);
        if (CollectionUtils.isNotEmpty(propertyValues) && PropertyUtils.isReadable(observation, property)) {
            criteria.add(Restrictions.in(property, propertyValues));
            criteria.addOrder(Order.asc(property));
        }
    }

    criteria.add(Restrictions.eq("voided", Boolean.FALSE));

    List<Obs> observations = new ArrayList<Obs>();

    // TODO: further optimization would be adding start date and end date parameter in the obs restrictions
    ScrollableResults scrollableResults = criteria.scroll(ScrollMode.FORWARD_ONLY);

    Integer size = fetchRestriction.getSize();

    // scroll the results
    Obs processedObs = null;
    while (scrollableResults.next() && OpenmrsUtil.compareWithNullAsGreatest(observations.size(), size) == -1) {
        Obs obs = (Obs) scrollableResults.get(0);
        // TODO: thanks to Ampath for the duplicate data, we need to sanitize the query results here
        if (processedObs != null && !obs.isObsGrouping()) {
            if (DateUtils.isSameDay(processedObs.getObsDatetime(), obs.getObsDatetime())
                    && OpenmrsUtil.nullSafeEquals(processedObs.getConcept(), obs.getConcept())
                    && OpenmrsUtil.nullSafeEquals(processedObs.getValueCoded(), obs.getValueCoded())
                    && (OpenmrsUtil.nullSafeEquals(processedObs.getValueNumeric(), obs.getValueNumeric())))
                continue;
        }
        processedObs = obs;
        observations.add(obs);
    }
    scrollableResults.close();
    return observations;
}

From source file:org.openmrs.module.clinicalsummary.rule.flowsheet.FlowsheetUtils.java

/**
 * Slice the flow-sheet to match the total number and record configuration needed
 *
 * @param results the result//from w  w  w. jav  a  2 s . c o m
 * @return results object arranged in a certain way
 */
public static Result slice(final Result results) {

    if (CollectionUtils.isEmpty(results))
        return results;

    Result slicedResults = new Result();

    // result is ordered descending, last result is the earliest result
    Result firstResult = results.get(CollectionUtils.size(results) - 1);
    slicedResults.add(firstResult);

    if (results.size() > slicedResults.size()) {
        //  get the last four results
        Integer counter = 0;
        Result otherResults = new Result();
        while (counter < results.size() - 1 && counter < FlowsheetParameters.FLOWSHEET_MAX_SIZE - 1) {
            Result result = results.get(counter++);
            // skip some not not valid results
            if (DateUtils.isSameDay(firstResult.getResultDate(), result.getResultDate())
                    && OpenmrsUtil.nullSafeEquals(firstResult.getDatatype(), result.getDatatype())) {
                if (OpenmrsUtil.nullSafeEquals(result.getDatatype(), Result.Datatype.NUMERIC)
                        && OpenmrsUtil.nullSafeEquals(firstResult.toNumber(), result.toNumber())
                        || (OpenmrsUtil.nullSafeEquals(result.getDatatype(), Result.Datatype.CODED)
                                && OpenmrsUtil.nullSafeEquals(firstResult.toConcept(), result.toConcept())))
                    continue;
            }
            // get the latest results
            otherResults.add(result);
        }

        // flip them to make the order from earliest to latest
        Collections.reverse(otherResults);
        // add all of them to the oldest result, we now have results from earliest to latest
        slicedResults.addAll(otherResults);
        // flip them back to make the order from latest to the earliest
        Collections.reverse(slicedResults);
    }

    return slicedResults;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.adult.general.LowCorpuscularVolumeReminderRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*www  .  j a  v a 2  s  . co  m*/
@Override
protected Result evaluate(final LogicContext context, final Integer patientId,
        final Map<String, Object> parameters) throws LogicException {

    Result result = new Result();

    ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();
    parameters.put(EvaluableConstants.OBS_CONCEPT,
            Arrays.asList(EvaluableNameConstants.MEAN_CORPUSCULAR_VOLUME));
    parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 1);
    Result corpuscularResults = obsWithRestrictionRule.eval(context, patientId, parameters);
    if (CollectionUtils.isNotEmpty(corpuscularResults)) {
        Result latestCorpuscularResult = corpuscularResults.latest();
        if (latestCorpuscularResult.toNumber() < 75) {
            parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList(EvaluableNameConstants.HEMOGLOBIN));
            Result hbResults = obsWithRestrictionRule.eval(context, patientId, parameters);
            if (CollectionUtils.isNotEmpty(hbResults)) {
                Result latestHbResult = hbResults.latest();
                if (latestHbResult.toNumber() < 10) {
                    Boolean displayReminder = Boolean.TRUE;

                    Result medicationResults;
                    parameters.put(EvaluableConstants.OBS_CONCEPT,
                            Arrays.asList(EvaluableNameConstants.MEDICATION_ADDED,
                                    "RECEIVED ANTENATAL CARE SERVICE THIS VISIT",
                                    "PATIENT REPORTED CURRENT ANTENATAL CARE TREATMENT",
                                    "RECIEVED POSTNATAL CARE SERVICE THIS VISIT", "CURRENT MEDICATIONS"));
                    parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                            Arrays.asList(EvaluableNameConstants.IRON_SUPPLEMENT, "FERROUS SULFATE",
                                    "FERROUS SULFATE AND FOLIC ACID"));
                    medicationResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                    if (CollectionUtils.isEmpty(medicationResults)) {
                        // see if any of the medication is after the low corpuscular volume
                        Integer counter = 0;
                        while (counter < CollectionUtils.size(medicationResults)) {
                            Result medicationResult = medicationResults.get(counter++);
                            if (medicationResult.getResultDate().after(latestCorpuscularResult.getResultDate())
                                    || DateUtils.isSameDay(medicationResult.getResultDate(),
                                            latestCorpuscularResult.getResultDate())) {
                                displayReminder = Boolean.FALSE;
                                break;
                            }
                        }
                    }

                    // no iron supplement found
                    if (displayReminder) {
                        result.add(new Result(
                                String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
                    }
                }
            }
        }
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.adult.pregnancy.SecondLineViralLoadReminderRule.java

@Override
protected Result evaluate(LogicContext context, Integer patientId, Map<String, Object> parameters) {
    Result result = new Result();

    ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();

    parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList("HIV VIRAL LOAD, QUANTITATIVE"));
    parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 2);
    Result viralLoadResults = obsWithRestrictionRule.eval(context, patientId, parameters);

    if (CollectionUtils.isNotEmpty(viralLoadResults) && CollectionUtils.size(viralLoadResults) == 2) {

        Result latestViralLoadResult = viralLoadResults.get(0);
        Result beforeLatestViralLoadResult = viralLoadResults.get(1);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(latestViralLoadResult.getResultDate());
        calendar.add(Calendar.MONTH, -3);
        Date threeMonthsAgo = calendar.getTime();

        if ((beforeLatestViralLoadResult.getResultDate().before(threeMonthsAgo)
                || DateUtils.isSameDay(beforeLatestViralLoadResult.getResultDate(), threeMonthsAgo))
                && latestViralLoadResult.toNumber() > 1000 && beforeLatestViralLoadResult.toNumber() > 1000) {

            parameters.put(EvaluableConstants.OBS_CONCEPT,
                    Arrays.asList("HIV ANTIRETROVIRAL DRUG PLAN TREATMENT CATEGORY"));
            parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                    Arrays.asList("SECOND LINE HIV ANTIRETROVIRAL DRUG TREATMENT"));
            Result antiretroviralPlanResults = obsWithRestrictionRule.eval(context, patientId, parameters);

            if (CollectionUtils.isNotEmpty(antiretroviralPlanResults)) {
                result.add(//  w ww  .  j  ava  2  s  .co m
                        new Result(String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
                return result;
            }
        }
    }
    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.adult.pregnancy.SwitchLineViralLoadReminderRule.java

@Override
protected Result evaluate(LogicContext context, Integer patientId, Map<String, Object> parameters) {
    Result result = new Result();

    EncounterWithRestrictionRule encounterWithRestrictionRule = new EncounterWithStringRestrictionRule();
    parameters.put(EvaluableConstants.ENCOUNTER_TYPE,
            Arrays.asList(EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_INITIAL,
                    EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_RETURN));
    parameters.put(EvaluableConstants.ENCOUNTER_FETCH_SIZE, 1);
    Result encounterResults = encounterWithRestrictionRule.eval(context, patientId, parameters);
    if (CollectionUtils.isNotEmpty(encounterResults)) {
        Result encounterResult = encounterResults.latest();

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(encounterResult.getResultDate());
        calendar.add(Calendar.MONTH, 12);
        Date twelveMonthsLater = calendar.getTime();

        ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();

        parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList("HIV VIRAL LOAD, QUANTITATIVE"));
        parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 2);
        Result viralLoadResults = obsWithRestrictionRule.eval(context, patientId, parameters);

        parameters.put(EvaluableConstants.OBS_CONCEPT,
                Arrays.asList("CURRENT HIV ANTIRETROVIRAL DRUG USE TREATMENT CATEGORY",
                        "HIV ANTIRETROVIRAL DRUG PLAN TREATMENT CATEGORY"));
        parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                Arrays.asList("FIRST LINE HIV ANTIRETROVIRAL DRUG TREATMENT"));
        Result treatmentCategoryResults = obsWithRestrictionRule.eval(context, patientId, parameters);
        if (CollectionUtils.isNotEmpty(treatmentCategoryResults) && CollectionUtils.isNotEmpty(viralLoadResults)
                && CollectionUtils.size(viralLoadResults) == 2) {

            Result latestViralLoadResult = viralLoadResults.get(0);
            Result beforeLatestViralLoadResult = viralLoadResults.get(1);

            calendar.setTime(latestViralLoadResult.getResultDate());
            calendar.add(Calendar.MONTH, -3);
            Date threeMonthsAgo = calendar.getTime();

            if ((beforeLatestViralLoadResult.getResultDate().after(threeMonthsAgo)
                    || DateUtils.isSameDay(beforeLatestViralLoadResult.getResultDate(), threeMonthsAgo))
                    && latestViralLoadResult.toNumber() > 1000
                    && beforeLatestViralLoadResult.toNumber() > 1000) {

                parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList("ANTIRETROVIRAL PLAN"));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList("START DRUGS", "DRUG RESTART"));
                Result antiretroviralPlanResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(antiretroviralPlanResults)
                        && (antiretroviralPlanResults.latest().getResultDate().after(twelveMonthsLater)
                                || DateUtils.isSameDay(antiretroviralPlanResults.latest().getResultDate(),
                                        twelveMonthsLater))) {
                    result.add(new Result(
                            String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
                    return result;
                }//from   ww w.  j  a  v a  2  s.  co m

                parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList("REASON ANTIRETROVIRALS STARTED"));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList("POST EXPOSURE PROPHYLAXIS", "TREATMENT",
                                "TOTAL MATERNAL TO CHILD TRANSMISSION PROPHYLAXIS", "CLINICAL DISEASE",
                                "PREVENTION OF MOTHER-TO-CHILD TRANSMISSION OF HIV", "UNKNOWN",
                                "ADULT WHO STAGE 3 WITH CD4 COUNT LESS THAN 350", "WHO STAGE 3 ADULT",
                                "WHO STAGE 4 ADULT", "CD4 COUNT LESS THAN 350", "DISCORDANT COUPLE",
                                "IMMUNOLOGIC FAILURE", "VIROLOGIC FAILURE", "CD4 COUNT LESS THAN 500"));
                Result reasonStartedResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(reasonStartedResults)) {
                    Result reasonStartedResult = reasonStartedResults.latest();
                    if (reasonStartedResult.getResultDate().after(twelveMonthsLater)
                            || DateUtils.isSameDay(reasonStartedResult.getResultDate(), twelveMonthsLater)) {
                        result.add(new Result(
                                String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
                        return result;
                    }
                }
            }
        }
    }
    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.peds.polymerase.RepeatPolymeraseReminderRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//* w w w .jav a 2  s.c  om*/
@Override
protected Result evaluate(final LogicContext context, final Integer patientId,
        final Map<String, Object> parameters) throws LogicException {
    Result result = new Result();

    Patient patient = Context.getPatientService().getPatient(patientId);

    if (patient.getBirthdate() != null) {

        Calendar calendar = Calendar.getInstance();

        // 18 months after birth date
        calendar.setTime(patient.getBirthdate());
        calendar.add(Calendar.MONTH, 18);
        Date eighteenMonths = calendar.getTime();

        // 6 weeks after birth date
        calendar.setTime(patient.getBirthdate());
        calendar.add(Calendar.WEEK_OF_YEAR, 6);
        Date sixWeeks = calendar.getTime();

        if (sixWeeks.before(new Date()) && eighteenMonths.after(new Date())) {
            ValidPolymeraseRule validPolymeraseRule = new ValidPolymeraseRule();
            // only pull the positive and negative results
            parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 2);
            parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                    Arrays.asList(EvaluableNameConstants.POSITIVE, EvaluableNameConstants.NEGATIVE));
            parameters.put(EvaluableConstants.OBS_CONCEPT,
                    Arrays.asList(EvaluableNameConstants.HIV_DNA_POLYMERASE_CHAIN_REACTION_QUALITATIVE));
            Result validPolymeraseResults = validPolymeraseRule.eval(context, patientId, parameters);

            if (CollectionUtils.isNotEmpty(validPolymeraseResults)
                    && CollectionUtils.size(validPolymeraseResults) < 2) {

                Result validPolymeraseResult = validPolymeraseResults.latest();

                // get the latest test ordered
                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.TESTS_ORDERED));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.HIV_DNA_POLYMERASE_CHAIN_REACTION_QUALITATIVE));

                ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();
                Result testResults = obsWithRestrictionRule.eval(context, patientId, parameters);

                calendar.setTime(patient.getBirthdate());
                calendar.add(Calendar.WEEK_OF_YEAR, 4);
                Date fourWeeks = calendar.getTime();

                calendar.setTime(new Date());
                calendar.add(Calendar.MONTH, -6);
                Date sixMonthsAgo = calendar.getTime();

                int pendingCount = 0;
                for (Result testResult : testResults) {
                    // test is valid if it's performed after four weeks and after six months ago and not the same with the date of the result
                    if (testResult.getResultDate().after(sixMonthsAgo)
                            && testResult.getResultDate().after(fourWeeks)
                            && !DateUtils.isSameDay(testResult.getResultDate(),
                                    validPolymeraseResult.getResultDate()))
                        pendingCount++;
                }

                if (pendingCount + validPolymeraseResults.size() < 2)
                    result.add(new Result(
                            String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
            }
        }
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.util.ResultUtils.java

/**
 * Strip duplicates result object//from w w  w  . j a v a 2s  . com
 *
 * @param results the results with duplicates
 * @return results without duplicates
 */
public static Result stripDuplicates(final Result results) {

    if (CollectionUtils.isEmpty(results))
        return results;

    Result strippedResults = new Result();

    Integer parentCounter = 0;
    while (parentCounter < CollectionUtils.size(results)) {
        Result referredResult = results.get(parentCounter++);
        // search for duplicates and remove them
        Integer childCounter = parentCounter;
        Boolean duplicateFound = Boolean.FALSE;
        while (childCounter < CollectionUtils.size(results) && !duplicateFound) {
            Result currentResult = results.get(childCounter++);
            if (DateUtils.isSameDay(referredResult.getResultDate(), currentResult.getResultDate())
                    && OpenmrsUtil.nullSafeEquals(referredResult.getDatatype(), currentResult.getDatatype())) {
                if (OpenmrsUtil.nullSafeEquals(currentResult.getDatatype(), Result.Datatype.NUMERIC)
                        && OpenmrsUtil.nullSafeEquals(referredResult.toNumber(), currentResult.toNumber())
                        || (OpenmrsUtil.nullSafeEquals(currentResult.getDatatype(), Result.Datatype.CODED)
                                && OpenmrsUtil.nullSafeEquals(referredResult.toConcept(),
                                        currentResult.toConcept()))) {
                    duplicateFound = Boolean.TRUE;
                }
            }
        }

        if (!duplicateFound)
            strippedResults.add(referredResult);
    }

    return strippedResults;
}

From source file:org.openmrs.module.clinicalsummary.task.OrderedObsProcessor.java

/**
 * @param observations//from w  w w .  j a v a 2s.  co  m
 * @return
 */
private List<Obs> stripDuplicate(final List<Obs> observations) {

    if (CollectionUtils.isEmpty(observations))
        return observations;

    List<Obs> strippedObservations = new ArrayList<Obs>();
    while (observations.size() > 0) {
        Obs referredObs = observations.remove(0);

        // search for duplicates and remove them
        int counter = 0;
        while (observations.size() > counter) {
            Obs currentObs = observations.get(counter);

            if (DateUtils.isSameDay(referredObs.getObsDatetime(), currentObs.getObsDatetime())
                    && OpenmrsUtil.nullSafeEquals(referredObs.getConcept(), currentObs.getConcept())) {

                if (OpenmrsUtil.nullSafeEquals(referredObs.getValueNumeric(), currentObs.getValueNumeric())
                        || OpenmrsUtil.nullSafeEquals(referredObs.getValueCoded(),
                                currentObs.getValueCoded())) {
                    Obs removedObs = observations.remove(counter);
                    saveOrderedObs(removedObs, StatusType.STATUS_DUPLICATE_RESULTS);
                    continue;
                }
            }
            counter++;
        }

        strippedObservations.add(referredObs);
    }

    Context.flushSession();
    Context.clearSession();

    return strippedObservations;
}