Example usage for org.apache.commons.collections CollectionUtils size

List of usage examples for org.apache.commons.collections CollectionUtils size

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections.*
  5. CollectionUtils
  6. size

Introduction

In this page you can find the example usage for org.apache.commons.collections CollectionUtils size.

Prototype

public static int size(Object object)

Source Link

Document

Gets the size of the collection/iterator specified.

Usage

From source file:org.openmrs.module.clinicalsummary.rule.antenatal.grouped.EncounterBasedNoFilterRule.java

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

    Result result = new Result();

    EncounterWithRestrictionRule encounterWithRestrictionRule = new EncounterWithStringRestrictionRule();
    Result encounterResults = encounterWithRestrictionRule.eval(context, patientId, parameters);
    // take out the encounter type for the reference encounter
    Object encounterType = parameters.remove(AncParameters.AFTER_ENCOUNTER_TYPE);
    // prepare the parameters
    parameters.put(EvaluableConstants.ENCOUNTER_FETCH_SIZE, 1);
    parameters.put(EvaluableConstants.ENCOUNTER_TYPE, Arrays.asList(encounterType));
    Result afterEncounterResults = encounterWithRestrictionRule.eval(context, patientId, parameters);
    // see if we can get the reference encounter
    Object afterEncounter = null;
    if (CollectionUtils.isNotEmpty(afterEncounterResults))
        afterEncounter = afterEncounterResults.latest().getResultObject();

    ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();

    int counter = 0;
    Boolean foundAfter = Boolean.FALSE;
    while (counter < CollectionUtils.size(encounterResults) && !foundAfter) {
        Result encounterResult = encounterResults.get(counter);

        parameters.put(EvaluableConstants.OBS_ENCOUNTER, Arrays.asList(encounterResult.getResultObject()));
        Result obsResults = obsWithRestrictionRule.eval(context, patientId, parameters);

        if (CollectionUtils.isNotEmpty(obsResults))
            result.addAll(obsResults);

        if (OpenmrsUtil.nullSafeEquals(afterEncounter, encounterResult.getResultObject()))
            foundAfter = Boolean.TRUE;

        counter++;
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.common.CohortBuilderRule.java

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

    String dateString = DATE_CUTOFF_POINT;
    Date initialDate = RuleUtils.parse(dateString, null);
    if (initialDate != null) {

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(initialDate);
        calendar.add(Calendar.MONTH, 5);
        Date cutoffDate = calendar.getTime();

        EncounterWithRestrictionRule encounterWithRestrictionRule = new EncounterWithStringRestrictionRule();

        parameters.put(EvaluableConstants.ENCOUNTER_FETCH_SIZE, 1);
        parameters.put(EvaluableConstants.ENCOUNTER_LOCATION, Arrays.asList(ENCOUNTER_LOCATION_MTRH_MODULE_4,
                ENCOUNTER_LOCATION_TURBO, ENCOUNTER_LOCATION_KITALE, ENCOUNTER_LOCATION_WEBUYE));
        Result encounterResults = encounterWithRestrictionRule.eval(context, patientId, parameters);

        if (CollectionUtils.isNotEmpty(encounterResults)
                && encounterResults.getResultDate().after(cutoffDate)) {

            Result encounterResult = encounterResults.latest();
            Encounter encounter = (Encounter) encounterResult.getResultObject();
            Location encounterLocation = encounter.getLocation();

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

            Integer age = patient.getAge();
            if (age != null && age >= 6 && age <= 14) {

                Result obsResult = null;

                ObsWithRestrictionRule obsWithRestrictionRule = new ObsWithStringRestrictionRule();

                parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 1);

                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.PROBLEM_ADDED));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.HIV_INFECTED));
                Result problemAddedResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(problemAddedResults))
                    obsResult = problemAddedResults.latest();

                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.HIV_TEST_RESULT_THIS_VISIT));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.POSITIVE));
                Result hivTestResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(hivTestResults))
                    obsResult = hivTestResults.latest();

                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.HIV_ENZYME_IMMUNOASSAY_QUALITATIVE));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.POSITIVE));
                Result elisaResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(elisaResults))
                    obsResult = elisaResults.latest();

                parameters.put(EvaluableConstants.OBS_FETCH_SIZE, 2);

                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.HIV_DNA_POLYMERASE_CHAIN_REACTION_QUALITATIVE));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.POSITIVE));
                Result polymeraseResults = obsWithRestrictionRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(polymeraseResults)
                        && CollectionUtils.size(polymeraseResults) >= 2)
                    obsResult = polymeraseResults.latest();

                if (obsResult != null) {
                    Obs obs = (Obs) obsResult.getResultObject();
                    result.add(new Result(encounter.getEncounterDatetime(), null, null, obs.getConcept(),
                            obs.getObsDatetime(), obs.getObsId().doubleValue(), encounterLocation.getName(),
                            obs.getValueCoded()));
                }
            }
        }
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.encounter.EncounterWithObjectRestrictionRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*from  w ww  .  j  a v  a2  s .  c  o m*/
@Override
@SuppressWarnings("unchecked")
protected Result evaluate(final LogicContext context, final Integer patientId,
        final Map<String, Object> parameters) throws LogicException {

    // this rule can process the following parameters:
    // - list of encounter type (map key: EvaluableConstants.ENCOUNTER_TYPE)
    // - list of location (map key: EvaluableConstants.LOCATION)
    // - number of encounter that should be returned (map key: EvaluableConstants.ENCOUNTER_FETCH_SIZE)
    // - ordering on the encounter datetime (map key: EvaluableConstants.ENCOUNTER_FETCH_ORDER)

    Result result = new Result();
    // we will pass this restrictions to core service to get the correct encounters
    Map<String, Collection<OpenmrsObject>> restrictions = new HashMap<String, Collection<OpenmrsObject>>();

    // get list of encounter types from the parameters
    Object encounterTypeObjects = parameters.get(EvaluableConstants.ENCOUNTER_TYPE);
    if (RuleUtils.isValidCollectionObject(encounterTypeObjects))
        restrictions.put(EvaluableConstants.ENCOUNTER_TYPE, (Collection<OpenmrsObject>) encounterTypeObjects);
    // get list of locations from the parameters
    Object locationObjects = parameters.get(EvaluableConstants.ENCOUNTER_LOCATION);
    if (RuleUtils.isValidCollectionObject(locationObjects))
        restrictions.put(EvaluableConstants.ENCOUNTER_LOCATION, (Collection<OpenmrsObject>) locationObjects);
    // get list of providers from the parameters (currently this is not supported)
    Object providerObjects = parameters.get(EvaluableConstants.ENCOUNTER_PROVIDER);
    if (RuleUtils.isValidCollectionObject(providerObjects))
        restrictions.put(EvaluableConstants.ENCOUNTER_PROVIDER, (Collection<OpenmrsObject>) providerObjects);

    // this fetch restriction will define how many records should be returned and how they will be ordered
    FetchRestriction fetchRestriction = new FetchRestriction();
    // specify how many records should be returned
    Object sizeObject = parameters.get(EvaluableConstants.ENCOUNTER_FETCH_SIZE);
    if (RuleUtils.isValidSizeObject(sizeObject))
        fetchRestriction.setSize(NumberUtils.toInt(sizeObject.toString()));
    // specify how the record will be ordered (ascending or descending by encounter datetime)
    Object orderObject = parameters.get(EvaluableConstants.ENCOUNTER_FETCH_ORDER);
    if (RuleUtils.isValidOrderObject(orderObject))
        fetchRestriction.setFetchOrdering(orderObject.toString());

    // call the core service to search for the matching encounters
    CoreService coreService = Context.getService(CoreService.class);
    // pass the patient id, restrictions map and the fetch restriction in the service call
    List<Encounter> encounters = coreService.getPatientEncounters(patientId, restrictions, fetchRestriction);

    if (log.isDebugEnabled())
        log.debug("Patient: " + patientId + ", encounters size:" + CollectionUtils.size(encounters));

    // iterate over the encounters and then wrap them into a logic's result object
    // check the result object implementation to see how to create result object and how to pull data from them
    for (Encounter encounter : encounters) {
        Date encounterDatetime = encounter.getEncounterDatetime();
        EncounterType type = encounter.getEncounterType();
        String encounterTypeName = StringUtils.EMPTY;
        if (type != null)
            encounterTypeName = type.getName();
        result.add(new Result(encounterDatetime, encounterTypeName, encounter));
    }

    return result;
}

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.  j  a v a2 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.primary.ConceptSetBasedObsRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*from  w w  w .  ja va 2s . c o  m*/
@Override
@SuppressWarnings("unchecked")
protected Result evaluate(final LogicContext context, final Integer patientId,
        final Map<String, Object> parameters) throws LogicException {

    Result result = new Result();

    Object conceptSetObjects = parameters.remove(PrimaryCareParameters.OBS_CONCEPT_SET_MEMBERS);
    Map<Concept, Integer> conceptSetPositions = searchPositions(conceptSetObjects);

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

    for (Result parentObsResult : parentObsResults) {
        Obs parentObs = (Obs) parentObsResult.getResultObject();
        if (parentObs.isObsGrouping()) {
            Set<Obs> childObservations = parentObs.getGroupMembers();

            Result groupedResult = new Result();
            groupedResult.add(new Result(parentObsResult.getResultDate()));
            Result[] results = new Result[CollectionUtils.size(conceptSetPositions)];
            for (Obs childObservation : childObservations) {
                Integer position = conceptSetPositions.get(childObservation.getConcept());
                if (position != null)
                    results[position] = new Result(childObservation);
            }
            groupedResult.addAll(Arrays.asList(results));
            result.add(groupedResult);
        }
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.primary.ConceptSetBasedObsRule.java

@SuppressWarnings("unchecked")
private Map<Concept, Integer> searchPositions(Object conceptSetObjects) {
    Map<Concept, Integer> conceptSetPositions = new HashMap<Concept, Integer>();
    if (RuleUtils.isValidCollectionObject(conceptSetObjects)) {
        List<String> conceptSetNames = (List<String>) conceptSetObjects;
        for (int counter = 0; counter < CollectionUtils.size(conceptSetNames); counter++) {
            Concept concept = CacheUtils.getConcept(conceptSetNames.get(counter));
            conceptSetPositions.put(concept, counter);
        }/*from   www  . j  a v  a2  s. com*/
    }
    return conceptSetPositions;
}

From source file:org.openmrs.module.clinicalsummary.rule.primary.GroupedObservationRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*from   w  w w .  j  ava 2s.  com*/
@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();
    Result results = obsWithRestrictionRule.eval(context, patientId, parameters);

    int counter = 0;
    Map<Concept, Result> groupedResult = new HashMap<Concept, Result>();
    while (counter < CollectionUtils.size(results)) {
        Result obsResult = results.get(counter++);
        Obs obs = (Obs) obsResult.getResultObject();
        Concept concept = obs.getConcept();
        Result resultList = groupedResult.get(concept);
        if (resultList == null) {
            resultList = new Result();
            groupedResult.put(concept, resultList);
        }
        resultList.add(obsResult);
    }

    for (Concept concept : groupedResult.keySet()) {
        result.add(groupedResult.get(concept));
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.adult.cluster.FallingCD4OnARVReminderRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//* w  w w. ja 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_FETCH_SIZE, 2);
    parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList(EvaluableNameConstants.CD4_COUNT));
    Result clusterResults = obsWithRestrictionRule.eval(context, patientId, parameters);
    // only process when we have at least two results
    if (CollectionUtils.size(clusterResults) >= 2) {
        Calendar calendar = Calendar.getInstance();
        // three months ago
        calendar.add(Calendar.MONTH, -3);
        Date threeMonthsAgo = calendar.getTime();
        // we already know there's at least two results, so we can use the magic number here to get last and second from last result
        Result currentClusterResult = clusterResults.get(0);
        Result previousClusterResult = clusterResults.get(1);
        Double percentage = (previousClusterResult.toNumber() - currentClusterResult.toNumber())
                / previousClusterResult.toNumber();
        if (currentClusterResult.getResultDate().before(threeMonthsAgo) && percentage > 0.5) {

            AntiRetroViralRule antiRetroViralRule = new AntiRetroViralRule();
            // prepare the encounter types
            parameters.put(EvaluableConstants.ENCOUNTER_TYPE,
                    Arrays.asList(EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_INITIAL,
                            EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_RETURN,
                            EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_NONCLINICALMEDICATION));
            Result arvResults = antiRetroViralRule.eval(context, patientId, parameters);
            if (CollectionUtils.isNotEmpty(arvResults)) {
                // we don't want to limit the search on the test
                parameters.remove(EvaluableConstants.OBS_FETCH_SIZE);
                // search for the test
                parameters.put(EvaluableConstants.OBS_CONCEPT,
                        Arrays.asList(EvaluableNameConstants.TESTS_ORDERED));
                parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                        Arrays.asList(EvaluableNameConstants.CD4_PANEL,
                                EvaluableNameConstants.HIV_DNA_POLYMERASE_CHAIN_REACTION_QUALITATIVE,
                                EvaluableNameConstants.HIV_VIRAL_LOAD_QUANTITATIVE));
                Result testResults = obsWithRestrictionRule.eval(context, patientId, parameters);

                calendar.setTime(currentClusterResult.getResultDate());
                calendar.add(Calendar.MONTH, 3);
                Date threeMonthsAfterResult = calendar.getTime();

                Boolean testExists = Boolean.FALSE;

                Integer testCounter = 0;
                while (testCounter < testResults.size() && !testExists) {
                    Result testResult = testResults.get(testCounter++);
                    if (testResult.getResultDate().before(threeMonthsAfterResult)
                            && testResult.getResultDate().after(currentClusterResult.getResultDate()))
                        testExists = Boolean.TRUE;
                }

                if (!testExists)
                    result.add(new Result(
                            String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
            }
        }
    }

    return result;
}

From source file:org.openmrs.module.clinicalsummary.rule.reminder.adult.cluster.Over300CD4ExpressCareReminderRule.java

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*from  ww  w  .  j a  v  a 2s.  c  o  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.HIV_VIRAL_LOAD_QUANTITATIVE));
    parameters.put(EvaluableConstants.ENCOUNTER_FETCH_SIZE, 2);
    Result obsClusterResults = obsWithRestrictionRule.eval(context, patientId, parameters);
    if (CollectionUtils.size(obsClusterResults) > 1) {
        Result latestClusterResult = obsClusterResults.get(0);
        Result previousClusterResult = obsClusterResults.get(1);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(latestClusterResult.getResultDate());
        calendar.add(Calendar.MONTH, -6);
        Date sixMonthsBefore = calendar.getTime();

        if (latestClusterResult.toNumber() < 1000 && previousClusterResult.toNumber() < 1000
                && previousClusterResult.getResultDate().before(sixMonthsBefore)) {
            parameters.put(EvaluableConstants.OBS_CONCEPT,
                    Arrays.asList(EvaluableNameConstants.REFERRALS_ORDERED));
            parameters.put(EvaluableConstants.OBS_VALUE_CODED,
                    Arrays.asList(EvaluableNameConstants.EXPRESS_CARE_PROGRAM,
                            EvaluableNameConstants.LOW_RISK_EXPRESS_CARE_PROGRAM));
            Result referralResults = obsWithRestrictionRule.eval(context, patientId, parameters);
            if (CollectionUtils.isEmpty(referralResults)) {
                parameters.put(EvaluableConstants.ENCOUNTER_TYPE,
                        Arrays.asList(EvaluableNameConstants.ECSTABLE));
                EncounterWithRestrictionRule encounterWithRestrictionRule = new EncounterWithStringRestrictionRule();
                Result stableEncounterResults = encounterWithRestrictionRule.eval(context, patientId,
                        parameters);

                AntiRetroViralRule antiRetroViralRule = new AntiRetroViralRule();
                // prepare the encounter types
                parameters.put(EvaluableConstants.ENCOUNTER_TYPE,
                        Arrays.asList(EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_INITIAL,
                                EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_RETURN,
                                EvaluableNameConstants.ENCOUNTER_TYPE_ADULT_NONCLINICALMEDICATION));
                Result arvResults = antiRetroViralRule.eval(context, patientId, parameters);
                if (CollectionUtils.isNotEmpty(arvResults) && CollectionUtils.isEmpty(stableEncounterResults))
                    result.add(new Result(
                            String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
            }
        }
    }

    return result;
}

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

/**
 * @see org.openmrs.logic.Rule#eval(org.openmrs.logic.LogicContext, Integer, java.util.Map)
 *//*from   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_FETCH_SIZE, 2);
    parameters.put(EvaluableConstants.OBS_CONCEPT, Arrays.asList(EvaluableNameConstants.WEIGHT_KG));
    Result weightResults = obsWithRestrictionRule.eval(context, patientId, parameters);
    // only process when we have at least two results
    if (CollectionUtils.size(weightResults) >= 2) {
        // we already know there's at least two results, so we can use the magic number here to get last and second from last result
        Result firstWeightResult = weightResults.get(0);
        Result secondWeightResult = weightResults.get(1);
        Double weightDrop = secondWeightResult.toNumber() - firstWeightResult.toNumber();
        Double weightDropPercentage = weightDrop / secondWeightResult.toNumber();

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(firstWeightResult.getResultDate());
        calendar.add(Calendar.MONTH, -6);
        Date sixMonthsBefore = calendar.getTime();
        if (weightDropPercentage > 0.1 && secondWeightResult.getResultDate().after(sixMonthsBefore)) {
            result.add(new Result(String.valueOf(parameters.get(ReminderParameters.DISPLAYED_REMINDER_TEXT))));
        }
    }

    return result;
}